Java回顾 封装 继承和多态
封装
什么是封装
封装:就是隐藏对象的属性和实现细节,仅对外提供公共访问方式。
封装时的权限控制符区别如下:
封装的意义
对于封装而言,一个对象它所封装的是自己的属性和方法,所以它是不需要依赖其他对象就可以完成自己的操作。使用封装有四大好处:
- 良好的封装能够减少耦合。( 耦合是指两个或两个以上的电路元件或电网络的输入与输出之间存在紧密配合与相互影响,并通过相互作用从一侧向另一侧传输能量的现象。 )
- 类内部的结构可以自由修改
- 可以对成员进行更精确的控制
- 隐藏信息,实现细节。
封装把一个对象的属性私有化,同时提供一些可以被外界访问属性的方法,如果不想被外界访问,我们大可不必提供方法给外界访问。但是如果一个类没有提供给外界访问的方法,那么这个类也没有什么意义了。
实现Java封装的步骤
- 修改属性的可见性来限制对象的访问(一般限制为private),例如:
public class Person(){private String name;private int age;
}
这段代码中,将 name 和 age 属性设置为私有的,只能本类才能访问,其他类都访问不了,如此就对信息进行了隐藏。
- 对每个值属性提供对外的公共方法访问,也就是创建一对赋取值,用于对私有属性的访问,例如:
/*
*封装演示
*/
public class Person { /* * 对属性的封装 一个人的姓名、性别和年龄都是这个人的私有属性 */ private String name; private String sex; private int age;/* * setter()、getter()是该对象对外开放的接口 */ public String getName() { return name; }public void setName(String name) { this.name = name; }public String getSex() { return sex; }public void setSex(String sex) { this.sex = sex; }public int getAge() { return age; }public void setAge(int age) { this.age = age; }
}
采用 this
关键字是为了解决实例变量(private String name
)和局部变量(setName(String name)
中的name
变量)之间发生的同名的冲突。
封装可以使我们容易地修改类的内部实现,而无需修改使用了该类的客户代码,就可以对成员变量进行更精确的控制。
public void setAge(int age) { if (age > 120) { System.out.println("ERROR:error age input...."); // 提示错误信息 } else { this.age = age; }
}
public String getSexName() { if ("0".equals(sex)) { sexName = "女"; } else if ("1".equals(sex)) { sexName = "男"; } else { sexName = "人妖"; } return sexName;
}
补充:
要对私有属性赋值,先 .get();再 . set(赋值);
继承
继承的基本概念
所谓继承:是指可以让某个类型的对象获得另一个类型的对象的属性的方法
动物分成 :吃草动物 吃肉动物
兔子和羊属于食草动物类,狮子和豹属于食肉动物类。
食草动物和食肉动物又是属于动物类。
所以继承需要符合的关系是:is-a
,父类更通用,子类更具体。
虽然食草动物和食肉动物都是属于动物,但是两者的属性和行为上有差别,所以子类会具有父类的一般特性也会具有自身的特性。
现在假设有一个Person
类,里面有name
与age
两个属性,而另外一个Student
类,需要有name
、age
、school
三个属性,如图所示,从这里可以发现Person
中已经存在有name
和age
两个属性,所以不希望在Student
类中再重新声明这两个属性,这个时候就需要考虑是不是可以将Person
类中的内容继续保留到Student
类中,也就是引出了接下来所要介绍的类的继承概念。
Java类的继承,可用下面的语法来表示:
class 父类 // 定义父类
{ ...
}
class 子类 extends 父类 // 用extends关键字实现类的继承
{ ...
}
示例:
public class TestPersonStudentDemo { public static void main(String[] args) { Student s = new Student(); // 访问Person类中的name属性 s.name = "张三"; // 访问Person类中的age属性 s.age = 18; // 访问Student类中的school属性 s.school = "哈佛大学"; System.out.println("姓名:" + s.name + ",年龄:" + s.age + ",学校:" + s.school); }
}
class Person { String name; int age;
}
class Student extends Person { String school;
}
由上面的程序可以发现,在Student
类中虽然并未定义name
与age
属性,但在程序外部却依然可以调用name
或age
,这是因为Student
类直接继承自Person
类,也就是说Student
类直接继承了Person
类中的属性,所以Student
类的对象才可以访问到父类中的成员。
继承的特性
- 子类拥有父类非
private
的属性和方法; - 子类可以拥有自己的属性和方法,即子类可以对父类进行扩展;
- 子类可以用自己的方式实现父类的方法;
- 在
Java
中只允许单继承,而不允许多重继承,也就是说一个子类只能有一个父类,但是Java
中却允许多层继承,多层继承就是,例如类C
继承类B
,类B
继承类A
,所以按照关系就是类A
是类B
的父类,类B
是类C
的父类,这是Java
继承区别于C++
继承的一个特性; - 提高了类之间的耦合性(继承的缺点,耦合度高就会造成代码之间的联系)。
多重继承
class A{ ...
}
class B{ ...
}
class C extends A,B{ ...
}
由上面可以发现类C
同时继承了类A
与类B
,也就是说类C
同时继承了两个父类,这在Java中是不允许的。
多层继承
class A{ ...
}
class B extends A{ ...
}
class C extends B{ ...
}
由上面可以发现类B
继承了类A
,而类C
又继承了类B
,也就是说类B
是类A
的子类,而类C
则是类A
的孙子类。
子类对象的实例化过程
既然子类可以继承直接父类中的方法与属性,那父类中的构造方法呢?请看下面的范例:
public class TestPersonStudentDemo1 { public static void main(String[] args) { Student s = new Student(); }
}
class Person { String name; int age;// 父类的构造方法 public Person() { System.out.println("1.public Person(){}"); }
}
class Student extends Person { String school;// 子类的构造方法 public Student() { System.out.println("2.public Student(){}"); }
}
输出结果:
1.public Person(){}
2.public Student(){}
从程序输出结果中可以发现,虽然程序第3
行实例化的是子类的对象,但是程序却先去调用父类中的无参构造方法,之后再调用了子类本身的构造方法。所以由此可以得出结论,子类对象在实例化时会默认先去调用父类中的无参构造方法,之后再调用本类中的相应构造方法。
实际上,在子类构造方法的第一行默认隐含了一个super()
语句
public Student(){ super() ; //实际上在程序的这里隐含了这样一条语句 System.out.println("2.public Student(){}"); }
}
继承条件下构造方法调用规则如下:
- 如果子类的构造方法中没有通过
super
显示调用父类的有参构造方法,也没有通过this
显示调用自身的其他构造方法,则系统会默认先调用父类的无参构造方法。在这种情况下写不写super()
语句效果都是一样; - 如果子类的构造方法中通过
super
显示调用父类的有参构造方法,那将执行父类相应构造方法,而不执行父类无参构造方法; - 如果子类的构造方法中通过
this
显示调用自身的其他构造方法,在相应构造方法中应用以上两条规则; - 特别注意的是,如果存在多级继承关系,在创建一个子类对象时,以上规则会多次向更高一级父类应用,一直到执行顶级父类
Object
类的无参构造方法为止。
package case2;public class extendsTest {public static void main(String args[]) {Cat cat = new Cat();cat.getName();cat.setName("大花猫");cat.getAge();cat.setAge(6);cat.voice();cat.eat();System.out.println(cat.getName()+cat.getAge()+"岁");/********* end *********/// 实例化一个Dog对象,设置属性name和age,调用voice()和eat()方法,再打印出名字和年龄信息/********* begin *********/Dog dog = new Dog();dog.getName();dog.setName("大黑狗");dog.getAge();dog.setAge(8);dog.voice();dog.eat();System.out.println(dog.getName()+dog.getAge()+"岁");//获取私有属性的值需要用getName(), }
}class Animal {/********* begin *********/private String name;private int age;public String getName(){return name;}public void setName(String name){this.name = name;}public int getAge(){return age;}public void setAge(int age){this.age = age;}/********* end *********/}class Cat extends Animal {// 定义Cat类的voice()和eat()方法/********* begin *********/void voice(){System.out.println("大花猫喵喵叫");}void eat(){System.out.println("大花猫吃鱼");}/********* end *********/
}class Dog extends Animal {// 定义Dog类的voice()和eat()方法/********* begin *********/void voice(){System.out.println("大黑狗汪汪叫");}void eat(){System.out.println("大黑狗吃骨头");}/********* end *********/
}
super
super关键字
super
关键字出现在子类中,我们new
子类的实例对象的时候,子类对象里面会有一个父类对象。怎么去引用里面的父类对象呢?使用super
来引用,所以可以得出结论:super
主要的功能是完成子类调用父类中的内容,也就是调用父类中的属性或方法。
super关键字的使用
super
关键字的用法如下:
super
可以用来引用直接父类的实例变量。super
可以用来调用直接父类方法。super()
可以用于调用直接父类构造函数。
super用于引用直接父类实例变量
public class TestSuper1 { public static void main(String args[]) { Dog d = new Dog(); d.printColor(); } } class Animal { String color = "white"; } class Dog extends Animal { String color = "black";void printColor() { System.out.println(color);// prints color of Dog class System.out.println(super.color);// prints color of Animal class } }
输出结果:
black
white
通过
super
来调用父类方法
public class TestSuper2 { public static void main(String args[]) { Dog d = new Dog(); d.work(); }
}
class Animal { void eat() { System.out.println("eating..."); }
}
class Dog extends Animal { void eat() { System.out.println("eating bread..."); }void bark() { System.out.println("barking..."); }void work() { super.eat(); bark(); }
}
输出结果:
eating...
barking...
Animal
和Dog
两个类都有eat()
方法,如果要调用Dog
类中的eat()
方法,它将默认调用Dog
类的eat()
方法,因为当前类的优先级比父类的高。所以要调用父类方法,需要使用super
关键字指定。
- 使用super来调用父类构造函数
public class TestSuper3 { public static void main(String args[]) { Dog d = new Dog(); }
}
class Animal { Animal() { System.out.println("animal is created"); }
}
class Dog extends Animal { Dog() { super(); System.out.println("dog is created"); }
}
输出结果:
animal is created
dog is created
注意:如果没有使用super()
或this()
,则super()
在每个类构造函数中由编译器自动添加。
super
与this
关键字的比较
super
关键字:我们可以通过super
关键字来实现对父类成员的访问,用来引用当前对象的父类。
this
关键字:指向自己的引用。
public class TestAnimalDogDemo { public static void main(String[] args) { Animal a = new Animal(); a.eat(); Dog d = new Dog(); d.eatTest(); }
}
class Animal { void eat() { System.out.println("animal : eat"); }
}
class Dog extends Animal { void eat() { System.out.println("dog : eat"); }void eatTest() { this.eat(); // this 调用自己的方法 super.eat(); // super 调用父类方法 }
}
输出结果:
animal : eat
dog : eat
animal : eat
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-CNUhd5sO-1649492463248)(C:\Users\14860\AppData\Roaming\Typora\typora-user-images\1649424217696.png)]
上表对 this
与 super
的差别进行了比较,从上表中不难发现,用 super
或 this
调用构造方法时都需要放在首行,所以super
与 this
调用构造方法的操作是不能同时出现的。
练习:
public static void main(String[] args) {// 实例化一个Student类的对象s,为Student对象s中的school赋值,打印输出信息Student s = new Student();s.school = "哈佛大学";System.out.print(",学校:"+s.school);//输出学校/********* end *********/}
}class Person {/********* begin *********/String name;int age;public Person(String name,int age) {System.out.print("姓名:"+name+",年龄:"+age);//输出姓名 年龄}/********* end *********/
}class Student extends Person {/********* begin *********/String school;public Student() {super("张三",18); //调用父类中有两个参数的构造方法String school;}/********* end *********/
方法的重写与重载
方法的重写 override
- 方法的重写
子类从父类中继承方法,有时,子类需要修改父类中定义的方法的实现,这称做方法的重写(method overriding
)。“重写”的概念与“重载”相似,它们均是Java
“多态”的技术之一,所谓“重载”,即是方法名称相同,但却可在不同的场合做不同的事。当一个子类继承一父类,而子类中的方法与父类中的方法的名称、参数个数和类型都完全一致时,就称子类中的这个方法重写了父类中的方法。“重写”又称为“复写”、“覆盖”。
- 如何使用重写
class Super { 访问权限 方法返回值类型 方法1(参数1) { ... }
}
class Sub extends Super{ 访问权限 方法返回值类型 方法1(参数1) —————>复写父类中的方法 { ... }
}
**注意:**方法重写时必须遵循两个原则,否则编译器会指出程序出错。
- 重写的方法不能比被重写的方法有更严格的访问权限;
- 重写的方法不能比被重写的方法产生更多的异常(关于异常,在后面会介绍)。
编译器加上这两个限定,是为了与Java
语言的多态性(关于方法重写引起的运行时多态,在后面会详细讲述)特点一致而做出的。这样限定是出于对程序健壮性的考虑,为了避免程序执行过程中产生访问权限冲突或有应该捕获而未捕获的异常产生。
方法的重载(overload
)
方法的重载
首先回顾一下前面所讲的方法的重载,方法重载是指多个方法可以享有相同的名字,但是参数的数量或类型不能完全相同。 调用方法时,编译器根据参数的个数和类型来决定当前所使用的方法。方法重载为程序的编写带来方便,是
OOP
多态性的具体变现。在Java
系统的类库中,对许多重要的方法进行重载,为用户使用这些方法提供了方便。重载的规则
- 被重载的方法必须改变参数列表(参数个数或类型不一样);
- 被重载的方法可以改变返回类型;
- 被重载的方法可以改变访问修饰符;
- 被重载的方法可以声明新的或更广的检查异常;
- 方法能够在同一个类中或者在一个子类中被重载。
- 无法以返回值类型作为重载函数的区分标准。
重写与重载之间的区别
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-N8W3cLPg-1649492463248)(C:\Users\14860\AppData\Roaming\Typora\typora-user-images\1649472907278.png)]
方法的重写和重载是Java
多态性的不同表现,重写是父类与子类之间多态性的一种表现,重载可以理解成多态的具体表现形式。
- 方法重载是一个类中定义了多个方法名相同,而他们的参数的数量不同或数量相同而类型和次序不同,则称为方法的重载;
- 方法重写是在子类存在方法与父类的方法的名字相同而且参数的个数与类型一样,返回值也一样的方法,就称为方法的重写;
- 方法重载是一个类的多态性表现,而方法重写是子类与父类的一种多态性表现。
抽象
抽象类的概念
前面对类的继承进行了初步的讲解。通过继承,可以从原有的类派生出新的类。原有的类称为基类或父类,而新的类则称为派生类或子类。通过这种机制,派生出的新的类不仅可以保留原有的类的功能,而且还可以拥有更多的功能。
除了上述的机制之外,Java
也可以创建一种类专门用来当作父类,这种类称为“抽象类”。抽象类的作用有点类似“模版”,其目的是要设计者依据它的格式来修改并创建新的类。但是并不能直接由抽象类创建对象,只能通过抽象类派生出新的类,再由它来创建对象。
如何定义抽象类
抽象类的定义规则:
- 抽象类和抽象方法都必须用
abstract
关键字来修饰; - 抽象类不能被实例化,也就是不能用
new
关键字去产生对象; - 抽象方法只需声明,而不需实现;
- 含有抽象方法的类必须被声明为抽象类,抽象类的子类必须复写所有的抽象方法后才能被实例化,否则这个子类还是个抽象类。
抽象类的定义格式
abstract class 类名称 // 定义抽象类
{ 声明数据成员; 访问权限 返回值的数据类型 方法名称(参数...)//定义一般方法 { ... } abstract 返回值的数据类型 方法名称(参数...); //定义抽象方法,在抽象方法里,没有定义方法体
}
注意:
- 在抽象类定义的语法中,方法的定义可分为两种:一种是一般的方法,它和先前介绍过的方法没有什么两样;另一种是“抽象方法”,它是以
abstract
关键字为开头的方法,此方法只声明了返回值的数据类型、方法名称与所需的参数,但没有定义方法体。 - 抽象类也可以像普通类一样,有构造方法、一般方法、属性,更重要的是还可以有一些抽象方法,留给子类去实现,而且在抽象类中声明构造方法后,在子类中必须明确调用。
练习:
- 声明一个名为
Person
的抽象类,在Person
类中声明了三个属性name
、age
和occupation
和一个抽象方法talk()
; - 声明一个
Student
类和一个Worker
类,都继承自Person
类,添加带有三个参数的构造方法; - 分别实例化
Student
类与Worker
类的对象,分别调用各自类中被复写的talk()
方法打印输出信息; - 具体输出要求请看测试说明。
public class abstractTest {public static void main(String[] args) {// 分别实例化Student类与Worker类的对象,并调用各自构造方法初始化类属性。Student s = new Student("张三",20,"学生");Worker w = new Worker("李四",30,"工人");// 分别调用各自类中被复写的talk()方法 打印信息。s.talk();w.talk();/********* end *********/}
}// 声明一个名为Person的抽象类,在Person中声明了三个属性name age occupation和一个抽象方法——talk()。
abstract class Person {/********* begin *********/String name;int age;String occupation;abstract void talk();/********* end *********/
}// Student类继承自Person类,添加带三个参数的构造方法,复写talk()方法 返回姓名、年龄和职业信息
class Student extends Person {public Student(String name,int age, String occupation) {this.name = name;this.age = age;this.occupation = occupation;}@Overridevoid talk() {System.out.println("学生——>姓名:"+name+",年龄:"+age+",职业:"+occupation+"!");}/********* begin *********//********* end *********/
}// Worker类继承自Person类,添加带三个参数的构造方法,复写talk()方法 返回姓名、年龄和职业信息
class Worker extends Person {public Worker(String name,int age, String occupation) {this.name = name;this.age = age;this.occupation = occupation;}@Overridevoid talk() {System.out.println("工人——>姓名:"+name+",年龄:"+age+",职业:"+occupation+"!");}}
final
final关键字的使用
在Java中声明类、属性和方法时,可使用关键字final
来修饰。
final
标记的类不能被继承;final
标记的方法不能被子类复写;final
标记的变量(成员变量或局部变量)即为常量,只能赋值一次。
final关键字修饰类、成员变量和成员方法
1.final
类
final
用来修饰一个类,意味着该类成为不能被继承的最终类。出于安全性的原因和效率上的考虑,有时候需要防止一个类被继承。例如,Java
类库中的String
类,它对编译器和解释器的正常运行有着很重要的作用,不能轻易改变它,因此把它修饰为final
类,使它不能被继承,这就保证了String
类的惟一性。同时,如果你认为一个类的定义己经很完美,不需要再生成它的子类,这时也应把它修饰为final
类。
定义一个final
类的格式如下:
final class ClassName{ ...
}
**注意:**声明为final
的类隐含地声明了该类的所有方法为final
方法。
下面的结论是成立的:声明一个类既为abstract
,又为final
是非法的,因为抽象类必须被子类继承来实现它的抽象方法。下面是一个final
类的例子:
final class A{ ...
}
class B extends A{//错误!不能继承A ...
}
2.final
修饰成员变量
变量被声明为final
后,成为常值变量(即常量),一旦被通过某种方式初始化或赋值,即不能再被修改。通常 static
与final
一起 使用来指定一个类常量。例如:
static final int SUNDAY=0;
把final
变量用大写字母和下划线来表示,这是一种编码规定。
3.final
修饰成员方法
用final
修饰的方法为最终方法,不能再被子类重写,可以被重载。
尽管方法重写是Java非常有力的特征,但有时却需要避免这种情况的发生。为了不允许一个方法被重写,在方法的声明中指定final
属性即可。例如:
class A{ final void method(){}
}
class B extends A{//定义A类的一个子类B void method(){}//错误,method()不能被重写
}
该例中,因为method()
方法在A
中被声明为final
,所以不能在子类B
中被重写。如果这样做,将导致编译错误。
方法被声明为final
有时可以提高性能:编译器可以自由地内联调用它们,因为它“知道”它们不会被子类重写。
接口
接口的定义
接口(interface
)是Java所提供的另一种重要技术,它的结构和抽象类非常相似,也具有数据成员与抽象方法,但它与抽象类又有以下两点不同:
- 接口里的数据成员必须初始化,且数据成员均为常量;
- 接口里的方法必须全部声明为
abstract
,也就是说,接口不能像抽象类一样保有一般的方法,而必须全部是“抽象方法”。
接口定义的语法如下:
interface 接口名称 // 定义抽象类
{ final 数据类型 成员名称 = 常量; //数据成员必须赋初值 abstract 返回值的数据类型 方法名称(参数...); //抽象方法,注意在抽象方法里,没有定义方法主体
}
接口与一般类一样,本身也具有数据成员与方法,但数据成员一定要赋初值,且此值将不能再更改,方法也必须是“抽象方法”。也正因为方法必须是抽象方法,而没有一般的方法,所以抽象方法声明的关键字abstract
是可以省略的。
相同的情况也发生在数据成员身上,因数据成员必须赋初值,且此值不能再被更改,所以声明数据成员的关键字final
也可省略。事实上只要记得:
- 接口里的“抽象方法”只要做声明即可,而不用定义其处理的方式;
- 数据成员必须赋初值。
接口的实现
在Java
中接口是用于实现多继承的一种机制,也是Java
设计中最重要的一个环节,每一个由接口实现的类必须在类内部复写接口中的抽象方法,且可自由地使用接口中的常量。
既然接口里只有抽象方法,它只要声明而不用定义处理方式,于是自然可以联想到接口也没有办法像一般类一样,再用它来创建对象。利用接口打造新的类的过程,称之为接口的实现(implementation
)。
接口实现的语法:
class 类名称 implements 接口A,接口B //接口的实现
{ ...
}
接口的拓展
接口是Java
实现多继承的一种机制,一个类只能继承一个父类,但如果需要一个类继承多个抽象方法的话,就明显无法实现,所以就出现了接口的概念。一个类只可以继承一个父类,但却可以实现多个接口。
接口与一般类一样,均可通过扩展的技术来派生出新的接口。原来的接口称为基本接口或父接口,派生出的接口称为派生接口或子接口。通过这种机制,派生接口不仅可以保留父接口的成员,同时也可加入新的成员以满足实际的需要。
同样的,接口的扩展(或继承)也是通过关键字extends
来实现的。有趣的是,一个接口可以继承多个接口,这点与类的继承有所不同。
接口扩展的语法:
interface 子接口名称 extends 父接口1,父接口2...
{ ...
}
练习:
- 声明一
Person
接口,并在里面声明三个常量:name
、age
、occupation
,并分别赋值; - 声明一
Student
类,此类实现Person
接口,并复写Person
中的talk()
方法; - 实例化一
Student
的对象s
,并调用talk()
方法,打印信息; - 具体输出要求请看测试说明。
public class interfaceTest {public static void main(String[] args) {// 实例化一Student的对象s,并调用talk()方法,打印信息/********* begin *********/Student s = new Student();s.talk();/********* end *********/}
}// 声明一个Person接口,并在里面声明三个常量:name、age和occupation,并分别赋值,声明一抽象方法talk()
interface Person {/********* begin *********/final String name = "张三";final int age = 18;final String occupation = "学生";abstract void talk();/********* end *********/
}// Student类继承自Person类 复写talk()方法返回姓名、年龄和职业信息
class Student implements Person {/********* begin *********/public void talk(){ //重写方法需要修饰符System.out.println("学生——>姓名:"+name+",年龄:"+age+",职业:"+occupation+"!");}/********* end *********/
}
多态
什么是多态?
就是指一个类实例的相同方法在不同情形有不同表现形式。多态机制使具有不同内部结构的对象可以共享相同的外部接口。这意味着,虽然针对不同对象的具体操作不同,但通过一个公共的类,它们(那些操作)可以通过相同的方式予以调用。
多态性是对象多种表现形式的体现。
现实中,比如我们按下F1
键这个动作:
- 如果当前在
Flash
界面下弹出的就是AS 3
的帮助文档; - 如果当前在
Word
下弹出的就是Word
帮助; - 在
Windows
下弹出的就是Windows
帮助和支持。
同一个事件发生在不同的对象上会产生不同的结果。
多态的实现条件
多态的三个条件:
- 继承的存在(继承是多态的基础,没有继承就没有多态);
- 子类重写父类的方法(多态下调用子类重写的方法);
- 父类引用变量指向子类对象(子类到父类的类型转换)。
子类转换成父类时的规则:
- 将一个父类的引用指向一个子类的对象,称为向上转型(
upcasting
),自动进行类型转换。此时通过父类引用调用的方法是子类覆盖或继承父类的方法,不是父类的方法。 此时通过父类引用变量无法调用子类特有的方法; - 如果父类要调用子类的特有方法就得将一个指向子类对象的父类引用赋给一个子类的引用,称为向下转型,此时必须进行强制类型转换。
可以用 instanceof
判断一个类是否实现了某个接口,也可以用它来判断一个实例对象是否属于一个类。instanceof
的语法格式为:
对象 instanceof 类(或接口)
它的返回值是布尔型的,或真(true
)、或假(false
)。
多态的实现形式
在Java中有两种形式可以实现多态:继承和接口。
- 基于继承实现的多态
基于继承的实现机制主要表现在父类和继承该父类的一个或多个子类对某些方法的重写,多个子类对同一方法的重写可以表现出不同的行为。
基于继承实现的多态可以总结如下:对于引用子类的父类类型,在处理该引用时,它适用于继承该父类的所有子类,子类对象的不同,对方法的实现也就不同,执行相同动作产生的行为也就不同。
如果父类是抽象类,那么子类必须要实现父类中所有的抽象方法,这样该父类所有的子类一定存在统一的对外接口,但其内部的具体实现可以各异。这样我们就可以使用顶层类提供的统一接口来处理该层次的方法。
- 基于接口实现的多态
继承是通过重写父类的同一方法的几个不同子类来体现的,那么就可能是通过实现接口并覆盖接口中同一方法的几不同的类体现的。
在接口的多态中,指向接口的引用必须是指定实现了该接口的一个类的实例程序,在运行时,根据对象引用的实际类型来执行对应的方法。
继承都是单继承,只能为一组相关的类提供一致的服务接口。但是接口可以是多继承多实现,它能够利用一组相关或者不相关的接口进行组合与扩充,能够对外提供一致的服务接口。所以它相对于继承来说有更好的灵活性。
Java回顾 封装 继承和多态相关推荐
- Java实验3继承、多态
继承.多态(接口和包) 实验目的 (1) 掌握Java语言中继承和多态的相关概念 (2) 掌握Java程序设计中继承和多态机制的使用 (3) 掌握Java语言中接口和包的概念及使用 实验内容及要求 仿 ...
- Java中的继承 与 多态(中)
先导: 我们在<Java中的继承 与 多态(上)>当中讲解了如下几个问题, 1.继承是什么 2.super关键字 3.特殊考点-父子类中不同代码块的实现顺序 所以现在我们对于继承 ...
- (十)Core Java 面向对象(封装,继承,多态,接口) -02 (96)
目录 : 24 ). 面向对象(聚集关系) 25 ). 面向对象(子父类中变量的特点) 26 ). 面向对象(子父类中函数的特点-覆盖) 27 ). 面向对象(子父类中构造函数的特点 ...
- java 继承重写_java 封装 继承 重写 多态
封装:是指隐藏对象的属性和实现细节,仅对外提供公共访问方式. 好处: 将变化隔离.便于使用.提高重用性.提高安全性 封装原则: 将不需要对外提供的内容都隐藏起来.把属性都隐藏,提供公共方法对其访问. ...
- 面向对象 详解笔记 方法 类 对象 封装 继承 重写 多态 接口
文章目录 面向过程&面向对象 面向过程 面向对象 什么是面向对象 回顾方法及加深 方法的定义 修饰符 返回类型 break:跳出switch,结束循环和return的区别 方法名:注意规范就o ...
- Java基础:继承、多态、抽象、接口
第一讲 继承 一.继承概述 1.多个类中存在相同属性和行为时,将这些内容抽取到单独一个类中,那么多个类无需再定义这些属性和行为,只要继承那个类即可. 2.通过extends关键字可以实现类与类的 ...
- 本质论之封装继承和多态的介绍
关于 类,我有一些话想说 说到类那就说到了面向对象的灵魂了,没有它也就没有了封装.继承and多态这些东西了.我还记得在读研期间每次看到这些都望而却步,甚至我搞不懂对象和类的区别(这里防止有人也不知道区 ...
- 黑马程序员_JAVA之面向对象(封装,继承和多态)
------- android培训.java培训.期待与您交流!---------- 面向对象 一.面向对象概述 定义: 面向对象(Object Oriented,OO)是软件开过过程中使用一种思维方 ...
- Java基础篇--继承(inherit),多态(Polymorphism)
Java基础篇--继承(inherit),多态(Polymorphism) 1. 继承概述 1.1 什么是继承 1.2 为什么要使用继承 1.3 继承的特点 1.4 继承的优点 2. 组合设计模式 2 ...
最新文章
- Retrofit2.0 请求数据 一直出返回网络错误,错误代码 414
- 以下选项不是python文件读操作的是-以下选项中,不是Python中文件操作的相关函数是()...
- iview weapp icon组件自定义图标 小程序
- 解码Java.Lang.OutOfMemoryError:PermGen空间
- 企业使用开源软件的风险
- 北京航空航天大学计算机科学与工程系,北航郑征主页 北京航空航天大学教师个人主页系统...
- 中央民族大学计算机考研考什么,中央民族大学电子信息专业硕士研究生入学考试初试科目考试大纲...
- .net source code download
- 人均34万,腾讯为3300名员工发11亿红包;B站回应大会员补偿会自动续费;​小米销量超苹果跻身全球第二|极客头条...
- mysql默认值是随机数_mysql生成指定位数的随机数及批量生成随机数的方法
- poj 匈牙利二分匹配算法2239 Selecting Courses
- 阿里云 DTS 实践
- Jstorm到Flink 在今日头条的迁移实践
- 2020-10-21
- 11部委印发《智能汽车创新发展战略》,加快智能汽车应用北斗高精度时空基准服务
- 使用hue时hive的历史查询记录结果无法下载
- KinectV2 Face Basic
- dns服务器一些网站无法解析,dns解析出错,导致有些网站解析出错,重启DNS服务器就正常了。 - Exchange论坛 - 51CTO技术论坛_中国领先的IT技术社区...
- 从公司角度来看,为什么要招实习生?
- 小米门卡协议加载失败_小米手机门禁卡空白卡开通步骤及写入激活方法
热门文章
- Android端CodePush配置
- oracle revoke 列_Oracle 权限(grant、revoke)
- 经典算法之辗转相除法(欧几里得定理)
- (二)Linux源码分析-init
- php 判断字符存在,PHP判断字符串str中是否存在某个值
- 抓包工具 之 Charles 的使用
- [Verilog学习笔记] always@(*)语句是什么意思
- Unity SteamVR插件详解:SteamVR Controller脚本分析+Vive控制器功能开发 ——转自波波...
- 安装 timescaledb 使用navcat连接 创建 hypertable
- 维吉尼亚密码_附有链接爆破