继承、多态
继承:
面向对象的三大特征之一:
是类和类之间的一种拓展关系,是一种从一般到特殊的关系;
格式: sub extends Super, 我们把sub称为子类或者拓展类, 把super称为父类或者基类(超类)
泛化: 把子类中的共性抽取到父类的过程;
特化: 子类在父类的基础之上,拓展自己特有的状态和特征;
Object: 是所有类的直接父类后间接父类;
class Student{} 等价于 class Student extends Object{}
直接父类: 直接继承的父类,有且只有一个,也就是说Java只支持单继承;
间接父类: 直接父类或间接的父类的父类;
方法和字段:
private 修饰的成员不能被继承;
默认访问权限的成员能不能被继承? 要是在同一个包中就能被继承
protected 修饰的成员,可以被继承;
public 修饰的成员,可以被继承;
构造方法能不能被继承? 不能
class Person{
public Person(){}
}
class Student extends Person
{
//public Person(){}//ERROR
}
若父类所有的构造方法是用 private 修饰,不能有子类;
子类实例化:
子类初始化,会先默认调用父类的一个无参的构造方法,自己再初始化;
子类的构造方法里,有一个隐式的 super();
若我们显示的让子类去调用父类有参数的构造方法,默认的隐式的构造方法就不会被调用了;
子类对象创建之前,必须有一个父类对象;
方法覆写:
当父类的某一个方法不适合子类对象的时候,就应当重新修改方法体;
遵循的原则: 一同 两小 一大:
一同: 方法签名相同
两小:
1.返回值类型可以是父类返回值类型的子类或相同;
父类的:Object show(){
return null;
}
子类的: String show()
{
return null;
}
2.异常更小
一大: 子类方法的访问权限 >= 父类方法的访问权限
父类的: private Object show(){
return null;
}
子类的: String show()
{
return null;
}
上面这个不是覆写:因为私有成员不能被继承
必杀技: 若子类方法是覆写方法的话, 那么在方法上加上 @Override 是可以编译通过的;
静态方法能不能被覆写: 不能!
方法的覆写:属于多态,而多态是基于对象的(父类的一个变量指向子类的一个对象);
而静态方法不属于对象,属于类;
super:
用在子类.,
super:表示父类对象
用于调用父类的方法或字段,用法和this一模一样
调用父类的构造方法:
super(参数);和this(参数);
都表示在构造方法里调用构造方法;都必须写在构造方法的第一行
不同: this(参数),调用的当前类里面的构造方法,super(参数),调用的是直接父类里构造方法
多态:
面向对象的三大特征之一:
Person p = new Student();
p的真正类型是学生;当是我们只把他当一般人看待;
编译类型: 申明变量的类型 Person , 是我们把它当做什么
运行类型: 创建对象的类型 Student , 是对象真正的类型
多态的产生前提:继承
当编译类型和运行类型不一致的时候,就会产生多态;
多态定义: 同一个实体有多种形态;
多态的作用: 可以屏蔽不同子类对象之间的差异,从而能写出更加通用的代码,能提高效率,维护性;
引用类型转换:
向上转型: 小->大, 自动转换, 这里说的小和大,说的是 继承关系中的子类和父类.
可以把子类对象赋给父类变量;
Person p = new Student();
Object类是所有类的父类.那么Object类型的变量能不能接受一切值? 可以!
向下转型: 大 -> 小
父类对象强制转换成子类对象;
Student s = (Student)p;
一般的,再强转之前,要先判断该对象时候属于这个类类型;
boolean b = 对象 instanceof 类
对象的类型和类必须有继承关系;
先判断 p是否是学生类型:
if(p instanceof Student)
{
Student s = (Student)p;
}
多态方法调用:
class Car{
public void run(){}
}
class Binli extends Car
{
public void paoMM(){
}
public void run(){}
}
Car c = new Binli();
1.调用的方法不是覆写方法,子类有,父类没有;
c.paoMM();//找不到方法,编译的时候,去Car类里去找;
if(c instanceof Binli)
{
Binli b =(Binli)c;
b.paoMM();
}
2.调用的方法是覆写的方法,父类有,子类也有;
c.run();//调用的是子类的方法,,在编译的时候去Car里找run方法,但运行期间找的Binli类里的run方法;
组合:
extends 继承是一种从一般到特殊的关系, 也就是说 子类是父类的一种特殊情况;
子类 is 父类的一种 is A 关系
组合,包含: 比如手机和手机卡, 手机里有手机卡 ,has A关系
圆心和圆的关系:
练习:判断一个点和圆的关系(外,内,上);
// 描述一个点,只需要坐标就OK了
class Dot
{
private double x;//横坐标
private double y;//纵坐标
//根据坐标来创建点
public Dot(double x, double y)
{
this.x =x;
this.y = y;
}
//getter setter
}
/*
描述一个圆,
圆包含圆心,圆心又是一个点
*/
class Circle{
private Dot o;//圆心//等价于private Dot o = null;
//private Dot p;/不能这样设计,这样就已经表示圆包含需要判断的点了
private double r;//半径
//根据半径和圆心来创建指定的圆
public Cirlce(Dot o, double r)
{
//this.o.setX(o.getX());ERROR
this.o = o;
this.r = r;
}
//写一个判断点和圆的关系的方法
public String judge(Dot p)
{
double x = o.getX() - p.getX();
double y = o.getY() - p.getY();
double xx = x * x;
double yy = y * y;
double rr = r * r;
if(xx + yy - rr > 0)
{
//圆外
}else if(xx + yy - rr == 0)
{
//圆上
}else{
//圆内
}
return "";
}
/*
getter/setter
*/
}
....main...
{
//创建圆心点
Dot o = new Dot(0.0,0.0);
//创建指定大小的圆
Circle c = new Circle(o, 5);
//还需要一个判断的点
Dot p = new Dot(3,4);
//判断
String ret =c.judge(p);
System.out.println(ret);
}