day 10：Java的继承和接口

多态成员访问特点：编译看左边（父类引用类型），运行看左边（看父类引用类型）,编译也看左边

子类的成员变量和父亲的相同，则父类成员变量自动隐藏；

子类的方法和父类的方法相同，则覆盖替换；

package bamzhy.day10;

public class Demo1 {
    //动物是动物
    public static void main(String[] args) {


        Animal animal = new Animal();
        //狗是狗
        Dog dog = new Dog();
        Animal ani = new Dog();//父类引用指向子类实例
         System.out.println(ani.number);
        System.out.println(ani.number2);
        ani.eat();
        ani.sleep();//方法看子类

        //多态中成员访问的特点
        //1、成员变量的访问


    }
}
   class Animal{
    int number=1;
    int number2=2;
    public void eat(){
        System.out.println("Animal eat");
    }
       public void sleep(){
           System.out.println("Animal sleep");
       }
       public int getNumber(){
        return number;
       }
   }
   class Dog extends Animal{
    int number=100;
    int number2=1000;
       public void eat(){
           System.out.println("Dog eat");
       }
       public void sleep(){
           System.out.println("Dog sleep");
       }
       public void play(){
           System.out.println("Dog play");
       }
       public int getNumber() {
           return number;
       }

package bamzhy.day11;
/*
接口的特点：
接口使用interface关键字进行声明
interface 接口名{}
类的实现接口使用implements表示（类实现接口之后，类和接口之间的关系，可就相当于继承关系）
格式：class类名implements接口名{}
1、接口不能被直接实例化，只能通过子类（接口的实例化天然具有多态的特定）

接口的子类（implemnts关键字）
要么是抽象类，要么重写接口中的所有抽象方法变成一个普通类
接口中的成员特点：
1、接口中的成员都是public的，不能指定其他的访问控制度
2、接口中的成员变量默认是static final的，必须显式初始化
3、接口中没有构造方法
4、接口中的方法，所有方法全都是抽象方法
*/
public class InterfaceDemo1 {
    public static void main(String[] args) {
        //接口不能直接被实例化
//        Interface1 inter1=new Interface1Impl1() {
//    }
    }

    interface Interface1 {
        int i = 10;

        void testInfer1();
    }

    class InterfaceImp1 implements Interface1 {
        public void testInfer1() {

        }
    }
}
abstract class Interface1Impl1 implements InterfaceDemo1.Interface1 {

package bamzhy.day12;
/*
利用接口描述马戏团中的猫和狗
1、因为马戏团中的猫和狗都具备一些特殊的技能，比如计算
2、这些技能并非所有的猫和狗都具备的，所以这些方法并不适合放在animal或者DOg、cat中
3、这些行为应该放在哪里呢？引入接口——一组扩展性功能的描述
 */
public class InterfaceDemo2 {
    public static void main(String[] args) {
        Animal[] animal={new Dog(),new Cat(),new TrainDog(),new TrainCat()};
        for (int i = 0; i <animal.length; i++) {
            if(animal[i] instanceof AnimalTrain){
                AnimalTrain trainer=(AnimalTrain) animal[i];
                trainer.caculate();
            }
        }
    }
}
class Cat extends Animal{
}
class Dog extends Animal{
}
class Animal{
}
interface AnimalTrain{
    public void caculate();
}
class TrainCat extends Cat implements AnimalTrain{

    @Override
    public void caculate() {
        System.out.println("狗计算");
    }
}
class TrainDog extends Dog implements AnimalTrain{
    @Override
    public void caculate() {
        System.out.println("猫计算");
    }
}

package bamzhy.day12;
/*
三个关系：（主要从继承的角度来看）
1、普通类之间的关系，可以互相继承
2、接口和普通类之间的关系
普通类可以通过实现接口，从而使得普通类称为接口的子类
3、接口和接口
一个接口可以有多个父接口，子接口拥有所有父接口中声明的方法（接口和接口之间可以多重继承）
接口可以继承多个接口，但是不能继承类

java语言中，类只支持单亲继承，一个类只能有唯一的父类
 */
public class InterfaceDemo3 {
    public static void main(String[] args) {

    }

}
interface inter1{
    int i=10;
    void play1();
}
interface inter2{
    void play2();
}
interface inter3{
    int i=10;
    void play3();
}
interface inter4 extends inter1,inter2,inter3{
    int i=100;
}

//普通类
class A implements inter1{

    @Override
    public void play1() {

    }
}

//抽象类
abstract class B implements inter1{
}
//一个类可以继承一个父类的同事，实现一个或者多个接口，extends关键字必须位于implements关键字之前
class C extends A implements inter2,inter3{

    @Override
    public void play2() {

    }

    @Override
    public void play3() {

    }
}
class G implements inter4{

    @Override
    public void play1() {
        System.out.println(i);
        System.out.println(inter1.i);
    }

    @Override
    public void play2() {

    }

    @Override
    public void play3() {

    }
}
class H extends Object{

}
//interface inter5 extends inter1,inter2,C{
//
//}
//接口不能继承普通类

package bamzhy.day12;
/*
jdk8以后，interface中可以有另外两种方法default方法和static方法
default方法是有方法体的，并不强制所有子类一定要覆盖该方法，如果你新定义了一个方法在接口中，又不想所有类都覆盖该方法，就用default
static方法的意义是，将静态方法与类定义重新结合，接口当中的工具方法都被推荐定义为静态方法
 */
public class InterfaceDemo4 extends InterTest.Test {
    public static void main(String[] args) {
        InterTest haha=new InterTest() {
            @Override
            public void lol() {
                System.out.println("这是普通方法");
            }
        };
        haha.pubg();
        haha.lol();
        InterTest.print();
    }
}
//使用接口中类型时，仅仅需要实现抽象方法，default、static方法均不需要强制自己新实现
interface InterTest {
    void lol();

    default void pubg() {
        System.out.println("这是default方法");
    }

    static void print() {
        for (int i = 0; i < 5; i++) {
            System.out.println("static可以自己写方法体");
        }
//调用静态方法可以无需创建对象,直接类名.方法名
// 静态方法在访问本类的成员时，只允许访问静态成员（即静态成员变量和静态方法），
// 而不允许访问实例成员变量和实例方法；实例方法则无此限制
// 在编译期间静态方法的行为就已经确定，而实例方法只有在运行期间当实例确定之后才能确定。
    }

    class Test implements InterTest {

        @Override
        public void lol() {

        }

        public void playPubg() {
            pubg();
        }
    }
}