java 第四章 面向对象（下）继承和多态

继承

继承设计原则:对于已经投入使用的类，尽量不要进行修改。
推荐定义一个新的类，来重复利用其中共性内容，并且添加改动新内容。

理解：
继承是多态的前提，如果没有继承，就没有多态。
类比：师父会多少武功，大徒弟也都会，小徒弟也都会。
继承主要解决的问题就是:共性抽取。
父类也可以叫基类、超类
子类也可以叫派生类
继承关系当中的特点:
1.子类可以拥有父类的“内容”
2.以拥有自己专有的内容。
特点：
Java语言是单继承的。一个类的直接父类只能有唯一一个。
class A {}
class B extends A {}//正确
class C{}
class D extends A,C{}//错误
Java语言可以多级继承。
我有一个父亲，我父亲还有一个父亲，也就是爷爷。

因为：

格式：
在继承的关系中，“子类就是一个父类”。也就是说，子类可以被当做父类看待。

定义父类的格式:(一个普通的类定义)
public class父类名称{
/ / …
}
定义子类的格式:
public cLass 子类名称 extends 父类名称{
//…
}
子类可以调用父类的方法即使子类方法中什么也不写

代码：

//定义一个父类:员工
public class Employee {
   
	public void method() {
   
	System.out.println("方法执行!");
	}
}

//定义了一个员工的子类:讲师
public class Teacher extends Employee {
   
	
}

public class Demoo1Extends {
   
	public static void main(String[] args) {
   
		//创建了一个子类对象
		Teacher teacher = new Teacher();
		//Teacher类当中虽然什么都没写，但是会继承来自父类的method方法。
		teacher.method();
	}
}

继承中成员变量的访问特点

在父子类的继承关系当中，如果成员变量重名，则创建子类对象时，访问有两种方式:
直接通过子类对象访问成员变量:
规则：等号左边是谁，就优先用谁,没有则向上找。

 Zi zi = new Zi();
 	 System.out.println(zi.num);

间接通过成员方法访问成员变量:
该方法属于准，就优先用谁,没有则向上找。

public class Zi extends Fu {
   
	int numZi = 20;
	int num = 200;
	public void methodzi() {
   
		//因为本类当中有num,所以这里用的是本类的num，而不是父类的num
		System.out.println(num);
	}
}

区分子类方法中重名的三种变量

局部变量: 直接写成员变量名
本类的成员变量: this.成员变量名
父类的成员变量: super.成员变量名
在父子类的继承关系当中，创建子类对象，访问重名成员方法的规则:
创建的对象是谁（看new的是谁）,就优先用谁，如果没有则向上找。

new三重名
public class Zi extends Fu {
   
	int num = 20;
	public void method() {
   
	int num = 30;
	System.out.println(num); // 30，局部变量
	System.out.println(this.num); // 20，本类的成员变量
	System.out.println(super.num);// 10，父类的成员变量
	}
}

继承中方法的覆盖重写

重写( Override)
概念:在继承关系当中，方法的名称一样，参数列表也一样。
重写(Override):方法的名称一样，参数列表【也一样】。覆盖、覆写。
重载（OverLoad):方法的名称一样，参数列表【不一样】。
方法覆盖重写的注意事项;
1．必须保证父子类之间方法的名称相同，参数列表也相同。
@Override:写在方法前面，用来检测是不是有效的正确覆盖重写。这个注解就算不写，只要满足要求，也是正确的方法覆盖重写。
2．子类方法的返回值必须【小于等于】父类方法的返回值范围。
小扩展提示。java.Lang.object类是所有类的公共最高父类（祖宗类），java.Lang. string就是object的子类。
3．子类方法的权限必须【大于等于】父类方法的权限修饰符。
小扩展提示:public > protected > (default) > private
备注:(default)不是关键字default，而是什么都不写，留空。

//定义一个新手机，使用老手机作为父类
public class NewPhone extends Phone {
   
	//@Override
	public void show() {
   
		super.show(); //把父类的show方法拿过来重复利用
		//自己子类再来添加更多内容
		System.out.println("显示姓名");
		System.out.println("显示头像");
	}
}

构造方法的访问特点

继承关系中，父子类构造方法的访问特点:
1．子类构造方法当中有一个默认隐含的“super()"调用，所以一定是先调用的父类构造，后执行的子类构造。

package cn.itcast.day09.demo07 ;
public class Fu {
   
	public Fu() {
   
		System.out.println("父类构造方法!");
	}
}
package cn.itcast.day09.demo07;
public class Zi extends Fu {
   
	public Zi() {
   
		super(); //在调用父类无参构造方法,不写也照样有
		System.out.println("子类构造方法!");
	}
}
先输出父类构造

2.子类构造可以通过super关键字来调用父类重载构造。

public class Fu {
   
	public Fu() {
   
		System.out.println("父类无参构造");
	}
	public Fu(int num) {
   
		System.out.println("父类构造方法!");
	}
}
public class Zi extends Fu {
   
