JAVA Class9

Posted 2020-10-29 Observer

学习内容：

1.final修饰词

（1）修饰类：

类无法被继承，但可以继承其他类

（2）修饰方法：

方法无法被子类重写

（3）修饰局部变量：

该变量只能被赋值一次

（4）修饰成员变量：

该变量必须在对象创建之前初始化，可以通过直接赋值、构造代码块或者利用构造器初始化

（5）修饰引用变量

该变量只有一次指向对象的机会，例：

final Hero h;

h = new Hero();

h = new Hero();//报错

public final class F {//不可被继承，但可以继承其他类
    //final int b = 0 ;创建时必须初始化
    final int b;
    F(int b){//创建对象前必须初始化且只能被赋值一次
        this. b =b;
    }
    public final void test1() {
        System.out.println("测试");
    }
    
    public static void main(String[] args) {
        final F f;//只可引用一次
        final int a;//只能赋一次值
        a = 5;
        f = new F(4);
        //f.b = 6;报错，只能赋值一次
        //f = new F();报错
        //a = 10;报错
    }
}

2.static修饰词

被static修饰的方法与成员变量被称为静态方法、静态变量或者类方法、类属性

（1）类方法可被类、实例化对象调用，类方法只能访问类属性。

（2）类属性属于“共享”属性，需要在声明时被初始化，所有实例化对象共享一个值，一改全改，一般被用作常量，加final，使其只能被赋值一次，

类属性同样可由类、实例化对象访问，推荐使用类访问。

public class F {
    int w;
    int t = 10;
    static int s = 10; //类属性，共享值，必须被立即初始化
    static{ //静态初始化块
           s = 10;
    }
    public static void test() {
        //w = 2;//报错，静态方法只能访问静态值，但是非静态方法可以访问静态属性
    }
    public static void main(String[] args) {
        F h = new F();
        h.s = 20;//一改全改
        System.out.println(f.s);//20
        System.out.println(h.s);//20
        System.out.println(F.s);//类访问类属性，推荐
        //静态属性、方法进入如静态区，先于非静态属性、方法创建，
　　　//非静态方法、属性随着实例化对象的产生而产生，故而静态方法无法访问非静态属性。
    }
}
        

 3.内部类

 （1）成员内部类：

public class Test{
    int i = 8;
    class bt{
        int i = 7;
        public void t() {
            System.out.println(Hero.this.i);
        }
    }
    public static void main(String[] args) {
        h.new bt().t();/成员内部类必须在有一个外部类对象时才能存在，可访问外部类属性、方法
    }

}

（2）局部内部类

public class Test{
    public void inner() {
        class inner{
            public void te() {
                System.out.println("局部内部类");
            }
        }
        inner i = new inner();
        i.te();//方法内访问局部内部类
    }
}

（3）静态内部类

public class Test{
    int i = 8;
    static class win{
        int i = 8;
        public void t() {
            //System.out.println(Hero.this.i);//无法访问外部类属性、方法
        }
        public void tt() {
            System.out.println("静态内部类");
        }
    }
    public static void main(String[] args) {
        new win().tt();//静态内部类不需要一个外部类的实例为基础
    }

}

（4）匿名类

继承接口重写抽象方法：

public interface Test {
    public void test();
}

public class Test2{
    public static void main(String[] args) {
        new Test() {//匿名类，实例化同时当场重写方法
            public void test() {
                System.out.println("匿名类测试");
            }
        }.test();
        Test ta = new Test() {
            public void test() {
                System.out.println("引用匿名类");
            }
        };
        ta.test();
    }

}

继承一般类重写对象方法

 

public class T {
    public void test() {
        System.out.println("测试");
    }
}

public class TC {
    public static void main(String[] args) {
        T t = new T() {
            public void test() {
                System.out.println("匿名类");
            }
        };
        System.out.println(t);
    }
}

 

运行结果：，JVM分配一个TC$1的“虚拟”类名。

 

4.访问修饰符

5.代码块

（1）静态代码块，最高执行优先级，先于main方法执行，一般用于初始化类属性，只执行一次。

（2）构造代码块，先于构造方法执行，一般用于初始化对象属性，每实例化一个对象就执行一次。

（3）局部代码块，大括号分隔作用域。

public class Test{
    static{//静态代码块优于主方法、构造代码块执行，一般用于初始化类属性
        System.out.println("静态代码块");
    }
    public Hero(){
        System.out.println("构造方法");
    }
    {
        System.out.println("构造代码块");
    }
    
    public static void main(String[] args) {
        Test t = new Test();//构造代码块先于构造方法执行
        //局部代码块 大括号分隔作用域
        {
            int x = 9;
            System.out.println(x);//输出9
        }
        int x = 3;
        System.out.println(x);//输出3
    }

}