接口、多态、内部类等笔记！

1.静态

static静态关键字可以修饰成员变量与成员方法

基本概念：

静态成员属于类
可以通过类名访问，且一般用public修饰
类名.属性名； 类名.方法名(); 也可以通过对象名访问（不建议）

内存解释：

静态内容太静态去，部署与任何一个对象，属于类，静态变量又叫做类变量；
当类加载的时候，静态变量会赋值（类级别优先于对象级别）
多个对象共享一个静态变量，当其中一个对象修改了该变量，将会影响所有对象

静态的注意事项：

静态只能访问静态！（因为加载顺序）
非静态可以访问静态

2.接口

接口（英文interface）在Java编程语言中，是一个抽象类型，是抽象方法（功能） 的集合，接口以interface来声明
弥补了Java单继承的弊端，子类可以在继承一个类的同时实现一个/多个接口，进行功能扩展

接口的定义语法

public interface 接口名 {
		public abstract void 方法名();
		public void 方法名();  //编译后是public abstract void 方法名();
		void 方法名(); //编译后是public abstract void 方法名();
}

接口使用语法

//类实现接口
public class C implement B ,A {    }

接口继承接口
public interface D extends B,A{    }

2.1接口的特征

• 接口不能被实例化
• 实现类必须实现接口中所有的抽象方法，否则该类是一个包含抽象方法的类，应该定义成抽象类
• 一个类可以继承其他类的同时 实现多个接口
• 一个接口可以继承多个接口

2.2 接口中成员的特点

• 普通方法变抽象公共方法：默认加public abstract
• 普通成员变量变静态变量，默认加：public static final
• default 修饰默认方法：子类可以重写也可以不重写
• 接口中的静态方法直接用接口类名调用

public interface IA{
	//1.静态变量       可以被子类继承
	public static final int A = 10;
	int B = 20; //编译后 public static final int B = 20 ;
	public int C = 30;   //编译后 public static final int C =30;
	//2.抽象方法    被子类继承，强制子类重写
	public abstract void show();
	void show1(); //编译后 ：public abstract void show1(); 
	//3.默认方法    被子类继承，子类可以重写，也可以不重写
	public default void show2(){
		Systeam.out.println("IA...>> default show2()........");
}
	//4.静态方法    不能被子类继承，只属于本接口，只能通过本接口名访问
	public static void show3(){
		Systeam.out,println("IA --->  static show3().....");
}

}

3.多态

多态：一个事物的多种形态
多态代码体现 ：父类引用指向子类对象 如 ：Animal a = new Dog();
多态调用后：调用的方法由引用类型说了算！

3.1多态相关

• 多态前提：

• 必须要有继承关系或者实现关系

• 要有子类重写父类对象的方法（这样才有意义）

• 多态的优点：提高代码扩展性

• 多态的缺点：无法使用子类特有的方法

多态的案例：

//两个父类/接口

public class Animal {

    public void eat() {
        System.out.println("吃香香...");
    }

}

public interface Fliable {

    void qifei();
    void fei();
    void luodi();
}

//子类
public class Cat extends Animal{

    //抓老鼠
    public void catchMouse() {
        System.out.println("抓老鼠...");
    }

    @Override
    public void eat() {
        System.out.println("小猫挠着吃...");
    }
}

public class Dog extends Animal {

    public void lookHome() {
        System.out.println("看家汪汪汪....");
    }

    @Override
    public void eat() {
        System.out.println("吃骨头...");
    }
}
public class Bird extends Animal implements Fliable{

    //报时
    public void baoshi() {
        System.out.println("咕咕咕,现在"+new Date());
    }

    @Override
    public void eat() {
        System.out.println("啄着吃..");
    }

    @Override
    public void qifei() {
        System.out.println("翅膀一扇就起飞");
    }

    @Override
    public void fei() {
        System.out.println("扇着翅膀飞");
    }

    @Override
    public void luodi() {
        System.out.println("收起翅膀落地");
    }
}

