2021.03.15

接口和多态

抽象方法
1.接口抽象方法的创建：

public interface Myinterface {
    //这些都是抽象方法必须为public abstract（可不写但是默认有）
    public abstract void methodAbs1();//抽象方法没方法体public和abstract都是可省略的
    abstract void methodAbs2();
    public  void methodAbs3();
    void methodAbs4();

}

2.接口的使用：必须覆盖重写（实现类）

public class MyinterfaceMyinterfaceImpl  implements Myinterface{/*
class 类名 implements 接口名称，快捷键alt + entert启动
    @Override//必须覆盖重写，否则继承抽象类
    public void methodAbs1() {
        System.out.println("one");
    }

    @Override
    public void methodAbs2() {
        System.out.println("two");
    }

    @Override
    public void methodAbs3() {
        System.out.println("three");
    }

    @Override
    public void methodAbs4() {
        System.out.println("four");
    }
}

3.方法的使用

public class Demo {
    public static void main(String[] args) {
        MyinterfaceMyinterfaceImpl inter = new MyinterfaceMyinterfaceImpl();
        //静态方法不需要new对象
        /*
        类名.方法调用
        /*
        inter.methodAbs1();
        inter.methodAbs2();
    }
}

默认方法
1.【public】 default 返回值类型 方法名称 （参数列表）；
2.默认方法也可以被重写

静态方法
【public】 static 返回值类型 方法名称（参数列表）；

package it.cast.cn.Demo05;

public class Demo03MyInterface {
    public static void main(String[] args) {
        //Demo03MyInterfaceImpl impl = new Demo03MyInterfaceImpl();静态static跟对象没关系所有不需要new

        //直接使用接口名称调用
        MyInterfaceStatic.methodStatic();
    }
}

ps:通过接口名称调用，不能通过实现类对象调用所有不需要实现类

私有方法的调用
1.默认私有方法

接口方法定义：

package it.cast.cn.Demo05;

public interface Myinter {
    public default void methodDefault1() {
        System.out.println("默认方法a");
        methodCommon();
    }

    public default void methodDefalut2() {
        System.out.println("默认方法2");
        methodCommon();
    }

    private void methodCommon() {

        System.out.println("AAA");
        System.out.println("BBB");
        System.out.println("CCC");
    }
}

实现类

package it.cast.cn.Demo05;

public class MyinterFacePrivateImpl implements Myinter {
    public void methodAnother(){
       /* //直接访问到了接口中的方法，这样是错误的
        methodCommon();*/
    }
}

调用

package it.cast.cn.Demo05;

public class Demo04Interface {
    public static void main(String[] args) {
       /* MyinterB.methodStatic1();
        MyinterB.methodStatic2();*/
        MyinterFacePrivateImpl a = new MyinterFacePrivateImpl();
        a.methodDefalut2();
    }
}

2.静态私有方法
定义：

package it.cast.cn.Demo05;

public interface MyinterB {
    public static void methodStatic1() {
        System.out.println("默认方法1");
        methodStaticCommon();
    }

    public static void methodStatic2() {
        System.out.println("默认方法2");
        methodStaticCommon();
    }

    private static void methodStaticCommon() {

        System.out.println("AAA");
        System.out.println("BBB");
        System.out.println("CCC");
    }
}

调用：

package it.cast.cn.Demo05;

public class Demo04Interface {
    public static void main(String[] args) {
        MyinterB.methodStatic1();
        MyinterB.methodStatic2();
/*        MyinterFacePrivateImpl a = new MyinterFacePrivateImpl();
        a.methodDefalut2();*/
    }
}

静态代码块

package cn.itcast.dayo8.demo03;
/*静态代码块的格式是:
public class类名称{
static {
//静态代码块的内容
}
}
特点:当第一次用到本类时，静态代码块执行唯一的一次。
*/
public class Person {
static {
System. out. println("静态代码块执行! ");
}
public Person( ) i
System.out.println(“构造方法执行!");
}

静态代码块用来一次性地对静态成员变量进行赋值

继承父类并实现多接口

package it.cast.cn.Demo05;
/*
1.接口不能有static代码块和构造方法
2.一个类的直接父类是唯一的，但是一个类可以同时实现多个接口
格式：
public class MyInterfaceImpl implements MyInterFaceA ,MyInterFace9B{
        //覆写所有抽象方法
}
3.如果实现类的多个接口中，存在重复的抽象方法，那么只需要覆盖重写一次
4.如果没重写那么实现类就是抽象的
5.如果实现类所实现的接口中存在重复的默认方法，那么实现类一定要对冲突的默认方法进行重写。
6.一个类如果直接父类当中的方法，在接口当中的默认方法产生了冲突，优先父类方法。

 */
public class Demo01Interface {
}

针对6：例如：
1.创建父类

package it.cast.cn.Demo05;

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

2.创建子类

package it.cast.cn.Demo05;

public class Zi extends Fu implements MyInterface11{

}

3.继承

package it.cast.cn.Demo05;

public class Demo096 {
    public static void main(String[] args) {
        Zi zi = new Zi();
        zi.method();
    }
}
//结果运行:Fu

多态

/*
访问成员变量的两种方式:
1．直接通过对象名称访问成员变量:看等号左边是谁，优先用谁，没有则向上找。
2.间接通过成员方法访间
3.成员变量不能被重写
4.间接通过成员方法访问成员变量:看该方法属于谁，优先用谁（从写后属于子），没有则向上找

*/
public class Demo01MultiField i
public static void main( string[] args) {
//使用多态的写法，父类引用指向子类对象Fu obj = new Zi();
	System.out.println(obj.num);
	System.out.println(obj.age); //错误写法!
	System.out.println("=============");
	//子类没有覆盖重写，就是父:10
	//子类如果覆盖重写，就是子:2Iobj.showNum();
	
	

/*
在多态的代码当中,成员方法的访问规则是:
看new的是谁，就优先用谁,没有则向上找。
口诀:编译看左边，运行看右边。
对比一下:
成员变量:编译看左边，运行还看左边。成员方法:编译看左边,运行看右边。*
public class Demo02MultiMethod {
public static void main(String[] args)iI
Fu obj = new Zi();//多态
obj.method(); //父子都有，优先用子
obj.methodFu(); //子类没有，父类有，向上找到父类

1.对象向上转型其实就是多态的常规用法

2.对象的向下转型
父类

package it.cast.cn.Demo08;

public class Animal {
    public void eat(){
    }
}

子类cat

package it.cast.cn.Demo08;

public class Cat extends Animal {
    public void eat(){
        System.out.println("猫吃鱼");
    }

    public void eatT(){
        System.out.println("毛特有");
    }
}

子类dog

package it.cast.cn.Demo08;
@Override
public class Dog extends Animal{
    public void eat(){
        System.out.println("狗吃肉");
    }
}

主程序

package it.cast.cn.Demo08;

public class Demo08Test {
    public static void main(String[] args) {
        Animal an = new Cat();//多态
        an.eat();
        /*
        向下转型其实就是还原的过程用instanof,返回一个布尔值；类似强制转换（int num = (int) 10.0可以；
        ；int num = (int) 10.5不可以）
         */
        if (an instanceof Cat) {
            Cat cat = (Cat) an;
            cat.eatT();
        }
        if (an instanceof Dog) {
            Dog dog = (Dog) an;
            dog.eat();
        }
    }
}