	public Zi() {
   
		//super(); //在调用父类无参构造方法
		super(20);//在调用父类重载的构造方法
		System.out.println("子类构造方法!");
	}
}

3.super的父类构造调用，必须是子类构造方法的第一个语句。不能在一个子类写两个super

super(); //在调用父类无参构造方法
super(20);//在调用父类重载的构造方法

总结:
子类必须调用父类构造方法，不写则赠送super();写了则用写的指定的super调用，super只能有一个，还必须是第一个。

super关键字

super关键字的用法有三种:
1．在子类的成员方法中，访问父类的成员变量。
2．在子类的成员方法中，访问父类的成员方法。
3．在子类的构造方法中，访问父类的构造方法。

public class Zi extends Fu {
   
	int num = 20;
	public Zi(){
   
		super();
	}
	public void methodZi() {
   
		System.out.println(super.num); //父类中的num
	}
	public void method() {
   
		super.method(); //访问父类中的method
		System.out.println("子类方法");
	}
}

this关键字

super关键字用来访问父类内容，而this关键字用来访间本类内容。用法也有三种:
1．在本类的成员方法中,访问本类的成员变量。
2．在本类的成员方法中，访问本类的另—个成员方法。
3．在本类的构造方法中，访问本类的另一个构造方法(注意：this(…)调用也必须是构造方法的第一个语句,也不能写多个。super和this两种构造调用，不能同时使用)。

public Zi() {
   
	//super(); //这一行不再赠送，赠送的话this就不是第一个了
	this(123); //本类的无参构造，调用本类的有参构造
	//this(1,2); //错误写法!不能同时写两个this调用
	}
	public Zi(int n) {
   
		
	}
	public Zi(int n, int m) {
   
		
	}
}
public class Zi extends Fu {
   
	int num = 20;
	public void showNum( ) {
   
		int num = 10;
		System.out.println(num); //局部变量
		System.out.print1n(this.num);//本类中的成员变量
		System.out.println(super.num); //父类中的成员变量
	}
	public void methodA( ) {
   
		System.out.println("AAA");
	}
	public void methodB() {
   
		this.methodA();
		System.out.println("BBB");
	}
}

抽象

一个动物肯定可以吃东西，但是吃什么东西不一定

抽象方法和抽象类

抽象方法:就是加上abstract关键字，然后去掉大括号，直接分号结束。
抽象类:抽象方法所在的类，必须是抽象类才行。在cLass之前写上abstract即可。抽象类是__不能实例化的类____。

如何使用抽象类和抽象方法:

1. 不能直接创建new抽象类对象。
2. 必须用一个子类来继承抽象父类。
3. 子类必须覆盖重写抽象父类当中所有的抽象方法。
   覆盖重写（实现)∶子类去掉抽象方法的abstract关键字，然后补上方法体大括号。
4. 创建子类对象进行使用。

public abstract class Animal {
   
//这是一个抽象方法，代表吃东西，但是具体吃什么(大括号的内容）不确定。
	public abstract void eat();
}
public class Cat extends Animal {
   
	public void eat() {
   
		System.out.print1n("猫吃鱼");
	}
}
public class MyClass {
   
	public static void main(String[] args) {
   
		Cat cat=new Cat();
		cat.eat();
	}
}
输出：猫吃鱼

例题：

public class Demo {
   
    public static void main(String[] args) {
   
        Demo demo = new Demo();
        demo.show(new Car() {
   
            public void run() {
   
                System.out.println("demo run");
            }
        });
    }
    public void show(Car c) {
   
        c.run();
    }
}
abstract class Car {
   
    public void run() {
   
        System.out.println("car run...");
    }
}
输出：
demo run

注意事项：
关于抽象类的使用，以下为语法上要注意的细节，虽然条目较多，但若理解了抽象的本质，无需死记硬背。

1.抽象类不能创建对象，如果创建，编译无法通过而报错。只能创建其非抽象子类的对象。

理解:假设创建了抽象类的对象，调用抽象的方法，而抽象方法没有具体的方法体，没有意义。

2.抽象类中，可以有构造方法，是供子类创建对象时，初始化父类成员使用的。

理解:子类的构造方法中，有默认的super()，首先会访问父类构造方法。

3.抽象类中，不一定包含抽象方法，但是有抽象方法的类必定是抽象类。

理解:未包含抽象方法的抽象类，目的就是不想让调用者创建该类对象，通常用于某些特殊的类结构设计。
这样没有抽象方法的抽象类，也不能直接创建对象，在一些特殊场景下有用途。
public abstract class MyAbstract {
}

4.抽象类的子类，必须重写抽象父类中所有的抽象方法，否则，编译无法通过而报错。除非该子类也是抽象类。

理解:假设不重写所有抽象方法，则类中可能包含抽象方法。那么创建对象后，调用抽象的方法，没有意义。

接口

生活中的接口举例：电源插座当中的电源接口
接口就是一种公共的规范标准。
只要符合规范标准，就可以大家通用。
例如：只要符合USB接口的规范,那么各种设备都可以使用:
U盘、打印机、夜读灯、USB小风扇…

接口就是多个类的公共