JAVASE学习笔记-13(权限修饰符,final,代码块,内部类)

权限修饰符:

public 

protected 

default(如果不填就是这个默认,但是不可以写default)

private

在同一个类中,四种权限修饰符的都能访问

permission.MyClass.java

public class MyClass {
    public String name;
    protected int age;
    private String sex;
    int id;

    public void method(){
        System.out.println(name);
        System.out.println(age);
        System.out.println(sex);
        System.out.println(id);
    }
}

在同一个包中,但是不同的类,private私有不能访问

permission.Test1.java

public class Test1 {
    public static void main(String[] args) {
        MyClass s = new MyClass();
        System.out.println(s.name);
        System.out.println(s.age);
//        System.out.println(s.sex);//报错,无法访问私有的
        System.out.println(s.id);
    }
}

不在同一个包中,但是是继承关系,default默认和private私有不能访问

permission2.Test1.java

public class Test1 extends MyClass{
    public static void main(String[] args) {
        MyClass s = new MyClass();
        System.out.println(s.name);
        System.out.println(s.age);
//        System.out.println(s.sex);//报错,无法访问私有的
//        System.out.println(s.id);//报错,无法访问默认
    }
}

不在同一个包,并且也不是继承关系,只有public可以访问

permission2.Test2.java

public class Test1  {
    public static void main(String[] args) {
        MyClass s = new MyClass();
        System.out.println(s.name);
//        System.out.println(s.age);//报错,无法访问受保护的
//        System.out.println(s.sex);//报错,无法访问私有的
//        System.out.println(s.id);//报错,无法访问默认
    }
}

图示:

	public	protected	default	private
同包	yes	yes	yes	yes
同包不同类	yes	yes	yes	no
不同包子父类	yes	yes	no	no
不用包非子父类	yes	no	no	no

final关键字:

被final修饰后,当前类不能再被更改,也不能被其他类继承,被修饰的对象地制值不能改变,但是对象里的属性值可以改变

public class final1 {
    public static void main(String[] args) {}
    public final String NAME = "dzy";

    public final void eat(){
        System.out.println(NAME);
        // NAME = "dzy2";//报错,被final修饰的变量无法二次赋值
    }
    // public class Dog extends eat{}//报错,被final修饰了无法被继承
    
}

代码块:

构造代码块:

person.java

public class person {
    {
        System.out.println("构造代码块执行");
    }
    public person(){
        System.out.println("无参构造器执行");
    }
}

public class Test {
    public static void main(String[] args) {
        person p = new person();
        person p1 = new person();
    }
}

每次new一个对象,构造代码块就会执行一次,并且比构造方法先执行.

静态代码块:

在person.java里面添加

    static {
        System.out.println("静态代码块执行");
    }

new对象后会执行静态代码块,并且只执行一次,并且最优先执行

内部类:

静态成员内部类:

public class Person {
    public void eat(){
        System.out.println("吃饭");
    }
    //静态成员内部类
    static class Heart{
        public void jump(){
            System.out.println("心再跳");
        }
    }
}

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

        Person.Heart heart = new Person.Heart();
        heart.jump();//访问静态内部类
    }
}

成员内部类:

public class Person {
    public void eat(){
        System.out.println("吃饭");
    }
    //静态成员内部类
    class Heart{
        public void jump(){
            System.out.println("心再跳");
        }
    }
}

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

        Person.Heart heart = new Person().new Heart();
        heart.jump();//访问静态内部类
    }
}

局部内部类:

public class Person {
    public void eat(){
        class Heart{
            public void jump(){
            System.out.println("心再跳");
        }
        }
        new Heart().jump();
    }
}

public class Test1 {
    public static void main(String[] args) {
        Person person = new Person();
        person.eat();
    }
}

匿名内部类:

没有显式声明出类名的内部类

new 接口/抽象类(){

        重写方法

}.重写的方法();