抽象类：

1. 抽象类可以写普通方法，但有抽象方法必须是抽象类
2. 不能new这个抽象类，只能靠子类去实现它：约束！

接口的作用：

1. 约束
2. 定义一些方法，让不同的人实现~
3. 默认方法都是public abstract
4. 属性都是常量且public abstract final
5. 接口不能被实例化~，接口中没有构造方法
6. implements可以实现多个接口
7. 必须要重写接口中的方法

内部类：

成员内部类：
    1. 可直接调用外部类的私有属性和方法
    2. 内部类的属性和外部类相同时会优先调用内部类
    3. 属性相同时，在内部类可用Outer.this.属性名，调用外部类的属性
    4. 实例化内部类对象时要先实例化外部类对象，再Outer.Inner inner = outer.new Inner();创建对象
    5. 不可使用static，除非是用final修饰的常量

静态内部类：
    1. 和外部类的层次是一样的
    2. 可包含静态成员变量和方法
    3. 调用自身非静态方法时要先实例化对象，Outer.Inner inner = new Outer.Inner();
    4. 调用自身静态方法时可直接通过类名调用，Outer.Inner.show();

局部内部类：
    1. 定义在方法中
    2. 局部内部类不能直接访问，需要在局部类所在的方法中先实例化局部类对象，
       再在这个方法中调用局部类的方法和属性，使用外部类对象调用局部类所在的方法才可使用
    3. 方法中的局部变量和方法不能有修饰符，局部类也是如此，但局部类里面的方法和属性可用修饰符
    4. 访问被包含的方法的局部变量时必须是常量，访问时自动添加final，但一修改局部变量的值final就会默认去掉，程序报错

匿名内部类：
    1. 一个接口/类的方法的某个实现方式在程序中只会执行一次，使用子类去重写会产生大量的代码，使用匿名内部类可以直接实现，避免代码冗余
    2. 匿名内部类可以用在具体类、抽象类、接口上，且对方法个数没有要求
    3. 匿名内部类会隐式地继承一个父类或实现一个接口。

常用匿名内部类的情况：
    1. 只用到类的一个实例。
    2. 类在定义后马上用到。
    3. 类非常小，通常5行代码之内。
    4. 给类命名不会导致代码更容易被理解。
    5. 注意：匿名内部类不能定义构造方法，并且功能上会受到很大的限制，如果不是很有必要，尽量不要去使用。

测试代码：

package com.test.day.Day05;

public class Outer {

	private int id = 10;
	private String name = "刘德华";
	private int age = 18;
	public void out(){
		System.out.println("这是外部类的方法");
	}

	// 1. 成员内部类，可获得外部类的私有属性和方法
//	public class Inner{
//
//		private int id = 12;
//		public void in(){
//			System.out.println("这是内部类的方法");
//		}
//
		private static String country = "China"; // 会报错，成员内部类不允许使用Static修饰属性，除非是常量，用final修饰
//
//		// 内部类的属性和外部类相同时会优先访问内部类
//		// 使用 外部类名.this.属性名 可访问外部类
//		// 获取外部类的私有属性
//		public void getID(){
//			System.out.println();
//		}
//	}

	// 2. 静态内部类，和外部类的层次一样
//	public static class Inner{
//		private String address = "邢台";
//		private String phone = "110";
//
//		// 可包含静态成员
//		private static int count = 100;
//
//		public static void show(){
//			// 不能直接调用外部类的属性
//			// 先实例化一个外部对象
//			Outer outer = new Outer();
//			// 调用外部类的属性
//			System.out.println();
//		}
//	}
	// 3. 局部内部类：定义在方法中
	public void show(){
		// 局部变量不能加任何修饰符，
		String address = "深圳";
		// 局部内部类不能加任何修饰符
		class Inner{
			// 局部内部类里面的属性和方法可以加修饰符
			private String phone = "119";
			private String email = "111";

			public void show2(){
				//访问外部类的属性
				System.out.println();

				// 访问内部类的属性
				System.out.println(phone);

				// 访问局部变量,此时address为final修饰的常量
				System.out.println(address);
			}
		}

		// 实例化内部类对象
		Inner inner = new Inner();
		inner.show2();
	}
}

实现方法：

package com.test.day.Day05;

public class Application {
	public static void main(String[] args) {
		// 1. 成员内部类
//		Outer outer = new Outer();
		//内部类可通过外部类来实例化
//		Outer.Inner inner = outer.new Inner();
//		inner.getID();

		// 2. 静态内部类
		// 直接创建静态内部对象 Out.Inner表示包含关系
//		Outer.Inner inner = new Outer.Inner();
		// 调用方法
//		inner.show();
//		Outer.Inner.show();

		// 3. 局部内部类
		Outer outer = new Outer();
		outer.show();
	}

}

/*
1. 父类引用指向子类的对象
2. 把子类转换为父类，向上转型（可自动转换）
3. 把父类转换为子类，向下转型；强制转换
4. 方便方法的调用，减少重复的代码!

抽象： 封装、继承、多态
 */

/*
		// instanceof 是 Java 的保留关键字，它的作用是测试它左边的对象是否是它右边的类的实例，返回 boolean 的数据类型
		Object obj = new Student();

		// Object > String
		// Object > Person > Student
		// Object > Person > Teacher
		System.out.println(obj instanceof Student); // true
		System.out.println(obj instanceof Person);  // true
		System.out.println(obj instanceof Object);  // true
		System.out.println(obj instanceof Teacher); // false
		System.out.println(obj instanceof String);  // false
 */