java代码块,final修饰符,内部类

final

• final代表最终的意思，可以修饰成员方法，成员变量，类
  • fianl修饰类：该类不能被继承（不能有子类，但是可以有父类）
  • final修饰方法：该方法不能被重写
  • final修饰变量：表明该变量是一个常量，不能再次赋值
    • 变量是基本类型,不能改变的是值
    • 变量是引用类型,不能改变的是地址值（指向）,可以改变指向的空间的值

代码块分类

• 局部代码块
  • 位置: 方法中定义
  • 作用: 限定变量的生命周期，及早释放，提高内存利用率
  • 示例代码

public class Test {
    /*
        局部代码块
            位置：方法中定义
            作用：限定变量的生命周期，及早释放，提高内存利用率
     */
    public static void main(String[] args) {
        {
            int num = 10;
            System.out.println(num);
        }

       // System.out.println(num);
    }
}

• 构造代码块
  • 位置: 类中方法外定义
  • 特点: 每次构造方法执行的时，都会执行该代码块中的代码，并且在构造方法执行前执行
  • 作用: 将多个构造方法中相同的代码，抽取到构造代码块中，提高代码的复用性
  • 示例代码

class Person {
    {
        System.out.println("构造方法公共的代码");
    }

    public Person(){
        System.out.println("空参数构造方法");
    }

    public Person(int a){
        System.out.println("带参数构造方法...........");
    }
}

public class Test {
    public static void main(String[] args) {
        Person person=new Person();
        Person person2=new Person(10);

    }
}

• 静态代码块
  • 位置: 类中方法外定义
  • 特点: 需要通过static关键字修饰，随着类的加载而加载，并且只执行一次
  • 作用: 在类加载的时候做一些数据初始化的操作
  • 示例代码

package cn.zzj;
class Person {
    static {
        System.out.println("静态代码块");
    }

    public Person(){
        System.out.println("空参数构造方法");
    }

    public Person(int a){
        System.out.println("带参数构造方法...........");
    }
}

public class Test {
    public static void main(String[] args) {
        Person person=new Person();
        Person person2=new Person(10);

    }
}

接口

• 接口组成更新概述【理解】

  • 常量
    public static final

  • 抽象方法
    public abstract void test()

  • 默认方法(Java 8)
    public default 返回值类型 方法名(参数列表) { }

    • 作用
      解决接口升级的问题
    • 注意事项
      • 默认方法不是抽象方法，所以不强制被重写。但是可以被重 写，重写的时候去掉default关键字
      • public可以省略，default不能省略
      • 如果实现了多个接口，多个接口中存在相同的方法声明，子类就必须对该方法进行重写

  • 静态方法(Java 8)
    public static 返回值类型 方法名(参数列表) { }

    • 注意事项
      • 静态方法只能通过接口名调用，不能通过实现类名或者对象名调用
      • public可以省略，static不能省略

  • 私有方法(Java 9)
    private 返回值类型 方法名(参数列表) { }

    • 私有方法产生原因
      • Java 9中新增了带方法体的私有方法，这其实在Java 8中就埋下了伏笔：Java 8允许在接口中定义带方法体的默认方法和静态方法。这样可能就会引发一个问题：当两个默认方法或者静态方法中包含一段相同的代码实现时，程序必然考虑将这段实现代码抽取成一个共性方法，而这个共性方法是不需要让别人使用的，因此用私有给隐藏起来，这就是Java 9增加私有方法的必然性
    • 注意事项
      • 默认方法可以调用私有的静态方法和非静态方法
      • 静态方法只能调用私有的静态方法

内部类

• 内部类概念
  • 在一个类中定义一个类。举例：在一个类A的内部定义一个类B，类B就被称为内部类
• 内部类定义格式

/*
	格式：
    class 外部类名{
    	修饰符 class 内部类名{
    	
    	}
    }
*/

class Outer {
    public class Inner {
        
    }
}

• 内部类的访问特点
  • 内部类可以直接访问外部类的成员，包括私有
  • 外部类要访问内部类的成员，必须创建对象
