final、内部类、抽象类、接口

final可以修饰类、方法、属性
修饰类，不能被继承

class FinalDemo
{
    public static void main(String args[]){

    }
}

final class Animal
{
    public void run(){
        System.out.println("run...");
    }
}

class Dog extends Animal
{

}

===============================
结果：
D:\java2>javac FinalDemo.java
FinalDemo.java:15: 无法从最终 Animal 进行继承
class Dog extends Animal
                  ^
1 错误

修饰方法，不能被覆盖

class FinalDemo
{
    public static void main(String args[]){

    }
}

class Animal
{
    public final void run(){
        System.out.println("run...");
    }
}

class Dog extends Animal
{
    public void run(){
        System.out.println("Dog run...");
    }

}

===============================
结果：
D:\java2>javac FinalDemo.java
FinalDemo.java:17: Dog 中的 run() 无法覆盖 Animal 中的 run()；被覆盖的方法为 final
        public void run(){
                    ^
1 错误

修饰属性，不能被修改，只能赋值一次，常量

class FinalDemo
{
    public static void main(String args[]){
        Dog a=new Dog();
        a.color="black";
    }
}

class Animal
{  
    final String color="white";
    public  void run(){
        System.out.println("run...");
    }
}

class Dog extends Animal
{

    public void run(){
        System.out.println("Dog run...");
    }


}

===========================================
结果：
D:\java2>javac FinalDemo.java
FinalDemo.java:5: 无法为最终变量 color 指定值
                a.color="black";
                 ^
1 错误

==========================

内部类：定义在类内部的类
1、内部类可以在类的成员位置上
–编译时产生的类，外部类$内部类名，例如：Benz$Engine.class

class InnerClassDemo
{
    public static void main(String args[]){
        new Benz().run();
    }
}

class Benz
{
    public void run(){
        Engine e=new Engine();
        e.fire();
        System.out.println("run...");
    }

    class Engine
    {
        public void fire(){
            System.out.println("fire...");
        }
    }
}

结果：
D:\java2>javac InnerClassDemo.java
Benz$Engine.class
 Benz.class
 InnerClassDemo.class
 InnerClassDemo.java
D:\java2>java InnerClassDemo
fire...
run...

2、内部类还可以在方法内定义,例如：Benz$nEngine.class

class InnerClassDemo
{
    public static void main(String args[]){
        new Benz().run();
    }
}

class Benz
{
    public void run(){
        class Engine
        {
            public void fire(){
                System.out.println("fire...");
            }
        }
        Engine e=new Engine();
        e.fire();
    }
}
结果：
D:\java2>javac InnerClassDemo.java
Benz$1Engine.class
 Benz.class
 InnerClassDemo.class
 InnerClassDemo.java
D:\java2>java InnerClassDemo
fire...

3、内部类访问局部变量时，不能对局部变量重新赋值。Java8不要求必须给局部变量使用final修饰。

class InnerClassDemo
{
    public static void main(String args[]){
        new Benz().run();
    }
}

class Benz
{
    public void run(){
        String key="key888";
        class Engine
        {
            public void fire(){
                System.out.println(key);
                System.out.println("fire...");
            }
        }
        Engine e=new Engine();
        e.fire();
    }   
}
结果：
D:\java2>javac InnerClassDemo.java
InnerClassDemo.java:15: 从内部类中访问局部变量 key；需要被声明为最终类型

=============================

抽象类：
1、抽象方法:目的是为了让子类去实现。
没有函数体的方法，必须使用 abstract修饰。
修饰符 abstract 返回值(参数列表…);
2、抽象方法必须在抽象类当中。

class AbstractDemo
{
    public static void main(String args[]){

    }
}

class MyAbstract
{
    public abstract void show();
}

==========================
结果：
D:\java2>javac AbstractDemo.java
AbstractDemo.java:8: MyAbstract 不是抽象的，并且未覆盖 MyAbstract 中的抽象方法 show()
class MyAbstract
^
1 错误

3、抽象类包含抽象方法，不能实例化，因为抽象类是张不全的图纸。

class AbstractDemo
{
    public static void main(String args[]){
        new MyAbstract();
    }
}

abstract class MyAbstract
{
    public abstract void show();
}

==========================
结果：
D:\java2>dir
AbstractDemo.java
D:\java2>javac AbstractDemo.java
AbstractDemo.java:4: MyAbstract 是抽象的；无法对其进行实例化
                new MyAbstract();
                ^
1 错误

4、抽象类有构造函数。

class AbstractDemo
{
    public static void main(String args[]){

    }
}

abstract class MyAbstract
{
    public abstract void show();
}

========================
结果：
D:\java2>javac AbstractDemo.java
D:\java2>dir
 AbstractDemo.class
 AbstractDemo.java
 MyAbstract.class

D:\java2>javap MyAbstract
Compiled from "AbstractDemo.java"
abstract class MyAbstract extends java.lang.Object{
    MyAbstract();
    public abstract void show();
}

非法修饰符组合：
private+abstract
final+abstract
private+final //多此一举

==========================

接口：最低标准
1、 接口中的所有方法都是抽象的

class InterfaceDemo
{   
}
interface White
{
    public  void white();
}

结果：
D:\java2>javac InterfaceDemo.java
D:\java2>dir
 InterfaceDemo.class
 InterfaceDemo.java
 White.class

D:\java2>javap White
Compiled from "InterfaceDemo.java"
interface White{
    public abstract void white();
}

2、 面向接口编程降低耦合度，耦合度即是交互程度。
3、 接口可以用来多实现。
4、 扩展性更强了，类只能单继承，而有了接口，类可以实现多个接口，这也是抽象类和接口之间的一个区别，有了接口，功能更加丰富、强大。

class InterfaceDemo
{
    public static void main(String args[]){
        J8 a=new J8();
        a.cry();


        Eater b=new Eater();
        b.eat(a);

        RichMan c=new RichMan();
        c.feed(a);
    }

}

abstract class Animal
{
    public abstract void cry();
}

class Dog extends Animal
{
    public void cry(){
        System.out.println("Dog汪汪叫");
    }
}

class J8 extends Dog implements Eateable,Pet
{
    public void cry(){
        System.out.println("J8汪汪叫");
    }

    public void eat(){
        System.out.println("吃吃吃J8");
    }

    public void meng(){
        System.out.println("J8蒙蒙哒！");
    }
}

interface Pet
{
    public void meng();
}

interface Eateable
{
    public void eat();
}

class Eater 
{
    public void eat(Eateable e){
        System.out.println("吃货准备开始吃吃吃");
        e.eat();
    }
}

class RichMan
{
    public void feed(Pet p){
        System.out.println("富人准备开始养宠物！");
        p.meng();
    }
}

结果：
D:\java2>javac InterfaceDemo.java
D:\java2>java InterfaceDemo
J8汪汪叫
吃货准备开始吃吃吃
吃吃吃J8
富人准备开始养宠物！
J8蒙蒙哒！

5、 接口可以继承多个接口。
6、 接口可以多重继承

class InterfaceDemo
{
    public static void main(String args[]){
        WomenStar w=new WomenStar();
        TuHao t=new TuHao();
        t.marry(w);
    }
}

interface White
{
    public void white();
}

interface Rich
{
    public void rich();
}

interface Beauty
{
    public void beauty();
}


interface WEB extends White,Rich,Beauty
{

}
class WomenStar implements WEB
{
    public void white(){
        System.out.println("很白");
    }

    public void rich(){
        System.out.println("有钱");
    }

    public void beauty(){
        System.out.println("漂亮");
    }
}

class TuHao
{
    public void marry(WEB wrb){
        wrb.white();
        wrb.rich();
        wrb.beauty();
    }
}

============================
结果：
D:\java2>javac InterfaceDemo.java
D:\java2>java InterfaceDemo
很白
有钱
漂亮