继承extends（也叫扩展）
多个类中存在相同的属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承那个类即可。
通过extends关键字可以实现类的继承
class 子类名 extends 父类名{}
继承的案例
创建一个Person类，定义两个功能吃饭、睡觉，再创建学生类、教师类，继承Person类，再定义两个自己独有的功能
创建Persen类
public class Person {
public void eat(){
System.out.println("吃饭");
}
public void sleep(){
System.out.println("睡觉");
}
}
//创建子类学生类继承Person类
public class Student extends Person {
public void play(){
System.out.println("打游戏");
}
}
//创建Teacher类继承Person类
public class Teacher extends Person {
public void teach(){
System.out.println("教书");
}
}
//创建测试类，对继承进行测试
public class PersonExtends {
public static void main(String[] args) {
Student st = new Student();
st.eat(); //用学生类调用继承方法
st.play(); //调用自己的方法
Teacher t =new Teacher();
t.sleep();
t.teach();
}
}
继承的好处
-
提高了代码的复用性：多个类的相同成员可以放到一个类中
-
提高了代码的维护性：如果功能的代码需要修改，修改一处即可，继承的类中自动都被修改了
-
让类与类之间产生了关系，是多态的前提
Java中继承的特点
Java只支持单继承，不支持多继承
即一个类只能有一个直接父类，不可以有多个直接父类
正确写法：class Sub extends Demo{}
错误写法：class Sub extends Demo1,Demo2{}
Java支持多层继承
class A{}
class B extends A{}
class C extends B{}
例
//
public class Grandfather {
public void show(){
System.out.println("grandfather");
}
}
public class Father extends Grandfather {
public void method(){
System.out.println("father");
}
}
public class Son extends Father {
public void function(){
System.out.println("son");
}
}
//测试类
public class GrandfatherTest {
public static void main(String[] args) {
Son s = new Son();
s.function();
s.method();
s.show();
}
}
Java中继承的注意事项
- 子类只能继承父类中所有非私有的成员（成员变量、成员方法）
- 子类不能父类的的构造方法，但可以同super关键字去访问父类构造方法
- 不要为了部分功能去继承，如果有两个类A,B，只有他们符合A是B的一种或者B是A的一种，就可以考虑使用继承
继承中成员变量的关系
案列演示：
//创建父类定义成员变量
public class Field {
int num = 10;
public void method(){
System.out.println(num);
}
}
//创建子类继承父类，并定义与父类同名成员变量
public class FieldExtends extends Field {
int num = 15;
public void show(){
System.out.println(num);
}
//在子类中定义新的方法，在方法内再定义与父类成员变量同名变量
public void function(){
int num = 5;
System.out.println(num);
}
}
//测试类
public class FieldTest {
public static void main(String[] args) {
FieldExtends fe = new FieldExtends();
fe.show(); // 15
fe.function(); // 5
fe.method(); //10
}
}
通过案列可以知道在子类中访问一个变量的顺序
- 在子类方法的局部范围找，有就使用
- 在子类的成员范围找，有就使用
- 在父类成员范围找有就使用
- 如果找不到，就报错
super关键字
用法与this关键字类似
- this 代表对本类对象的引用
- super 代表父类存储空间的标识（可以理解为对父类对象的引用）
用法
-
访问成员变量
this.成员变量 super.成员变量（访问父类的成员变量，不能访问父类的private变量） 访问静态成员时，也可以用 父类名.静态成员 -
访问构造方法
this(...) super(...) -
访问成员方法
this.成员方法（） super.成员方法（）
案列演示
//创建父类
public class FatherSuper {
int num = 10;
public FatherSuper(){
System.out.println("父类构造方法");
}
public void show(){
System.out.println("父类成员方法");
}
}
public class SonSuper extends FatherSuper {
int num = 15 ;
public SonSuper(){
System.out.println("子类构造方法");
}
public void method(){
System.out.println("子类成员方法");
}
public void function(){
int num = 5;
System.out.println(num); //打印方法内局部变量
System.out.println(super.num); //打印父类成员变量
System.out.println(this.num); //打印本类成员变量
super.show(); //调用父类成员方法
this.method(); //调用本类成员方法
}
}
测试类
public class SuperTest {
public static void main(String[] args) {
SonSuper ss = new SonSuper();
ss.function();
}
}
继承中构造方法的关系
- 子类中所有的构造方法默认都会访问父类中空参数的构造方法，除非显示使用super/this调用了父类或者本类的其他构造方法。
- 在类中对本类或者父类构造方法的调用，只能在构造方法中，不能在实例方法总中调用构造方法（更不能在类方法中调用构造方法）
注意构造方法不能递归调用
class A {
public A(int i){
this(1 ,2);
}
public A(int a ,int b){
this(2);
}
}
案例演示
//创建父类
public class A {
public A(){
System.out.println("父类空参构造");
}
public A(String name){
System.out.println("父类有参构造");
}
}
//创建子类继承父类
public class B extends A {
public B(){ //这一步默认执行了 super（）；调用了父类空参
System.out.println("子类空参构造");
}
public B(String name){
super(name); //调用父类有参构造方法
System.out.println("子类有参构造");
}
}
测试类
public class C {
public static void main(String[] args) {
B b = new B();
B b1 = new B("tom");
}
}
如果父类没有空参构造，子类的构造方法中就必须显式调用父类带参构造super(...);
super(…)或者this(…)必须出现在构造方法第一条语句上否则，就会有父类数据的多次初始化
方法重写
子类中出现和父类中一摸一样的方法声明，称为方法覆盖（Override）或重写（OverWrite）
使用特点
- 如果方法名不同就调用对应的方法
- 如果方法名相同最终使用的是自己的（使用子类的引用的时候，在多态情况下，使用父类的引用，则有可能调用的是父类静态方法）
方法重写的应用
- 当子类需要父类功能时，而功能主体子类有自己的特有的内容时，可以重写父类的方法，这样即沿袭了父类的功能，又定义了特有的内容。
-
方法重写是多态实现的条件
//首先创建 一个手机父类 public class PhoneF { public void call(String name){ //定义一个方法 System.out.println("给"+name+"打电话"); } } //在创建一个手机子类继承父类 public class PhoneS extends PhoneF { public void call(String name){ //同名同修饰词 对父类中的方法进行重写 super.call(name); System.out.println("听天气预报"); //在继承父类之后在身再加的打印语句 } } //创建测试类 public class PhoneTest { public static void main(String[] args) { PhoneS ps = new PhoneS(); ps.call("Tom"); } }
方法重写的注意事项
- 父类中私有的方法不能被重写，编译报错；
- 子类重写父类方法时，访问权限不能更低，编译报错；
- 子类重写父类方法时，返回值类型可以相同，也可以是父类返回值的子类型；
- 父类的实例方法（非静态方法），子类不能重新定义为静态方法
- 子类中的重写父类方法，按照重写的原则（访问权限不能变小，返回值类型同类或者为子类，方法名相同，形参列表相同）；
- 子类想重写父类的方法，最好是让方法的签名一模一样；
final关键字
final关键字是最终的意思，可以修饰类，成员变量，成员方法 - 修饰类，类不能被继承（不能放在extends后面） - 修饰变量，变量将变成常量只能被赋值一次，不论是在子类还是本类中，都不能被修改（常量一般是大写字母表示 final int ONE = 1） - 修饰方法，方法不能被重写（子类只用使用权，没有修改权）
final修饰局部变量
- 在方法内部，该变量不可以被改变
- 在方法声明上，基本类型是这个参数的值不能被改变，引用类型，是这个参数只想的地址值不能被改变
总结
类中非static的final变量（实例final变量）可以在生命的时候赋值，如果声明的时候没有赋值的话，就必须在以下两个地方赋值，一个是构造代码块一个是构造方法中，如果这两个地方没有赋值，编译报错。
如果是static修饰的final变量的话，则只能在两个地方赋值，声明的时候，或者在静态代码块中。
多态（polymorphism）
某一个事物，在不同时刻表现出来的不同状态
在Java中，对一个事物的引用可以分成两种类型，一种是编译时的类型，一种是运行时的类型。 编译时的类型指的是声明这个变量时指定的类型；运行时类型指的是实际赋给这个变量的对象的类型。
若Student类继承自Person类，则下面的写法是正确的
Person p = new Student();
注意
父类引用不能调用子类特有的方法，因为使用了父类的引用，就代表站在父类角度来看待当前子类对象，只能看到从父类继承而来的特性，或者是子类重写的父类的方法。成员变量没有多态性，只能看到父类的成员变量。
多态中的成员访问特点
- 成员变量 编译看左边，运行看右边；
- 构造方法 创建子类对象的时候，访问父类的构造方法，对父类的数据进行初始化
- 成员方法 便宜看左边，运行看右边
- 静态方法 编译看左边，运行看右边
多态的前提条件
- 有继承关系
- 有方法重写
- 有父类引用指向子类对象
多态中成员访问特点
成员变量和静态方法没有多态性 只有被子类重写的成员方法才有多态性