关于final关键字和匿名内部类

一、final知识点

package oop;
//定义一个接口
interface MyInt{
    public final static String version="windows";//public final和static顺序可以调换，接口里面所有的定义都是默认public final static修饰,所以可以不写public final static
}
//final类不能被继承-》固定算法
public class Topclass {
    public final static String version="windows";//定义一个final static的变量，在运行时不能修改
    public final void show(){//定义一个final的方法则在子类不能重写

    }
    public static void main (String []args){
        //topclass.version="linux";//不能修改变量的值
        System.out.println(MyInt.version);
    }
}
class MySon extends Topclass{
    //final修饰的方法不能重写
    //public void show(){}

}

二、内部类的知识点
内部类
1、内部类分为成员内部类、静态嵌套类、方法内部类、匿名内部类。
几种内部类的共性：
A、内部类仍然是一个独立的类，在编译之后会内部类会被编译成独立的.class文件，但是前面冠以外部类的类命和$符号。
B、内部类不能用普通的方式访问。内部类是外部类的一个成员，因此内部类可以自由地访问外部类的成员变量，无论是否是private的。

2、成员内部类：形式如下

 class Outer {
        class Inner{}
    }    

编译上述代码会产生两个文件：Outer.class和Outer$Inner.class
成员内部类内不允许有任何静态声明！下面代码不能通过编译。

class Inner{
    static int a = 10;
} 

能够访问成员内部类的唯一途径就是通过外部类的对象！
A、从外部类的非静态方法中实例化内部类对象。

   class Outer {
        private int i = 10;
        public void makeInner(){
            Inner in = new Inner();
            in.seeOuter();
        }
        class Inner{
            public void seeOuter(){
                System.out.print(i);
            }
        }
    }

重点为匿名内部类，顾名思义，没有名字的内部类。表面上看起来它们似乎有名字，实际那不是它们的名字。
A、继承式的匿名内部类。

  class Car {
        public void drive(){
            System.out.println("Driving a car!");
        }
    }
    
    class Test{
        public static void main(String[] args) {
            Car car = new Car(){
                public void drive(){
                    System.out.println("Driving another car!");
                }
            };
            car.drive();
        }
    }

结果输出了：Driving another car! Car引用变量不是引用Car对象，而是Car匿名子类的对象。
建立匿名内部类的关键点是重写父类的一个或多个方法。再强调一下，是重写父类的方法，而不是创建新的方法。因为用父类的引用不可能调用父类本身没有的方法！创建新的方法是多余的。简言之，参考多态。

B、接口式的匿名内部类。

interface  Vehicle {
    public void drive();
}

class Test{
    public static void main(String[] args) {
        Vehicle v = new Vehicle(){
            public void drive(){
                System.out.println("Driving a car!");
            }
        };
        v.drive();
    }
}

上面的代码很怪，好像是在实例化一个接口。事实并非如此，接口式的匿名内部类是实现了一个接口的匿名类。而且只能实现一个接口。

C、参数式的匿名内部类（不懂）

class Bar{
    void doStuff(Foo f){}
}
interface Foo{
    void foo();
}
class Test{
    static void go(){
        Bar b = new Bar();
        b.doStuff(new Foo(){
            public void foo(){
                System.out.println("foofy");
            }
        });
    }
}

匿名内部类实例如下
(1)

package oop;
public class Car {
    public void show(){
        System.out.println("这是一个车");
    }
}

package oop;
public class Test1 {
    public static void main(String[] args) {
    Car c = new Car();
        c.show();
   Car bmw=new BMW();
   bmw.show();
   Car lbjn=new Car(){
       @Override
       public void show(){
           System.out.println("我是兰博基尼");
       }
   };
   Accelator a=new Cycle();
   a.accelate();//输出“单车加速了"
Accelator b=new Accelator(){
    @Override
    public void accelate(){
        System.out.println("加速器");
    }
};
b.accelate();
    }
}
class BMW extends Car{
    @Override
    public void show(){
        System.out.println("别摸我");
    }
}
interface Accelator{
   public void accelate();
}
class Cycle implements Accelator{
    @Override
    public void accelate(){
        System.out.println("单车加速");
    }
}

(2)时钟内部类实现

package oop5;
import  java.util.Date;


public class Test02 {
    public static void main(String[] args) {
        //写法一：外部类写法
        Thread t = new Thread(new TimeTask());
        t.start();
        //写法二：面向接口的匿名内部类
        Thread s = new Thread(new Runnable() {//匿名内部类
            @Override
            public void run() {
                while (true) {
                    try {
                        Thread.sleep(1000);
                        System.out.println(new Date());
                    } catch (Exception ex) {
                    }
                }
            }
        });
        s.start();
        //更精简
        new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    try {
                        Thread.sleep(1000);
                        System.out.println(new Date());
                    } catch (Exception ex) {
                    }
                }
            }
        }).start();//把上面一种方法放在一个整体
    //写法四：Java8支持的lambda写法
    new Thread(()->{
        while (true){
            try{
                Thread.sleep(1000);
                System.out.println(new Date());
            }catch (Exception ex){
        }
    }
    }).start();
}
class TimeTask implements  Runnable{//Runnable里面有public abstract void run();空方法
    @Override
    public void run(){
        while (true){
            try{
                Thread.sleep(1000);
                System.out.println(new Date());
            }catch (Exception ex) {
            }
        }
    }
}