面试官:总结一下接口与抽象类的区别，聊聊关于类的名词

抽象类与接口有哪些异同？

我朝着比较重要的几点总结，简单的我就不说了，说下回答哪些点才能加分

JDK7及以前：接口只能定义全局常量和抽象方法

全局常量：public static final的.但是书写时，可以省略不写。

抽象方法：public abstract的，书写时，可以省略不写。

JDK8：除了定义全局常量和抽象方法之外，还可以定义静态方法、默认方法

接口中不能定义构造器的！意味着接口不可以实例化

接口与接口之间可以继承，而且可以多继承

来个代码加深一下理解

interface Flyable{
	
	//全局常量
	public static final int MAX_SPEED = 7900;//第一宇宙速度
	int MIN_SPEED = 1;//省略了public static final
	
	//抽象方法
	public abstract void fly();
	//省略了public abstract
	void stop();
	//下面这种写法是错误的接口中不允许有构造器
//	public Flyable(){
//		
//	}
//静态方法 
	public static void method1(){
		System.out.println("method1");
	}
	//默认方法
	public default void method2(){
		System.out.println("method1");
	}
	default void method3(){
		System.out.println("method3");
	}
# 需要注意的是不要将default和权限修饰符弄混了
}

abstract修饰的抽象类中一定有构造器，便于子类实例化时调用（通过super），记一道题自己做错了，心想抽象类又不能实例化，不能有构造器，其实是可以有的。

abstract修饰方法，就是抽象方法，包含抽象方法的类，一定是一个抽象类。反之，抽象类中可以没有抽象方法的。

abstract使用上的注意点：

1.abstract不能用来修饰：属性、构造器等结构

2.abstract不能用来修饰私有方法、静态方法、final的方法、final的类

再来聊聊什么是匿名对象、内部类、匿名内部类。

# 当我们new一个对象为给对象取名时，像下边这样就称匿名对象
new Student()
# 反之非匿名对象
Student student = new Student()

内部类

1. Java中允许将一个类A声明在另一个类B中，则类A就是内部类，类B称为外部类
2. 内部类的分类：成员内部类（静态、非静态）和 局部内部类(方法内、代码块内、构造器内)
3. 成员内部类：一方面，作为外部类的成员，他可以调用外部类的结构，可以被static修饰，可以被4种不同的权限修饰。另一方面，作为一个类：类内可以定义属性、方法、构造器等，可以被final修饰，表示此类不能被继承。言外之意，不使用final，就可以被继承，可以被abstract修饰。
4. 关于内部类主要关注如下的3个问题。如何实例化成员内部类的对象？如何在成员内部类中区分调用外部类的结构？开发中局部内部类的使用？关于这三个问题下面这个代码可以给你答案。

class Person{
	
	String name = "小明";
	int age;
	
	public  void eat(){
		System.out.println("人：吃饭");
	}
	
	
	//静态成员内部类
	static class Dog{
		String name;
		int age;
		
		public void show(){
			System.out.println("卡拉是条狗");
			# 此方法是外部类的非静态方法，内部类不可以直接调用
//			eat();
		}
		
	}
	//非静态成员内部类
	class Bird{
		String name = "杜鹃";
		
		public Bird(){
			
		}
		
		public void sing(){
			System.out.println("我是一只小小鸟");
			Person.this.eat();//调用外部类的非静态属性
			eat(); //调用外部类的非静态属性 也可以
			System.out.println(age);
		}
		
		public void display(String name){
			System.out.println(name);//方法的形参
			System.out.println(this.name);//内部类的属性
			System.out.println(Person.this.name);//外部类的属性
		}
	}
	
	
	public void method(){
		//局部内部类
		class AA{
			
		}
	}
	
	{
		//局部内部类
		class BB{
			
		}
	}
	
	public Person(){
		//局部内部类
		class CC{
			
		}
	}
	
	
	
}
 public class InnerClassTest {
	public static void main(String[] args) {
		
		//创建Dog实例(静态的成员内部类):
		Person.Dog dog = new Person.Dog();
		dog.show();
		//创建Bird实例(非静态的成员内部类):
//		Person.Bird bird = new Person.Bird();//错误的
		Person p = new Person();
		Person.Bird bird = p.new Bird();
		bird.sing();
		
		System.out.println();
		
		bird.display("黄鹂");
		
	}
}
输出结果：

卡拉是条狗
我是一只小小鸟
人：吃饭
人：吃饭
0

黄鹂
杜鹃
小明

匿名内部类

匿名内部类本质是一种简化的写法。他的本质是一个带具体实现的父类或者父接口的匿名的子类对象，开发中用的比较多，这个很重要。

以接口举例，当使用一个接口时的做一下操作。

1. 定义子类
2. 重写接口中的方法
3. 创建子类对象
4. 调用重写后的方法

匿名内部类就是将这四步合成一步了，但是匿名内部类必须继承一个父类或者实现一个父接口。

举个栗子

abstract class Person{
    public abstract void breath();
    
    public abstract void eat();
}

class Worker extends Person{

	@Override
	public void eat() {
	}

	@Override
	public void breath() {
	}
	
}
# 假设Worker类是重写Person类的所有抽象方法
# Worker worker = new Worker(); # //非匿名的类非匿名的对象 解释 非匿名类在于Worker重新实现了Person类给
# Person取了个名字叫Worker，因为Person对象是一个抽象类是不可以实例化的。

//创建了一匿名子类的对象：p 
Person p = new Person(){

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

	@Override
	public void breath() {
		System.out.println("好好呼吸");
	}
};

# 解释一下 Person是抽象类不可以实例化，需要来个子类继承他，来实现他所有的抽象方法，并对子类又重新取
# 了一个名字。上面这样写new 一个抽象类显然是抽象类所不允许的，但是这样写比较方便，可以这样理解，
# java底层默认给Person实现了一个类，但这个类是没有名字的，这个类还是Person的子类，但有方法体，方法体是重写父类的方法。所以上面创建的这个类没有名字，但new的这个对象有名字就是P

今天就到这里，希望看了的小伙伴们能点点关注+收藏+转发，后边我希望自己再接再厉，坚持写下去！！！