JAVA Class9

Posted Observer

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了JAVA Class9相关的知识,希望对你有一定的参考价值。

学习内容:

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
    }

}

 

以上是关于JAVA Class9的主要内容,如果未能解决你的问题,请参考以下文章

java 代码片段【JAVA】

# Java 常用代码片段

# Java 常用代码片段

创建片段而不从 java 代码实例化它

如何重构这个 Java 代码片段

java 反射代码片段