抽象类注意事项：
　　抽象类不能被实例化，为什么还有构造函数？
　　只要是class定义的类里面肯定有构造函数。抽象类中的函数是给子类实例化的。
　　一个类没有抽象方法，为什么定义为抽象类?
　　不想被继承，还不想被实例化。
　　抽象关键字abstract不可以和哪些关键字共存？
　　final：如果方法被抽象，需要被覆盖，而final是不可以被覆盖，所以冲突。
　　private：如果函数被私有了，子类无法直接访问，怎么覆盖呢？
　　static：不需要对象，类名可以调用抽象方法。而调用抽象方法没有意义。
　　接口（interface）
　　接口是抽象方法和常量值的集合。从本质上讲，接口是一种特殊的抽象类，这种抽象类只包含常量和方法的定义，而没有变量和方法的实现。
　　格式：interface接口名{}
　　接口的出现将”多继承“通过另一种形式体现出来，即”多实现“。
　　实现（implements）
　　格式：class类名implements接口名{}
　　特点：
　　接口不能被实例化。
　　一个类如果实现了接口，要么是抽象类，要么实现接口中的所有方法。
　　接口的成员特点：
　　接口中的成员修饰符是固定的！
　　成员常量：public static final，接口里定义的变量是全局常量，而且修饰符只能是这三个关键字，都可以省略，常量名要大写。
　　成员方法：public abstract，接口里定义的方法都是抽象的，两个修饰符关键字可省略。
　　推荐：永远手动给出修饰符。
　　继承与实现的区别：
　　类与类之间称为继承关系：因为该类无论是抽象的还是非抽象的，它的内部都可以定义非抽象方法，这个方法可以直接被子类使用，子类继承即可。只能单继承，可以多层继承。（(class)）
　　类与接口之间是实现关系：因为接口中的方法都是抽象的，必须由子类实现才可以实例化。可以单实现，也可以多实现；还可以在继承一个类的同时实现多个接口。（(class)extends(class)implements(interface1，interface2…)）
　　接口与接口之间是继承关系：一个接口可以继承另一个接口，并添加新的属性和抽象方法，并且接口可以多继承。（(interface)extends(interface1，interface2…)）
　　抽象类和接口的区别：
　　成员变量
　　抽象类能有变量也可以有常量
　　接口只能有常量
　　成员方法
　　抽象类可以有非抽象的方法，也可以有抽象的方法
　　接口只能有抽象的方法
　　构造方法
　　-抽象类有构造方法
　　-接口没有构造方法
　　类与抽象类和接口的关系
　　类与抽象类的关系是继承extends
　　类与接口的关系是实现implements
　　接口的思想特点：
　　接口是对外暴露的规则；
　　接口是程序的功能扩展；
　　接口的出现降低耦合性；(实现了模块化开发，定义好规则，每个人实现自己的模块，大大提高了开发效率)
　　接口可以用来多实现；
　　多个无关的类可以实现同一个接口；
　　一个类可以实现多个相互直接没有关系的接口；
　　与继承关系类似，接口与实现类之间存在多态性。
　　//运动员和教练的案例（下图是思路分析）
　　/*
　　篮球运动员和教练
　　乒乓球运动员和教练
　　现在篮球运动员和教练要出国访问，需要学习英语
　　请根据你所学的知识，分析出来哪些是类，哪些是抽象类，哪些是接口
　　*/
　　interface SpeakEnglish{
　　public abstract void speak();
　　}
　　interface GoAboard{
　　public abstract void aboard();
　　}
　　abstract class Person{
　　private String name;
　　private int age;
　　public Person(){}
　　public Person(String name，int age){
　　this.name=name;
　　this.age=age;
　　}
　　public void setName(String name){
　　this.name=name;
　　}
　　public String getName(){
　　return name;
　　}
　　public void setAge(int age){
　　this.age=age;
　　}
　　public int getAge(){
　　return age;
　　}
　　//吃饭
　　public abstract void eat();
　　//睡觉
　　public void sleep(){
　　System.out.println("Zzz...");
　　}
　　}
　　//运动员
　　abstract class Player extends Person{
　　public abstract void study();
　　}
　　//教练
　　abstract class Coach extends Person{
　　public abstract void teach();
　　}
　　//篮球运动员
　　class BasketballPlayer extends Player implements SpeakEnglish，GoAboard{
　　public void eat(){
　　System.out.println(getAge()+"岁的"+getName()+"吃鸡腿");
　　}
　　public void study(){
　　System.out.println(getAge()+"岁的"+getName()+"学扣篮");
　　}
　　public void speak(){
　　System.out.println(getAge()+"岁的"+getName()+"Say Hello World");
　　}
　　public void aboard(){
　　System.out.println(getAge()+"岁的"+getName()+"Go Aboard");
　　}
　　}
　　//乒乓运动员
　　class PingPangPlayer extends Player{
　　public void eat(){
　　System.out.println(getAge()+"岁的"+getName()+"吃鸡蛋");
　　}
　　public void study(){
　　System.out.println(getAge()+"岁的"+getName()+"学扣球");
　　}
　　}
　　//篮球教练
　　class BasketballCoach extends Coach implements SpeakEnglish{
　　public void eat(){
　　System.out.println(getAge()+"岁的"+getName()+"啃鸡爪");
　　}
　　public void teach(){
　　System.out.println(getAge()+"岁的"+getName()+"教扣篮");
　　}
　　public void speak(){
　　System.out.println(getAge()+"岁的"+getName()+"Say Hello Java");
　　}
　　public void aboard(){
　　System.out.println(getAge()+"岁的"+getName()+"Go Aboard");
　　}
　　}
　　//乒乓球教练
　　class PingPangCoach extends Coach{
　　public void eat(){
　　System.out.println(getAge()+"岁的"+getName()+"吃鸡蛋皮");
　　}
　　public void teach(){
　　System.out.println(getAge()+"岁的"+getName()+"教扣球");
　　}
　　}
　　class PlayerAndCoach{
　　public static void main(String[]args){
　　//篮球运动员
　　BasketballPlayer bp=new BasketballPlayer();
　　bp.setName("郭艾伦");
　　bp.setAge(33);
　　bp.eat();
　　bp.sleep();
　　bp.study();
　　bp.speak();
　　bp.aboard();
　　System.out.println("***********************");
　　//篮球教练
　　BasketballCoach bc=new BasketballCoach();
　　bc.setName("波波维奇");
　　bc.setAge(65);
　　bc.eat();
　　bc.sleep();
　　bc.teach();
　　bc.speak();
　　bc.aboard();
　　System.out.println("***********************");
　　//多态
　　Person p=new BasketballPlayer();
　　p.setName("Kobe Bryant");
　　p.setAge(33);
　　p.eat();
　　p.sleep();
　　//p.study();
　　//p.speak();
　　BasketballPlayer bp2=(BasketballPlayer)p;
　　bp2.study();
　　bp2.speak();
　　bp2.aboard();
　　System.out.println("***********************");
　　}
　　}
　　内部类
　　将一个类定义在另一个类里面，里面的那个类称为内部类。内部类的出现，再次打破了Java单继承的局限性。
　　访问特点：
　　内部类可以直接访问外部类的成员，包括私有成员。
　　外部类要访问内部类的成员，必须要建立内部类的对象。
　　内部类分类及共性：
　　共性：
　　内部类仍然是一个独立的类，在编译之后会内部类会被编译成独立的.class文件，但是前面冠以外部类的类名和$符号。
　　内部类不能用普通的方式访问。内部类是外部类的一个成员，因此内部类可以自由地访问外部类的成员变量，无论是否是private的。
　　成员内部类
　　在外部类中有成员变量和成员方法，成员内部类是把整个一个类作为了外部类的成员；
　　成员内部类是定义在类中方法外的类；
　　创建对象的格式为：外部类名.内部类名对象名=外部类对象.内部类对象；
　　成员内部类之所以可以直接访问外部类的成员，那是因为内部类中都持有一个外部类对象的引用：外部类名.this；
　　成员内部类可以用的修饰符有final，abstract，public，private，protected，static.
　　静态内部类
　　静态内部类是成员内部类加上静态修饰符static，定义在类中方法外。
　　在外部类中访问静态内部类有两种场景：
　　在外部类中访问静态内部类中非静态成员：*外部类名.内部类名对象名=外部类名.内部对象*，需要通过创建对象访问；
　　在外部类中访问静态内部类中的静态成员：同样可以使用上面的格式进行访问，也可以直接使用外部类名.内部类名.成员。
　　局部内部类
　　局部内部类是定义在方法中的类。
　　方法内部类只能在定义该内部类的方法内实例化，不可以在此方法外对其实例化。
　　方法内部类对象不能使用该内部类所在方法的非final局部变量。
　　可以用于方法内部类的修饰符有final，abstract；
　　静态方法中的方法内部类只能访问外部的静态成员。
　　匿名内部类
　　匿名内部类是内部类的简化写法，是建立一个带内容的外部类或者接口的子类匿名对象。
　　前提：
　　内部类可以继承或实现一个外部类或者接口。
　　格式：
　　new外部类名或者接口名(){重写方法};
　　通常在方法的形式参数是接口或者抽象类，并且该接口中的方法不超过三个时，可以将匿名内部类作为参数传递。
　　不同修饰符修饰的内容(和内部类无关)

　　注意，常见规则如下：
　　以后，所有的类都用public修饰。并且，在一个java文件中，只写一个类。
　　以后，所有的成员变量用private修饰。
　　以后，所有的成员方法用public修饰。
　　如果是抽象类或者接口：public abstract+…
　　以后，所有的构造方法用public修饰。
　　如果类是工具类或者单例类：构造用private修饰
　　四种权限修饰符
 


　　成员变量private
　　构造方法public
　　成员方法public