内部类、static关键字、final关键字

内部类、static关键字、final关键字

一、内部类

什么是内部类

将类写在其他类的内部，可以写在其他的成员位置和其他类的局部位置，这时写在其他类内部的类就称为内部类。

什么时候使用内部类

在描述事物，若一个事物内部还包含其他可能包含的事物，比如在描述汽车时，汽车中还包含这发动机这个事物，这时发动机就可以使用内部类来描述。即就是内部事物必须寄宿在外部事物内部。

内部类代码体现

class Outer{ 		//外部类的成员变量 
	int num = 5; 		//写在Outer成员位置上的内部类 
	class Inner{ 		//内部类的成员函数
		void show(){	 //在内部类中访问外部类的成员变量 
		System.out.println("Outer num = "+num); 
		}
	} 
}

广泛意义上的内部类一般来说包括这四种：成员内部类、局部内部类、匿名内部类和静态内部类。

1、成员内部类

在类的内部方法的外部编写的类就是成员内部类。

成员内部类特点

1. 成员内部类可以无条件访问外部类的所有成员属性和成员方法（包括private成员和静态成员）。
2. 同名属性名方法名时访问外部类 外部类.this.成员名。
3. 成员内部类是依附外部类而存在的，也就是说，如果要创建成员内部类的对象，前提是必须存在一个外部类的对象。所以在外部类访问内部类的时候必须先实例化外部类对象。
4. 成员内部类可以使用四种权限修饰符进行修饰
5. 成员内部类中不能书写静态变量和方法。

例：

public class Outter {
    String name = "王五";
    static int age = 20;

    public static void show() {
        System.out.println("外部类中的show方法");
    }

    public void printf() {
        System.out.println("外部类中的打印方法");
    }

    //成员内部类 可以使用权限修饰符进行修饰
    public class Inner{
        String name="张三";
        //成员内部类可以直接访问外部类的属性和方法
        public void innerShow() {
            show();
            printf();
            System.out.println(age);
            System.out.println("我是："+name);
            System.out.println("我是："+Outter.this.name);//进行特指访问时 使用类名.this.变量名进行访问
        }
    }

    public static void main(String[] args) {
        //成员内部类对象的创建步骤
        //第一步需要实例化外部类对象
        //第二步正常实例化内部类对象 但是new关键字要改成 外部类对象名.new
        Outter outter = new Outter();
        Inner ineer = outter.new Inner();
        ineer.innerShow();
    }
}

2、局部内部类

编写在方法的内部的类称之为局部内部类

局部内部类的特点

1. 局部内部类是定义在一个方法或者一个作用域里面的类，它的访问仅限于方法内或者该作用域内。
2. 不可使用权限修饰符 静态修饰符进行修饰 同局部变量相同
3. 可以直接访问方法中的属性
4. 可以直接访问方法外部类中属性和方法
5. 创建对象 要在方法内部 局部内部类的外部声明

例：

public class Demo1 {
    String name = "王五";
    static int age = 10;

    public static void show() {
        System.out.println("外部类中的show方法");
    }

    public void printf() {
        System.out.println("外部类中的打印方法");
    }

    public void demo() {
        String name = "张三";

        //编写在方法的内部的类称之为局部内部类
        //局部内部类不可使用权限修饰符 静态修饰符进行修饰 同局部变量相同
        //局部内部类与局部变量使用范围一样 在此方法内部
        //局部内部类可以直接访问方法中的属性 重名时使用参数传递完成访问
        //局部内部类 可以访问方法外部类中属性和方法

        class Inner{
            String name = "李四";
            public void showInner(String name) {
                show();
                printf();
                System.out.println(age);
                System.out.println("这是:"+Demo1.this.name);
                System.out.println("这是："+name);
                System.out.println("这是："+this.name);

            }
        }
        //局部内部类 创建对象 要在方法内部 局部内部类的外部声明
        Inner inner=new Inner();
        inner.showInner(name);

    }

