3.java面向对象语法学习（部分2-抽象类，接口，内部类）

java类与对象之 抽象类，接口，内部类

1. 抽象方法：
在类中没有方法体的方法，就是抽象法

---

2.抽象类：
含有抽象方法的类叫抽象类，不能被实例化

自认为作用是：
（1）对于某些抽象概念不需要具体实现其功能
例如，（抽象类）动物都（抽象方法）吃，但是吃的东西不一样，无法统一，此时用抽象方法比较好

（2）方便管理，将考虑不到的功能提前做有个类似于模板的东西（没方法体）使用时按需添加

抽象类中的抽象方法必须被实现（必须被继承，在子类中实现（重写） ），普通方法同普通类
注意：如果子类没有实现父类中的抽象方法，则子类也称为一个抽象类

抽象类不能被声明为final类型的，因为加final关键字的类保证不能被继承，
因此为抽象类加final关键字，这个类就没法用了。

抽象类只能被继承，不能被实例化！

---

3.interface 接口:
接口算是抽象类的极限吧，，接口中的方法全是抽象方法，
通过implements来实现某个接口，需要重写其所有方法（抽象类可以不实现接口方法）
接口很好地解决了Java的单继承问题
使用接口的好处：
(1)、接口可以实现向上转型，多个具有共同属性的类可以将它们的共同点提取出来，做成抽象，这样层次分明，统一管理。
//向上转型（同类的子继父业，子类对象等于父类对象，父类对象不等于子类对象）
(2)、接口不具有任何实现，最适合做基类。

---

总结一下抽象类与接口的区别和联系：,
a) 抽象类是类，可以有实体方法。
b) 抽象类不能实现多继承，而接口可以。
c) 如果需要创建不带任何方法定义和成员变量的基类，则使用接口，如果类中需要有部分具体的实现，则使用抽象类。
d) 如果事先想要将某类设计为一个基类，那么首选接口。（注意c和d是接口的使用场景）
接口可以通过继承(extends)接口，来拓展功能。接口中的域默认是final、static的，我们可以通过类名来直接引用。

---

4.内部类的使用：（可以是指为private）

和普通类差不多每个内部类都能独立继承自一个接口的实现，和外部类没有任何关系（不论外部类是否实现了该接口）。
内部类使用外部类对象，.new 来创建：

        public class ABC {  
            void a() {  
            System.out.println("this is A.a()!");  
            }  

            class B {  
            void b() {  
                System.out.println("this is B.b()!");  
            }  

            class C {  
                void c() {  
                a();  
                b();  
                System.out.println("this is C.c()!");  
                }  
            }  
            }  

            public static void main(String[] args) {  
            ABC abc = new ABC();  
            ABC.B b = abc.new B();  
            ABC.B.C c = b.new C();  
            c.c();  
            }  
        }  

---

5.匿名内部类：
没有名字的内部类，由于没有名字，所以匿名内部类只能使用一次，通常用来简化代码编写
使用前提条件：必须继承一个父类或实现一个接口

  例子：
    abstract class Person {
        public abstract void eat();
    }

    public class Demo {
        public static void main(String[] args) {
        Person p = new Person() {
            public void eat() {
            System.out.println("eat something");
            }
        };
        p.eat();
        }
    }

注意事项：
a)匿名内部类不能有构造方法
b)匿名内部类不能定义任何静态成员、方法和类。
c)匿名内部类不能是public,protected,private,static。
d)只能创建匿名内部类的一个实例。
e)一个匿名内部类一定是在new的后面，用其隐含实现一个接口或实现一个类。
f)因匿名内部类为局部内部类，所以局部内部类的所有限制都对其生效。

---

实测代码：

    /*
     * 内部类的测试
     */

    //interface Interface_Class {  
    //    void say();  
    //    class IC implements Interface_Class{  
    //        public void say() {  
    //            System.out.println("hello");  
    //        }  
    //        public static void main(String[] args) {  
    //            new IC().say();  
    //        }  
    //    }  
    //}  

    public class StudyObject2 {
        public StudyObject2() {
            System.out.println("外层类的构造方法");
        }

        class inClass{
            public inClass(){
                System.out.println("内部类的构造方法");
            }
        }

    //  public void eat() {
    //      // TODO Auto-generated method stub
    //      
    //  }
    //
    //  public void call() {
    //      // TODO Auto-generated method stub
    //      
    //  }

    }

    class test{
        public static void main(String[] args) {
            StudyObject2 studyObject2 = new StudyObject2();
            StudyObject2.inClass class1 = studyObject2.new inClass();
        }
    }








    /*
     * 接口解决多重继承问题
     */
    //interface animal{
    //  public void eat();
    //  public void call();
    //  public int i = 1;
    //}
    //
    //interface human{
    //  public void eat(int i);
    //  public void thinking();
    //}
    //class animalClass{
    //  public void eat(){
    //      System.out.println("eat");
    //  }
    //  public void call(){
    //      System.out.println("call");
    //  }
    //}
    //
    //public class StudyObject2 implements animal,human{
    //
    //  public void thinking() {
    //      // TODO Auto-generated method stub
    //      
    //  }
    //  
    //
    //  public void eat() {
    //      // TODO Auto-generated method stub
    //      
    //  }
    //
    //  public void call() {
    //      // TODO Auto-generated method stub
    //      
    //  }
    //
    //  public void eat(int i) {
    //      // TODO Auto-generated method stub
    //      
    //  }


    //  public void eat() {
    //      
    //  }
    //
    //  public void call() {
    //      // TODO Auto-generated method stub
    //      
    //  }

    //}


    /*
     * final 和 abstract 只能用一个
     */
    //final abstract class abstractClass{
    //  
    //}