java继承

面向对象的三大特征：

1. 封装性
2. 继承性
3. 多态性

继承是多态的前提，如果没有继承，就没有多态
目的：写一个类 把以后的类都有这个类中的方法。

//创建父级  员工 
public class Employee{
public void method(){
System.out.println("方法执行！");
}

//创建子级 讲师
public class teacher extends Employee{
}
//创建子级 助教
public class Assistant extends Employee{

}
public class Demo{
public static void main(String[] args){

//创建一个子类对象
Teacher teacher=new Teacher();
//Teacher类当中虽然什么都没写，但是会继承来自Employee类中的方法
teacher.method();

//创建另一个子类助教对象
Assistant assistant =new Assistant();
Assistant.method();
}
}

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

//创建fu类
public class Fu{
int numFu=10;
int num=100;
public void methodFu(){
//使用的是本类当中的，不会向下找子类的
System.out.println(num);
}
}
//创建子类
public class Zi extends Fu{
int numZi=20;
int num=200;
public void methodZi  (){
//使用的是本类当中的num。
System.out.println(num);
}
}

public class Demo{
public static void main(String[] args){
Fu fu=new Fu()//创建父类对象
System.out.println("Fu.numFu")；//只能使用父类的东西，没有任何子类内容
 
Zi zi=new Zi();//创建子类对象, // 等号左边是谁，就优先用谁，没有则向上找

System.out.println(zi.num); // 等号左边是谁，就优先用谁，没有则向上找//显示200
System.out.println(zi.abc);//到处都没，就编译错误 

//这个方法是子类的，优先使用子类的
zi.methodZi();//200
//这个方法是在父类定义的 输出是父类的100
zi.methodFu();//
}
}

有关于super的语法

局部变量： 直接写成员变量名
本类的成员变量： this.成员变量名
父类的成员变量： super.成员变量名

//创建父亲
public class Fu{
int num =10;
}

//创建儿子
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 父类的成员变量
}

public class Demo{
public static void main(String[] args){
//创建一个对象
Zi zi=new Zi();
//调用儿子方法
zi.method();// 30 20 10
}
}

方法重名 情况
在父子类的继承关系当中，创建子类对象，访问成员方法的规则：
创建的对象是谁 就优先用谁 如没有就网上找
注意事项：
无论是成员方法还是成员变量，如果没有都是向上找爸爸 没有找儿子的

//创建父亲
public class Fu{
public void methodFu(){
System.out.println("父类方法执行！");
}
public void method(){
System.out.println("父类重名方法执行")
}
}

//创建儿子
public class Zi extends Fu{
public void methodZi(){
System.out.println("子类方法执行！");
}
public void method(){
System.out.println("子类重名方法执行")
}
}
}

public class Demo{
public static void main(String[] args){
Zi zi=new Zi();
zi.methodFu();
zi.methodZi();  

zi.method();//创建的对象是谁 就用谁 没有就向上找
}
}

重写（override）
概念：在继承关系当中，方法的名称一样，参数列表也一样
重写（override）：
方法的名称一样，参数列表也一样。覆盖 覆写
重载（overload）：
方法的名称一样，参数类表不一样

方法的覆盖重写特点：创建的是子类对象，则优先用子类方法
方法的覆盖重写的注意事项：
1 必须保证父子类之间方法的名称相同 参数列表也相同
@override:写在方法前面，用来检测是不是有效的正确覆盖重写。
这个注释就算不写，只要满足要求，也是正确的方法覆盖重写。

2子类方法的返回值必须小于等于父类方法的返回值范围
java.lang.Object 类是所有类的公共最高父类（祖宗类） ,java.lang.String是Object的子类.

3子类方法的权限必须大于等于父类方法的权限修饰符
public > protected>(default)>private
备注（default）不是关键字 而是什么都不写

public class Fu{
public Object method(){
return null;
}
}

public class Zi extends Fu{
@override
public Object method(){   //也可以写成public String method()
return null;
}
}

关于覆盖重写的举例

//老款手机
public class phone{
public void call(){
System.out.println("打电话")；
}
public void send(){
System.out.pritln("发短信")；
}
public void show(){
System.out.println("显示号码");
}

//定义一个新手机 老手机作为父类
public class NewPhone extends phone{
@override
public void show(){
super.show();//把父类的show方法拿过来重复利用//自己的子类再来添加更多内容

System.out.println("显示姓名")；
System.out.println("显示头像")；
}
public class Demo{
public static void main(String[] args){
Phone phone =new phone();
phone.call();
phone.send();
phone.show();

NewPhone newphone =new NewPhone();
phone.call();
phone.send();
phone.show();
}

}
}
}

继承关系中的构造方法
1

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

public class Fu{
int num=10;
public void method(){
System.out.println("父类方法")
}
}

public class Zi extends Fu{
int num=20;
public Zi(){
super();//3
}

public void methodZi(){      //1
System.out.println(num);//20
system.out.println(super.num)//10
}


public void method(){
super.method();//访问父类中的method//2
System.out.println("子类方法")
}
}

this关键字
1在本类的成员方法中，访问本类的成员变量
2 在本类的成员方法中，访问本类的另一个成员方法。
3 在本类的构造方法中，访问本类的另一个构造方法

public class Fu{
int num=30;}

public class Zi extends Fu{
int num=10;
public void method(){
int num=20;
System.out.println(this.num);//局部变量 10//1
System.out.println(num);//成员变量20
System.out.println(super.num);//父类中的成员变量

public void method(){
this.method();//2
}

public Zi(){
this(123);//本类的无参数构造 调用本类的有参数构造//3注意：
//this（...)调用也必须是构造方法的第一个语句，唯一一个 就是不能调用两个有参数的 在案例中。super和this不能同时使用，因为sper也要是唯一且第一个语句
//错误 this.Zi(123,124);
}
public Zi(int n){
}
public Zi(int n,int m）
}

Java语言是单继承的
一个类的直接父类只能有唯一一个（一个类只有一个爸爸 ）
Java是可以多级继承的
一个类可以有爷爷
Java的直接父类是唯一的，但一个父亲可以有多个子类