    public static void main(String[] args) {
        Demo1 d = new Demo1();
        d.demo();

    }
}

3、匿名内部类

匿名内部类特点

匿名内部类不能定义任何静态成员、方法和类，只能创建匿名内部类的一个实例。一个匿名内部类一定是在new的后面，用其隐含实现一个接口或实现一个类。

例：

public class Demo2 extends Thread{
    public static void main(String[] args) {
        Thread thread = new Thread(){
            @Override
            public void run() {
                System.out.println("这是一个线程");
            }
        };
        thread.start();

    }
}

4、静态内部类

在类中编写的以static修饰的类称为静态内部类

静态内部类特点

1. 静态内部类也是定义在另一个类里面的类，只不过在类的前面多了一个关键字static。
2. 静态内部类是不需要依赖于外部类的，这点和类的静态成员属性有点类似，并且它不能使用外部类的非static成员变量或者方法。
3. 静态内部类中即能声明静态成员也可以声明非静态成员。

例：

public  class StaticDemo {
    static String name="王五";

    public static class Inner{//四种权限修饰符可以修饰静态内部类
        //静态内部类中不能访问外部类非静态成员
        String name="张三";
        static int age=18;
        double height=1.8;
        public void show() {
            //重名时 访问外部类的静态变量使用类名.属性名访问
            System.out.println("这是"+name);
            System.out.println("这是"+StaticDemo.name);
            System.out.println(age);
            System.out.println(height);
        }
    }

    public static void main(String[] args) {
        //静态内部类可以直接实例化 不需要依附于外部类
        Inner inner = new Inner();
        inner.show();
    }
}

二、static关键字

在类中，用static声明的成员变量为静态成员变量，也成为类变量。类变量的生命周期和类相同，在整个应用程序执行期间都有效。

注意：

1. static修饰的成员变量和方法，从属于类
2. 普通变量和方法从属于对象
3. 静态方法不能调用非静态成员，编译会报错

static关键字可以修饰非常多的东西（如：属性、方法、类、语法块、导包）

static修饰的代码，会提前加载到内存中，并且只有一份，属于该类，
	因此：静态方法中，无法直接调用非静态函数（属性）

被static修饰的属性和方法，不属于对象，属于该类
直接可以使用类名称.属性（方法）来调用。

public class TestStatic {

    public int age;
    // 静态属性
    public static int aa;
    
    public void say() {
        System.out.println("hello static ");
    }

    public static void sayHello() {
        System.out.println("这个是一个静态方法");
    }

    {
        // 构造代码块
    }

    static {
        // 静态代码块
    }

    public static void main(String[] args) {
		System.out.println(aa);
		sayHello();

        MyUtil myUtil = new MyUtil();
		System.out.println(myUtil.PI);
		System.out.println(myUtil.age);
        System.out.println(myUtil.name);

		myUtil.age = 30;
		System.out.println(myUtil.age);

        // 静态属性，直接使用类名称调用
        System.out.println(MyUtil.PI);
        System.out.println(MyUtil.age);

        MyUtil myUtil02 = new MyUtil();
		System.out.println(myUtil02.age);

    }

    // static还可以修饰类，注意，只能修饰内部类
    static class Test {

    }
}

class MyUtil {

    public final static double PI = 3.14;
    public static int age = 20;
    public String name = "张三";

    public void say() {
        System.out.println("hello static ");
    }

    public static void sayHello() {
        System.out.println("这个是一个静态方法");
    }
}

三、final关键字

final： 不可改变。可以用于修饰类、方法和变量。

变量：被修饰的变量，不能被重新赋值。
方法：被修饰的方法，不能被重写。
类：被修饰的类，不能被继承。

注意：被final修饰的常量名称，一般都有书写规范，所有字母都大写。

例：

修饰变量——不能被重新赋值

修饰方法——不能被重写

修饰类——不能被继承