• 示例代码：

public class Outer {
    private int iNum= 1;
    public class Inner {
        public void show() {
            System.out.println(iNum);
        }
    }
    public void method() {
        Inner i = new Inner();
        i.show();
    }
}

• 成员内部类
  • 成员内部类的定义位置
    • 在类中方法，跟成员变量是一个位置
  • 外界创建成员内部类格式
    • 格式：外部类名.内部类名 对象名 = 外部类对象.内部类对象;
    • 举例：Outer.Inner oi = new Outer().new Inner();
  • 一般私有化私有成员内部类
    • 将一个类，设计为内部类的目的，大多数都是不想让外界去访问，所以内部类的定义应该私有化，私有化之后，再提供一个可以让外界调用的方法，方法内部创建内部类对象并调用

class Outer {
    private int iNum = 10;
    private class Inner {
        public void show() {
            System.out.println(iNum );
        }
    }
    public void method() {
        Inner i = new Inner();
        i.show();
    }
}
public class InnerDemo {
    public static void main(String[] args) {
		//Outer.Inner oi = new Outer().new Inner();
		//oi.show();
        Outer o = new Outer();
        o.method();
    }

• 静态成员内部类
  • 静态成员内部类访问格式：外部类名.内部类名 对象名 = new 外部类名.内部类名();
  • 静态成员内部类中的静态方法：外部类名.内部类名.方法名();
  • 示例代码

class Outer {
    static class Inner {
        public void show(){
            System.out.println("inner..show");
        }

        public static void method(){
            System.out.println("inner..method");
        }
    }
}

public class TestInnerClass {
    /*
        静态成员内部类演示
     */
    public static void main(String[] args) {
        // 外部类名.内部类名 对象名 = new 外部类名.内部类名();
        Outer.Inner oi = new Outer.Inner();
        oi.show();

        Outer.Inner.method();
    }

局部内部类

• 局部内部类定义位置
  • 局部内部类是在方法中定义的类
• 局部内部类方式
  • 局部内部类，外界是无法直接使用，需要在方法内部创建对象并使用
  • 该类可以直接访问外部类的成员，也可以访问方法内的局部变量
• 示例代码

class Outer {
    private int outVal = 10;
    public void method() {
        int methodVal= 20;
        class Inner {
            public void show() {
                System.out.println(outVal );
                System.out.println(methodVal);
            }
        }
        Inner i = new Inner();
        i.show();
    }
}
public class OuterDemo {
    public static void main(String[] args) {
        Outer o = new Outer();
        o.method();
    }
}

• 匿名内部类
  • 匿名内部类的前提
    • 存在一个类或者接口，这里的类可以是具体类也可以是抽象类
  • 匿名内部类的本质
    • 本质：是一个继承了该类或者实现了该接口的子类匿名对象
  • 匿名内部类的格式
    • 格式：new 类名 ( ) { 重写方法 } new 接口名 ( ) { 重写方法 }

new Inter(){
    @Override
    public void method(){}
} 

• 匿名内部类可以通过多态的形式接受

interface Inter{
    void method();
}
Inter i = new Inter(){
  @Override
    public void method(){
        
    }
}

• 匿名内部类直接调用方法

interface Inter{
    void method();
}

class Test{
    public static void main(String[] args){
        new Inter(){
            @Override
            public void method(){
                System.out.println("我是匿名内部类");
            }
        }.method();	// 直接调用方法
    }

• 匿名内部类在开发中的使用
  • 当发现某个方法需要，接口或抽象类的子类对象，我们就可以传递一个匿名内部类过去，来简化传统的代码
  • 示例代码：

interface DaBaoJian {
    void go();
}

class TestDaBaoJian {
    /**
     * 使用接口的方法
     */
    public static void goDaBaoJian(DaBaoJian daBaoJian){
        daBaoJian.go();
    }

    public static void main(String[] args) {
        goDaBaoJian(new DaBaoJian() {
            @Override
            public void go() {
                System.out.println("铁汁, 我们去大保健吧");
            }
        });
    }

}