第1章 多态
多态是继封装、继承之后,面向对象的第三大特性。
现实事物经常会体现出多种形态,如学生,学生是人的一种,则一个具体的同学张三既是学生也是人,即出现两种形态。
Java作为面向对象的语言,同样可以描述一个事物的多种形态。如Student类继承了Person类,一个Student的对象便既是Student,又是Person。
Java中多态的代码体现在一个子类对象(实现类对象)既可以给这个子类(实现类对象)引用变量赋值,又可以给这个子类(实现类对象)的父类(接口)变量赋值。
如Student类可以为Person类的子类。那么一个Student对象既可以赋值给一个Student类型的引用,也可以赋值给一个Person类型的引用。
最终多态体现为不光子类引用变量可以指向子类对象,父类引用变量也可以指向子类对象。
多态的前提是必须有子父类关系或者类实现接口关系,否则无法完成多态。
在使用多态后的父类引用变量调用方法时,会调用子类重写后的方法
1.1 多态的定义与使用格式
多态的定义格式:就是父类的引用变量指向子类对象
父类类型 变量名 = new 子类类型();
变量名.方法名();
l 普通类多态定义的格式
父类变量名 = new 子类();
如: class Fu {}
class Ziextends Fu {}
//类的多态使用
Fu f = new Zi();
l 抽象类多态定义的格式
抽象类变量名 = new 抽象类子类();
如: abstractclass Fu {
public abstract void method();
}
class Zi extends Fu {
public void method(){
System.out.println(“重写父类抽象方法”);
}
}
//类的多态使用
Fu fu= new Zi();
l 接口多态定义的格式
接口变量名 = new 接口实现类();
如: interface Fu {
public abstract voidmethod();
}
class Zi implements Fu {
public void method(){
System.out.println(“重写接口抽象方法”);
}
}
//接口的多态使用
Fu fu = new Zi();
l 注意事项
同一个父类的方法会被不同的子类重写。在调用方法时,调用的为各个子类重写后的方法。
如 Person p1 = newStudent();
Person p2= new Teacher();
p1.work(); //p1会调用Student类中重写的work方法
p2.work(); //p2会调用Teacher类中重写的work方法
当变量名指向不同的子类对象时,由于每个子类重写父类方法的内容不同,所以会调用不同的方法。
l 多态成员变量
成员变量:编译看父类,,运行看父类(编译时,父类没有这个成员变量,就编译失败,运行则是父类的成员变量的值
成员方法:编译看父类,运行看子类(编译时,父类没有这个成员方法,就编译失败,运行则是子类的成员方法被执行,即多态的方法重写
总结:方法和变量编译都是看父类有没有,没有就报错,只有运行不一样,方法是运行之类的,变量是运行父类的.
class Fu {
int num =4;
voidshow() {
System.out.println("Fu show num");
}
}
class Zi extends Fu {
int num =5;
voidshow() {
System.out.println("Zi show num");
}
}
class Demo {
publicstatic void main(String[] args) {
Fu f = new Zi();
f.show();//执行子类的方法
f.num;//执行的父类的变量
}
}
1.1 instanceof关键字
我们可以通过instanceof关键字来判断某个对象是否属于某种数据类型或这种类型的子类。如学生的对象属于学生类,因为为student类为person的子类,所以学生的对象也属于person类.就是判断这个对象是不是这个数据类型的同类或子类
使用格式:
boolean b = 对象 instanceof 数据类型;
1.1 多态-转型
多态的转型分为向上转型与向下转型两种:
l 向上转型:当有子类对象赋值给一个父类引用时,便是向上转型,多态本身就是向上转型的过程。
使用格式:
父类类型 变量名 = new 子类类型();
如:Person p = new Student();//多态本身就是向上转型
l 向下转型:一个已经向上转型的子类对象可以使用强制类型转换的格式,将父类引用转为子类引用,这个过程是向下转型。如果是直接创建父类对象,是无法向下转型的!
使用格式:
子类类型变量名 = (子类类型) 父类类型的变量;
如:Person p = new Student();
Student stu = (Student) p; //变量p 实际上指向Student对象
Person p = new Person()
Student stu = (Student) p;//因为是直接创建的父类对象,所以无法向下转型,这个编译错误
1.1 多态的好处与弊端
当父类的引用指向子类对象时,就发生了向上转型,即把子类类型对象转成了父类类型。向上转型的好处是隐藏了子类类型,提高了代码的扩展性。
但向上转型也有弊端,只能使用父类共性的内容,而无法使用子类特有功能,功能有限制。
l 什么时候使用向上转型:
当不需要面对子类类型时,通过提高扩展性,或者使用父类的功能就能完成相应的操作,这时就可以使用向上转型。
如:Animal a = new Dog();
a.eat();
l 什么时候使用向下转型
当要使用子类特有功能时,就需要使用向下转型。
如:Dog d= (Dog) a; //向下转型
d.lookHome();//调用狗类的lookHome方法
l 向下转型的好处:可以使用子类特有功能。
l 弊端是:需要面对具体的子类对象;在向下转型时容易发生ClassCastException类型转换异常。在转换之前必须做类型判断。
如:if(!a instanceof Dog){…}
面向对象的三大特征
总结下封装、继承、多态的作用:
l 封装:把对象的属性与方法的实现细节隐藏,仅对外提供一些公共的访问方式
l 继承:子类会自动拥有父类所有可继承的属性和方法。
l 多态:配合继承与方法重写提高了代码的复用性与扩展性;如果没有方法重写,则多态同样没有意义。
都是父类的引用变量,只要指向不同的子类,那么调用相同的方法时,会执行不同的子类各自的方法
第1章 总结
1.1 知识点总结
l 接口:理解为是一个特殊的抽象类,但它不是类,是一个接口
n 接口的特点:
1,定义一个接口用interface关键字
interface Inter{}
2,一个类实现一个接口,实现implements关键字
class Demo implements Inter{}
3, 接口不能直接创建对象
通过多态的方式,由子类来创建对象,接口多态
n 接口中的成员特点:
成员变量:
只能是final 修饰的常量
默认修饰符: public static final
构造方法:
无
成员方法:
只能是抽象方法
默认修饰符: public abstract
接口中不写就是默认
void show();相当于public abstract void show();
int a=100;相当于public static final int a = 100;
n 类与类,类与接口,接口与接口之间的关系
类与类之间:继承关系,单继承,可以是多层继承
类与接口之间: 实现关系,单实现,也可以多实现
接口与接口之间:继承关系,单继承,也可以是多继承
Java中的类可以继承一个父类的同时,实现多个接口
l 多态:理解为同一种对象的多种形态
Student s=new Student()或者Person s=new Student();同一对象new student()既是
Student类型又是Person类型
n 多态使用的前提:
1,有继承或者实现关系
2,要方法重写
3,父类引用指向子类对象
n 多态的成员访问特点:
方法的运行看右边,其他都看左边
java 中的instanceof 运算符是用来在运行时指出对象是否是特定类的一个实例。instanceof通过返回一个布尔值来指出,这个对象是否是这个特定类或者是它的子类的一个实例。
用法:
result = object instanceof class
参数:
Result:布尔类型。
Object:必选项。任意对象表达式。
Class:必选项。任意已定义的对象类。
说明:
如果 object 是 class 的一个实例,则 instanceof 运算符返回 true。如果 object 不是指定类的一个实例,或者 object 是 null,则返回 false。
但是instanceof在Java的编译状态和运行状态是有区别的:
在编译状态中,class可以是object对象的父类,自身类,子类。在这三种情况下Java编译时不会报错。
在运行转态中,class可以是object对象的父类,自身类,不能是子类。在前两种情况下result的结果为true,最后一种为false。但是class为子类时编译不会报错。运行结果为false。
例子:
接口Person
public interface Person {
public void eat();
}
实现类People
public class People implements Person {
private int a=0;
@Override
public void eat() {
System.out.println("======"+a);
}
}
子类xiaoming:
public class xiaoming extends People {
private String name;
@Override
public void eat() {
System.out.println("+++++++++");
}
}
主函数
public static void main(String[] args) {
People p=new People();
xiaoming x=new xiaoming();
System.out.println(p instanceof Person);
System.out.println(p instanceof xiaoming); -----2
System.out.println(x instanceof Person);
System.out.println(x instanceof People);
}
注意:上面2处的代码在编译时不会报错。
运行结果:
true
false
true
true