菜鸡学习day10_01_接口&多态性&定义抽象方法私有方法&子接口

菜鸡学习day10_01

package day10;
/*
接口就是多个类的公共规范
接口是一种引用数据类型（最重要的内容是抽象方法）

定义接口格式：     public interface 接口名称{
}
接口中包含的内容
1.常量
2.抽象方法
3.默认方法
4.静态方法
5.私有方法

接口使用步骤
1.接口不能忘直接使用，必须要一个实现类来实现接口
格式：     public class 实现类名称 implements 接口名称{
           }
2.实现类必须覆盖重写所有抽象方法（去掉abstract 加上{}）
3.创建实现类对象

实现类对象不能调用静态方法
调用格式：      接口名称.静态方法名称（参数）；

extends继承或implements实现，是实现多态性的前提

多态性
一个对象同时拥有多种形态，叫做对象的多态性
父类引用指向子类对象
格式      父类名称 对象名 = new 子类名称（）；
          父类名称 对象名 = new 实现类名称（）；
注：使用对象时，若方法重名，先找子类方法（new），没有就向上找
    访问成员变量，若重名，1.直接通过对象访问成员变量：优先等号左边
                        2.间接通过成员方法访问：优先看方法属于谁
                        编译看左，运行看左
    访问成员方法，若重名，编译看左，运行看右
左边统一

对象的向上转型（多态写法）
父类名称 对象名 = new 子类名称（）；
创建一个子类对象，把他当作父类看待（父类引用指向子类对象）
注：向上转型一定是安全的（小范围转大范围）
    一旦转为父类，就无法使用原子类特有内容
对象的向下转型（还原）
子类名称 对象名 = （子类名称）父类对象
将父类对象还原为本来的子类对象
注：1.必须保证对象创建时就是这个子类，现在还原为子类
    2.若对象本来不是这个子类，则报错
    类似于强制类型转换 int num = （int）10.0 √
                     int num = （int）10.5 ×精度损失

判断一个父类对象本来是什么子类
对象 instanceof 类名称
将得到一个boolean结果（判断前面的对象是否能当作后面类型的实例）
 */
public class D1001 {
     
    public static void main(String[] args) {
     
        Shixian sh = new Shixian();
        sh.method1();//调用抽象方法（实现类）
        sh.method2();
        sh.methoddefault1();//调用默认方法，实现类中覆盖重写了（若实现类中没有，向上找）

        Jiekou.methodstatic();//调用静态方法

        sh.methoddefault2();//调用默认方法（里面调用了私有方法）

        System.out.println(Jiekou.NUM_ONE);//调用接口常量

        Fu obj1 = new Shixian();//向上转型，父类引用指向子类对象
        obj1.method();//若方法重名，先找子类方法，没有就向上找

        if(obj1 instanceof Shixian){
     //判断obj1本来的子类是什么
            Shixian obj2 = (Shixian) obj1;//向下转型，还原
            obj2.method();
        }
        if(obj1 instanceof Zi2){
     
            Zi2 obj3 = (Zi2) obj1;
            obj3.method();
        }

    }
}

package day10;
/*
定义抽象方法
public abstract 返回值类型 方法名称（参数列表）；
注：抽象方法的修饰符 public abstract 可省略

定义默认方法（java8）
public default 返回值类型 方法名称（参数列表）{
    方法体；
}
注:默认方法可以解决接口升级问题，拼接函数模型？

定义静态方法（java8）
public statuc 返回值类型 方法名称（参数列表）{
    方法体；
}

定义私有方法（java9）接口中使用
1普通（解决多个默认方法之间重复代码问题）
private 返回值类型 方法名称（参数列表）{
}
2静态（解决多个静态方法之间重复代码问题）
private static 返回值类型 方法名称（参数列表）{
}

定义“成员变量”
必须用public static final修饰（可以省略），相当于接口的常量
格式：     public static final 数据楔形 常量名称 = 数据值
注：1.一旦赋值就不可修改（final关键字）
    2.接口常量必须赋值
    3.接口常量名称    大写_

使用接口注意事项
1.接口不能有静态代码块/构造方法
2.一个类只有一个直接父类，但一个类可以同时实现多个接口
格式：     public class 实现类名称 implements 接口1，接口2{}
3.若实现类实现的多个接口中存在多个重名抽象方法，只需覆盖重写1次
4.若实现类没有覆盖重写所有抽象方法，则实现类必须是抽象类
5.若多个接口中有重复的默认方法，实现类必须覆盖重写重复的默认方法
6.若直接父类的方法与接口默认方法冲突，则优先父类



 */
public interface Jiekou {
     
    public abstract void method1();
    abstract void method2();
    public void method3();
    void method4();//都是抽象方法

    public default void methoddefault1(){
     //默认方法
        System.out.println("添加了一个默认方法。");
        methodsiyou();
    }

    public default void methoddefault2(){
     //默认方法
        System.out.println("添加了一个默认方法。");
        methodsiyou();
    }

    public static void methodstatic(){
     //静态方法

    }

    private void methodsiyou(){
     //私有方法
        System.out.println("调用了私有方法。");
    }

    public static final int NUM_ONE = 10;//定义接口常量
}

package day10;

public interface Jiekou2 {
     

}

package day10;
/*
子接口
接口之间是多继承的
父接口抽象方法重复，不用覆盖重写
      默认方法重复，需要覆盖重写，并且带上关键字default
 */
public interface Jiekou3 extends Jiekou,Jiekou2 {
     

}

package day10;
/*
实现类可以覆盖重写默认方法
 */
public class Shixian extends Fu implements Jiekou{
     

    @Override
    public  void method1(){
     
        System.out.println("第一个方法。");
    }
    @Override
    public void method2(){
     
        System.out.println("第二个方法。");
    }
    @Override
    public void method3(){
     

    }
    @Override
    public void method4(){
     

    }//都是抽象方法

    @Override
    public void methoddefault1(){
     //默认方法
        System.out.println("实现类覆盖重写了默认方法。");
    }

    public void method(){
     
        System.out.println("第一个子类。");
    }
}

package day10;

public class Fu {
     
    public void method(){
     
        System.out.println("父类");
    }
}

package day10;

public class Zi2 extends Fu {
     
    public void method(){
     
        System.out.println("第二个子类。");
    }
}