类的高级概念

 

1、访问修饰符

权限：
包外 子类 包内 类内 public yes yes yes yes protected no yes yes yes default no no yes yes private no no no yes
注意：同一包中，default子类可以被访问。

2、static使用

a、修饰属性

例如：static int age;

使用static修饰的属性变量不是一个类私有，属全体类共有，仅仅将static写在类中；值不随类的初始化而初始化。

b、修饰方法

例如：public static void print();

使用static修饰的方法为全体类共有；调用时，非静态方法能调用静态方法；静态方法只能调用静态方法。

c、静态块

块分为静态初始化块及初始化块： 初始化块：在类中单独的“{}”表示的代码 静态初始化块：在初始化块前加static关键字：“static{}”
使用：在对象被初始化时优先加载一些资源。
静态块优先执行，且只加载一次。 初始化块随类实例化优先于构造函数执行。
即：静态块（只执行一次）>初始化块>构造函数

例如

 

public class Demo16 {
    public static void main(String[] args) {
        Student1 student=new Student1();
        Student1 student1=new Student1();
        student.setAge(12);
        System.out.println(student.getAge());
    }
}
class Student1{
    private int age;
    private String name;
    static {
        System.out.println("静态块执行");
    }
    {
        System.out.println("初始化块执行");
    }
    public void setAge(int age){
        if(age>=0&&age<200){
            this.age=age;
        }else{
            System.out.println("输入不正确");
        }
    }
    public int getAge(){
        return age;
    }
    public void setName(String name){
        this.name=name;
    }
    public String getName(){
        return name;
    }
} 

3、内部类

静态内部类

在类的内部，使用static修饰的类称为静态内部类。
静态内部类可以访问内部类的属性及方法，前提条件是外部类的属性和方法为static修饰

 

class Outer{
    int age;
    static String name;
    public void fun(){
        System.out.println(age);
}
    static class Inner{
        public void show(){//           System.out.println(age);//不能访问Outer类中的非static修饰的属性age
            System.out.println(name);//可以访问
        }
    }
} 

成员内部类

在类的内部创建一个类，叫成员内部类。
成员内部类的可以调用外部类的所有成员（属性和方法），但只有在创建了外部类的对象后，才能调用外部类。
声明方法如下：

Outer outer=new Outer(); //外部类先实例化
Inner inner=outer.new Inner();//使用外部内.new 内部类名

 

import johney.practice.Outer.Inner;     //需要引入Outer包后才能初始化
public class Demo16 {
    public static void main(String[] args) {
        Outer outer=new Outer();
        Inner inner=outer.new Inner();//使用外部内.new 内部类名
    }
}
class Outer{
    int age;
    static String name;
    public void fun(){
        System.out.println(age);
    }
    class Inner{
        public void show(){
            System.out.println(age);
            System.out.println(name);
        }
    }
} 

局部内部类

在类的方法内部定义的类。局部内部类只能在方法内部中使用，一旦方法执行完毕，局部内部类就会从内存中被清楚。

 

public class Demo16 {
    public static void main(String[] args) {
        Outer outer=new Outer();
        outer.fun();
    }
}
class Outer{
    int b=16;
    public void fun(){
        int a=10;
        class Inner{
            public void show(){
                System.out.println(a);//局部内部类可以访问外部类所有成员（属性和方法）
                System.out.println(b);
                fun();//如果调用，程序死循环
            }
        }
        Inner inner=new Inner();//只能在方法内部实例
        inner.show();
    }
}