继承

一、继承

继承就是子类继承父类可以继承的属性和方法。

如何确定子父类，父类是子类的共同点集合，通过一层层寻找共性确定父类，父类位于顶部地位。

设计继承是由下往上，写代码是从上往下

二、继承的格式extends

class 子类 extends 父类
 三.继承的好处

1、继承的出现提高了代码的复用性，提高软件开发效率。

2、继承的出现让类与类之间产生了关系，提供了多态的前提。

java只支持单继承，如父类a，b，子类c只能单继承a，b其中一个

java多个子类能继承一个父类，如子类a，b能够继承父类c

java支持多层继承，如a可以继承b也可以成为c的父类

Object是祖宗类，这里面不需要写extends

四、继承的成员变量重名的解决

如封装是this来调取本类对象，继承中也可以用this（本类中使用），更重要的是supper（子类中调取父类变量）.成员变量（只是把父类成员变量调取过去）

①super只能写在子类中
②this子类父类都可
两者调取的都是类中的方法和属性
this，super都写在方法名中
子类都可以用super
注意：
假如说子类私有，父类是无法访问的

子类和父类出现同名成员变量时，
        如果子类有，调子类的，如果子类没有，掉父类，就近原则
例如：

public class Fu {
    //创建父类成员变量
    int i=1；
}
public class Zi extends Fu{
    int  i=2;
    public void show(){
        //就近原则
        //子类成员变量
        int i=3;
        System.out.println(i);  //3 =就近原则=局部变量
        System.out.println(this.i);  // 本类的成员变量 =this.i     =2
        System.out.println(super.i); //1 父类对象只能存在在子类中，可以跨子父类调取=父类的i=1
        }    public static void main(String[] args) {
        //创建子类对象
        Zi z=new Zi();
        System.out.println(z.i); //2 调取本类中的成员变量i

 五.方法重写：

方法重写是子类重写父类，如果子类没有则调取父类方法，如果父类和子类出现一模一样的方法，则是特殊情况覆盖。

方法重写的好处是即继承了父类的元素，又有子类特有的元素

1：在子父类中2、出现一样方法声明，出现覆盖重写

   写法上稍微注意:必须一模一样:方法的返回值类型 方法名 参数列表都要一样。

如：

父类
public class Fu {
    //创建父类成员变量
    int i=1;
    //方法的重写
    public void eat(){
        System.out.print("爸爸吃饭");
    }

子类
public void eat(){
        //调取父类方法联合自己的方法,父类对象名.方法名（）；
        super.eat();
        System.out.println("儿子吃肉");
        
    }

测试：
public class Cs_fu {
    public static void main(String[] args) {
        z.show();
        //2  1
        //方法重写1：、在子父类中2、出现一样方法声明，出现覆盖重写
        //调取子类中的eat
        z.eat();//方法重写从父类先走，相当于将父类+子类的方法放到了一起
    }

六：抽象类：abstarct

方法功能声明相同，但方法功能主体不同。那么这时也可以抽取，但只抽取方法声明，不抽取方法主体。那么此方法就是一个抽象方法。（总感觉是一个中转作用）
抽象类一般是父类，说不明白的东西，不能new对象
抽象类中可以不放抽象类，但抽象类一定要放在抽象方法中
抽象类中可以放变量，后面可以继承
抽象方法只能有方法名，没有方法体，只能作为继承出现，就是为了继承出现的。
必须要把抽象类全部重写带上方法体，子类才可以创建对象，

注意：
抽象关键字abstract不可以和哪些关键字共存。
private：私有的方法子类是无法继承到的，也不存在覆盖，
而abstract和private一起使用修饰方法，abstract既要子类去实现这个方法，而private修饰子类根本无法得到父类这个方法。互相矛盾。
final修饰的不能被修改。静态修饰符static不进堆栈，直接在静态方法区就开始运行。

例如：

原先用封装需要将员工中的员工名字，性别提取到父类中，但是研发部员工和维护部员工就空出来没有作用，而我们学习继承抽象之后就可以利用继承不停的向上提取共性，确定员工中的名字和性别并提取到研发部和维护部中，但是抽象告诉我们可以只在这里面定义两个抽象类姓名和性别，不需要一个一个定义方法，后面子类只需要继承抽象类，重写方法从而在子类调取父类元素进行输出。

代码如下：

//抽象父类 研发部员工
package com.oracle.demo04;
//抽象方法一定在抽象类里,抽象类不一定是抽象方法
//抽象类研发部员工
public abstract class Developer {抽象类书写格式
    int  did;
    String dname;
    //没有方法体，抽象方法
    public abstract void work(); 抽象方法书写格式
    
}
public class JavaEE  extends Developer{ 继承的书写格式
    //重写可以让抽象类变成普通类，子类继承父类，方法名.参数.返回值相同
//继承普通子类
public void work() {
        //重写将抽象类变成普通类
            System.out.println("工号为"+did+"姓名为"+dname+"的员工正在写Andriod代码");
    }
public class Andriod extends Developer {
//重写可以让抽象类变成普通类，子类继承父类，方法名.参数.返回值相同
    public void work(){
        System.out.println("工号为"+did+"姓名为"+dname+"的员工正在写javaEE代码");
    }

//抽象父类 研发部员工
package com.oracle.demo04;
//抽象方法一定在抽象类里,抽象类不一定是抽象方法
//抽象类研发部员工
public abstract class Developer {
    int  did;
    String dname;
    //没有方法体，抽象方法
    public abstract void work();
    
}
//继承普通子类
public void work() {
        //重写将抽象类变成普通类
            System.out.println("工号为"+did+"姓名为"+dname+"的员工正在写Andriod代码");
    }
//重写可以让抽象类变成普通类，子类继承父类，方法名.参数.返回值相同
    public void work(){
        System.out.println("工号为"+did+"姓名为"+dname+"的员工正在写javaEE代码");
    }
测试：
    public static void main(String[] args) {
        JavaEE java =new JavaEE();
        java.did=123;
        java.dname="小红帽";
        java.work();
        Andriod an=new Andriod();
        an.did=456;
        an.dname="灰色";
        an.work();

结果：

六.二接口：interface
它仍然是特殊类，只能写抽象类，使用interface关键字，仍是class文件，是继承的一个表现形式。
是一个功能的集合，作为一个公共访问的抽象方法，解决继承外额外的功能，只描述方法，不实现
定义格式：
public interface 接口名{
抽象方法1；
抽象方法2；
抽象方法3；
}
类继承类extends==继承 class zi extends fu 继承
类实现接口==implements类实现接口  class zi implement eat 实现接口

接口接口是继承关系==extends  zi implement eat 互为继承

实现接口后，将接口中的所有抽象方法继承
接口弥补java的单继承，普通学生类实现学生中有烟喝酒接口类，先继承后实现
public class Student implements  preson Smoking,Drink

接口中成员特点
1.接口中可以定义常量：
必须要有特定的修饰符public static final ，就算是不写，也是静态常量，后面不能更改
    静态常量
    static：用类名.变量名 去访问取值 class.farnaml
    final:一次赋值，终身不变，必须赋值
    public static final int a=1;

2、接口中可以定义方法，方法也有固定的修饰符，public abstract void eat（）；

3、接口不可以创建对象。不可以new对象

4、子类必须覆盖掉接口中所有的抽象方法后，子类才可以实例化。否则子类是一个抽象类。

接口的多继承：弥补了java不能多继承。
接口可以多继承，java不能多继承

package com.oracle.demo05;
//类实现接口
//类继承类extends关系继承，当类和接口的时候implements类实现接口，接口接口是继承关系继承
//接口弥补java的单继承，普通学生类实现吸烟喝酒接口功能，挑选出坏学生
//public class Student implements  preson Smoking,Drink
public class Student implements Smoking,Drink{
    public void smoke() {
        //常量是固定的，不能在子类中修改
        //Smoking.a=5;
        System.out.println("学生抽烟");
    }
    public void drink() {
        //Smoking.a=5;
        System.out.println("学生抽烟");
    }     
}
package com.oracle.demo05;
//类实现接口
//类继承类extends关系继承，当类和接口的时候implements类实现接口，接口接口是继承关系继承
//接口弥补java的单继承，普通学生类实现吸烟喝酒接口功能，挑选出坏学生
//public class Student implements  preson Smoking,Drink
public class Student implements Smoking,Drink{
    public void smoke() {
        //常量是固定的，不能在子类中修改
        //Smoking.a=5;
        System.out.println("学生抽烟");
    }
    public void drink() {
        //Smoking.a=5;
        System.out.println("学生抽烟");
    }    
}
//接口  ==喝酒的共同集合
public interface Drink {
    //接口里面只能放抽象方法
    public abstract void drink();
    //public static final 就算是不写，也是静态常量
    //静态常量
    //static：用类名.变量名去访问取值
    //final:一次赋值，终身不变，必须赋值
    public static final int a=1;
    //public abstract 已经定义好
    //定义抽象方法
        public abstract void smoke();

5.抽象类和接口的区别：
抽象类可以有普通方法，接口只能包含抽象方法
一个类只能继承一个直接父类，但可以实现多个接口（弥补单继承）
必须要重写，否则子类是抽象类
抽象类继承父类具有的功能和方法，接口是实现额外的功能
接口的作用：
接口降低了耦合性，为设备和设备之间进行了解耦
接口和抽象类是继承类的内容
接口拓展了功能