面向对象高级

一.内部类

内部类是类中的五大成分（成员变量，方法，构造器，内部类，代码块）之一，如果一个类定义在另一个类的内部，这个类就是内部类。
1.成员内部类
就是类中的一个普通成员，类似我们学过的成员变量和成员方法。
成员内部类中访问其他成员的特点:

public class void main(String[]args){
  outer.Inner in=new outer().new Inner();
        in.tset();
    }
}

public class oute{
	 public class Inner{
	 }
	 }

1、和前面学过的实例方法一样，成员内部类的实例方法中，同样可以直接访问外部类的实例成员、静态成员。
2、可以在成员内部类的实例方法中，拿到当前外部类对象，格式是:外部类名.this。
2.静态内部类
有static修饰的内部类，属于外部类自己持有。
可以直接访问外部类的静态成员，不可以直接访问外部类的实例变量。
3.匿名内部类
就是一种特殊的局部内部类，所谓匿名，指的是程序员不需要为这个类声明名字。

public class Test{
	public static void main(Sting[] args){
	 go(new Swimming() {
           @Override
           public void swim() {
               System.out.println("狗游得飞快");
           }
       });
    }

    public static void go(Swimming s){
        System.out.println("开始-----------------------");
        s.swim();
    }
}
interface Swimming{
    void swim();
}

特点:匿名内部类本质上就是一个子类，并会立即创建出一个子类对象。
作用:用于更方便的创建一个子类对象。

二.枚举类

枚举类是一种特殊类。
注意:
枚举类中的第一行，只能写一些合法的标识符，多个名称用逗号隔开。
这些名称，本质上就是一种常量，每个常量都记住一个枚举的对象。

public class tset {
    public static void main(String[] args) {
        //目标：认识枚举
        A a1=A.X;
        System.out.println(a1);
        //1.枚举类的构造器都是私有的，不能对外创建对象
        //2.枚举类的第一行都是常量，记住的都是枚举类的对象
        //3.枚举类可以提供一个额外类的API
         A [] as=A.values();
        System.out.println(as);

        A a3=A.valueOf("Y");
        System.out.println(a3.getName());
        System.out.println(a3.ordinal());
        System.out.println("----------------------");
        B y=B.Y;
        y.go();
    }
    public enum A {
    //注意事项：枚举类的第一行必须罗列枚举对象的名字
    X,Y,Z;
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}
public enum B {
    X(){
        @Override
        public void go() {

        }
    },Y("zhangsan"){
        @Override
        public void go() {
            System.out.println(getName() + "在跑");
        }
    },Z(){
        @Override
        public void go() {


        }
    };
    private String name;

    B() {
    }

    B(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public abstract void go();
}

}

枚举类的构造器都是私有的(写不写都只能是私有的)，因此，枚举类对外不能创建对象。·枚举都是最终类，不可以被继承 A
·枚举类中，从第二行开始，可以定义类的其他各种成员。
·编译器为枚举类新增了几个方法，并且枚举类都是继承:java.lang.Enum类的，从enum类也会继承到一些方法。

三.泛型

泛型
·定义类、接口、方法时，同时声明了一个或者多个类型变量(如:),称为泛型类、泛型接口，泛型方法、它们统称为泛型。
·作用:泛型提供了在编译阶段约束所能操作的数据类型，并自动进行检查的能力！这样可以避免强制类型转换，及其可能出现的异常。
泛型类:

public class Arrylist<E> {
    //泛型类
    private Object[] arr=new Object[10];
    private int size;
        private boolean add(E e){
            arr[size++]=e;
            return true;
        }
        public E get(int indx){
            return (E) arr[indx];
        }
}

泛型接口:

public class Test {
    public static void main(String[] args) {
        //1.目标：掌握泛型类接口的定义和使用
        //2.场景：系统需要处理学生和老师的书局，两个功能，保存对象数据，根据名称查询数据
        Teacher t=new Teacher();
        TeacherDate teacherDate=new TeacherDate();

        System.out.println(teacherDate);
    }
}

//泛型接口
public interface Date<T> {
    void add(T t);
    ArrayList<T> getBYName(String name);
}

泛型方法:

public class test {
    public static void main(String[] args) {
        //掌握泛型方法的定义和使用
        String rs=test("java");
        System.out.println(rs);

        Dog d=test(new Dog());
        System.out.println(d);
        ArrayList<Car>cars=new ArrayList<>();
        cars.add(new BMW());
        cars.add(new BMW());
        go(cars);

        //?是一个通配符，在使用泛型的时候可以代表一切类型

        ArrayList<BMW> bmws=new ArrayList<>();
        bmws.add(new BMW());
        bmws.add(new BMW());

    }

    public static void go(ArrayList<Car>cars){


    }
 public static <T>T test(T t){
        return t;
 }
}

泛型的擦除问题和注意事项
泛型是工作在编译阶段的，一旦程序编译成class文件，class文件中就不存在泛型了，这就是泛型擦除。·泛型不支持基本数据类型，只能支持对象类型(引用数据类型)。

public class test {
    public static void main(String[] args) {
        //目标：理解泛型的注意事项
        //1.泛型是工作在编译器阶段的，一旦程序编译成class文件，class文件就不存在泛型了，这就是泛型擦除
        //2.泛型不支持基本数据类型，只能支持对象类型（引用数据类型）
        ArrayList<Integer>list=new ArrayList<>();
        list.add(12);
        ArrayList<Double>list1=new ArrayList<>();
        list1.add(22.3);
    }
}