JAVA基础语法10 多态 下

JAVA基础语法10

笔记 多态 下

• 问题
  • java只支持单继承
  • 如何解决一个类型中拥有多个不同类型特征

//接口访问修饰符：public 默认
public interface INet {
	/*接口中抽象方法可以不写abstract关键字
    /*访问修饰符默认public
     * 当类实现接口时，需要去实现接口中的所有抽象方法，否则需要将该类设置为抽象类
     */
	void network();
	
	
	//接口中可以包含常量，默认public static final
	int TEMP=20;
	
    //default：默认方法 可以带方法体 jdk1.8后新增
	//可以在实现类中重写，并可以通过接口的引用调用（Inet.super.connection）
	default void connection(){
		System.out.println("我是接口中的默认链接");
	}
	
	//static:静态方法 可以带方法体 jdk1.8后新增
	//不可以在实现类中重写，可以同接口名调用
	static void stop(){
		System.out.println("我是接口中的静态方法");
	}

• 当接口中的常量与类中常量重名 如果是接口指向类的实例化，则调用接口中的常量。如果是类指向类实例化则调用类中的常量。
• 当一个类 继承父类与多个接口的同时有相同的方法名的方法，则调用父类方法不需要重写。但是常量类不占优势 需要指定调用或者重写

• 内部类

• 内部类的分类

  • 成员内部类
  • 静态内部类
  • 方法内部类
  • 匿名内部类

• 成员内部类

• Person

package com.zzh.People;

public class Person {
    int age;

    public Heart getHeart() {

        new Heart().eat();
        return new Heart();
    }

    public void eat() {
        System.out.println("外部类吃东西");
    }

    /*
     * 1、内部类在外部使用时，无法直接实例化，需要借由外部类信息才能完成实例化
     * 2、默认访问权限：只限本包下调用  public：外部包可以调用
     * 3、内部类可以直接访问外部类的成员；如果出现同名属性，优先访问内部类中定义的
     * 4、可以使用外部类.this.成员的方式，访问外部类中同名的信息
     * 5、外部类访问内部类信息，需要通过内部类实例，无法直接访问
     * 6、内部类编译后.class文件命名：外部类$内部类.class
     * 7、内部类中是否可以包含与外部类相同方法签名的方法？以及如何调用？
     * 7、方法：可以拥有相同的方法。同样内部类优先自己的方法，访问外部需要外部类.this.成员的方式
     * 外部访问内部一样需要 Person.Heart myHeart = new Heart().eat();Person person = new Persom()
     * 同时在主函数定义的内部类函数调用的还是内部类的方法。
     *
     */
    class Heart {
        public String beat() {
            Person.this.eat();
            return "心脏在跳动！";
        }
        public void eat() {
            System.out.println("内部类吃东西");
        }
    }
}

• Test

package com.zzh.People;

public class Test {
    public static void main(String[] args) {
        // 方法一
        Person.Heart person = new Person().getHeart();
        System.out.println(person.beat());
        System.out.println("=======================");

        //方法二
        Person.Heart person1 = new Person().new Heart();
        System.out.println(person1.beat());
        System.out.println("=======================");

        //方法三
        Person person2 = new Person();
        person = person2.new Heart();
        System.out.println(person.beat());
        // 调用的是内部类的eat（）
        person.eat();
        System.out.println("=======================");
        // 访问还是内部类的eat()
        Person person3 = new Person();
        person.eat();

    }
}

• 静态内部类

Person

package com.zzh.People;

public class Person {
    int age;

    public Heart getHeart() {
        eat();
        new Heart().eat();
        return new Heart();
    }
    public  void eat() {
        System.out.println("外部类吃东西");
    }
    /**
     * 静态内部类
     * 1、静态内部类中，只能直接访问外部类的静态成员，如果需要调用非静态成员，可以通过对象实例
     * 2、静态内部类对象实例时，可以不依赖于外部类对象 Person.Heart myHeart = new Person.Heart();
     * 3、可以通过外部类.内部类.静态成员的方式，访问内部类中的静态成员
     * 4、当内部类属性与外部类属性同名时，默认直接调用内部类中的成员；
     * 如果需要访问外部类中的静态属性，则可以通过 外部类.属性 的方式；Person.eat();
     * 如果需要访问外部类中的非静态属性，则可以通过 new 外部类().属性的方式；new Person().eat();
     */
    public static class Heart {
        public String beat() {
            new Person().eat();
            return "心脏在跳动！";
        }
        public void eat() {
            System.out.println("内部类吃东西");
        }
    }
}

Test

package com.zzh.People;

public class Test {
    public static void main(String[] args) {
        // 获取静态内部类的对象实例
        Person.Heart myHeart = new Person.Heart();
        System.out.println(myHeart.beat());
    }
}

• 方法内部类

    /**
     * 方法内部类
     * @return
     */
    // 因为Heart 在方法里面，作用范围也在方法内。所有无法使用内部类方法
    public Object getHeart() {
        class Heart {
            public String beat() {
                new Person().eat();
                return "心脏在跳动！";
            }

            public void eat() {
                System.out.println("内部类吃东西");
            }
        }
        // 需要在内部调用，外部无法调用内部类的方法
        return new Heart().beat();
    }
    public  void eat() {
        System.out.println("外部类吃东西");
    }

• 匿名内部类

    //根据不同的人 调用不同的方法
    // 方案1：
    public void getRead(Person person){
        person.read();
    }

    public static void main(String[] args){
        PersonTest personTest = new PersonTest();
        // 匿名内部类:没有类型名称以及实例对象名称 
        personTest.getRead(new Person() {
            @Override
            public void read() {
                //。。。
            }
        });
    }

• 注