//多态使用
public static void main(String[] args) {

        Cat cat = new Cat();
        cat.eat();
        cat.catchMouse();
        System.out.println("===================");
        Dog dog = new Dog();
        dog.eat();
        dog.lookHome();
        System.out.println("===================");
        Bird bird = new Bird();
        bird.eat();
        bird.baoshi();
        bird.qifei();
        bird.fei();
        bird.luodi();
        System.out.println("======以上为多态之前=============");
        Animal animal = new Cat();
        animal.eat();
        System.out.println(animal.address);

        Animal animal2 = new Dog();
        animal2.eat();

        Animal animal3 = new Bird();
        animal3.eat();

        Fliable fliable = new Bird();
        fliable.qifei();
        fliable.fei();
        fliable.luodi();

        //==========以下为多态好处体现的代码======================
        Animal c = new Cat();  //不同的子类对象传入method方法中，虽然执行的都是eat方法，但执行的结果不同
        method(c);
        Animal d = new Dog();
        method(d);
        Animal b = new Bird();
        method(b);
}
    
//有了多态后，只需要定义父类类型，接收不同的子类对象
public static void method(Animal a) {
    a.eat();
}

3.2向上向下转型

多态本身的子类对象 赋值给 父类变量》》》 向上转型 例如：Animal a = new Dog();

向下转型 ：强制类型转换
向下转型是，我们可以用instanceof 来判断对象的所属类型

如代码：
//创建饲养员类

public class SiYangYuan {

    public void feed(Animal animal) { //Animal animal = new Cat() 定义父类变量可以接收子类对象
        //是动物都得吃
        animal.eat();

        //判断对象的类型
        //如果是猫，就抓老鼠
        if(animal instanceof Cat) {  
            Cat cat = (Cat)animal;  //向下转型
            cat.catchMouse();
        }
        //如果是狗，就看门
        if(animal instanceof Dog) { 
            Dog dog = (Dog)animal;  //向下转型
            dog.lookHome();
        }
    }
}

4.内部类

成员内部类定义在成员位置，方法外

成员内部类定义：

package com.itheima.demo09;

public class Outer{
    //成员变量
    private String name = "大幂幂";
    //成员方法
    public void method(){...}
    //成员内部类
     class Inner{
        public void innerMethod() {
            System.out.println("成员内部类方法被调用了");
            //我是内部类地方法
            System.out.println(name);
        }
    }
}

成员内部类对象创建：

public class Demo09 {
    public static void main(String[] args) {
        //创建外部类对象
        Outer outer = new Outer();
        outer.method();

        //成员内部类创建对象
        Outer.Inner inner = outer.new Inner();
        Outer.Inner inner2 = new Outer().new Inner();

        inner.innerMethod();
        inner2.innerMethod();
    }
}

成员内部类编译后的class文件： Outer$ inner.class 成员内部类也是一个独立的class文件，所属Outer外部类
成员内部类可以被 private/public /static等修饰符修饰，如果用static修饰，则创建对象方式如下：

//如果成员内部类用static 修饰，则采用一下格式创建对象
Outer.Inner inner = new Outer.Inner();

局部内部类定义：

public class Outer{
    //成员变量
    private String name = "大幂幂";
    //成员方法
    public void method(){

        System.out.println("outer方法被调用了");
        //局部内部类
        class Inner2 {
            public void innerMethod2() {
                System.out.println("局部内部类方法被调用了");
                //我是内部类地方法
                System.out.println(name);
                System.out.println("=================");
            }
        }

        //局部内部类定义出来，即时创建的对象并使用
        Inner2 inner2 = new Inner2();
        inner2.innerMethod2();
    }
}

局部内部类编译后的class文件：Outer $1Inner2.class 局部内部类 注意；局部内部类有编号

5.匿名内部类

没有类名的 局部内部类的对象

格式

//用一个格式，既定义了局部内部类，又创建了该类的对象
  new 父类类型(){
      //重写方法
  }
  
  //目标父类，本案例要创建该类的子类对象
  public abstract class Animal {
    public abstract void eat();
  }

  public static void main(String[] args) {
    //创建对象后，可以利用多态，将该子类对象赋值给父类引用
    Animal animal = new Animal(){

        @Override
        public void eat() {
            System.out.println("吃.....");
        }
    };
    //调用方法
    animal.eat();
  }