JavaSE基础day09final、内部类、静态代码块、包、权限修饰符、匿名内部类

---

一. 代码块(了解)

(一)概述

1、使用大括号包起来的一段代码。放在不同的位置，有不同的名称，有不同的作用，有不同的执行时机。

2、分类：

       局部代码块

       构造代码块

       静态代码块

       同步代码块（多线程）

(二)局部代码块

1、位置：定义在方法中的代码块

2、作用：

       限定变量的生命周期

       在局部代码块中【声明】的变量，只能在局部代码块的范围内使用，一旦出了局部代码块的大括号，变量就不能继续使用了。

       缩短局部变量的生命周期，及时的释放内存空间提升代码的运行效率

3、注意事项：

(1) 代码块可以使用外部的所有资源

(2) 如果是在局部代码块中修改了局部代码块外声明的变量，局部代码块结束之后，并不会消除局部代码块对这个变量的修改。

public class Demo01_局部代码块 {
    public static void main(String[] args) {
        int i = 10;
        // 局部代码块: 作用, 限定 定义在局部代码块中变量作用范围
        // 优势: 不仅仅是范围的限定,也是变量在内存中存储时间的限定,例如y变量,如果局部代码块执行完毕, y就变成了一个无法再使用的变量,很快就会被JVM回收掉
        {
            int y = 20;
            System.out.println(y);
            // 如果是局部代码块之外变量使用,不受局部代码块限制
            i = 88;
        }
        // System.out.println(y);
        System.out.println(i);// 88
    }
}

(三)构造代码块

1、位置：定义在类中方法外【成员变量位置】

2、作用：

(1) 创建对象的时候给对象的属性值显性赋值

(2) 提取本类构造方法中的共性内容实现

3、构造代码块的执行说明：

       1、在创建对象的时候执行，由jvm默认调用

       2、在构造方法执行之前，执行

public class Demo02_构造代码块 {
    int i = 10;
    String name;
    // 构造代码块:
    // 运行时机: 当每次创建对象的同时, JVM虚拟机主动调用构造代码块一次, 并且是在构造方法之前
    // 作用: 可以给当前对象中的成员变量进行赋值; 如果当前类型中有多个构造方法, 并且这些构造中有相同的处理逻辑
    // 这些逻辑可以提升到构造代码块中完成
    {
        name = "张三";
        System.out.println("构造代码块运行了");
        System.out.println("我是构造方法");
    }

    public Demo02_构造代码块(){
       // System.out.println("我是构造方法");
    }

    public Demo02_构造代码块(int i){
        this.i = i;
       // System.out.println("我是构造方法");
    }

    public static void main(String[] args) {
        Demo02_构造代码块 demo = new Demo02_构造代码块();
        System.out.println(demo.name);
        Demo02_构造代码块 demo1 = new Demo02_构造代码块(99);
    }
}

(四)静态代码块(一定掌握)

1、格式：

       static {

            静态代码块的内容

        }

2、位置：类中方法外

3、作用：

(1) 给类的静态变量赋值

(2) 用来加载只需要加载一次的资源【例如: 加载数据库驱动】

4、执行特点：

(1) 随着类的加载而执行

(2) 静态代码块只执行一次

(3) 执行的时机最早：早于所有的对象相关内容

public class Demo03_静态代码块 {
    int i;
    static int w;
    // 静态代码块:
    // 1. 可以给类型中的静态成员变量进行赋值
    // 2. 静态代码块运行时机: 因为静态都属于类, 因此在当前类进入内存时候(进入方法区),JVM虚拟机主动调用
    // 静态代码块一次
    // 3. 静态代码块使用场景: 如果有代码只需要执行一次, 并且是在所有其他代码运行之前就执行, 那么这些逻辑
    // 可以设计在静态代码块中
    // 举例: 数据库,持久性的存储数据; 需要在交易开始之前, 保证数据库连接成功的(登录数据库,读取数据库登录时用户名和密码)
    // 连接数据库的过程就可以设计在静态代码块中
    static{
       // i = 10;  静态中不能直接使用非静态
       w = 99;
       System.out.println("我是静态代码块");
    }

    public static void main(String[] args) {
        System.out.println(Demo03_静态代码块.w);
        Demo03_静态代码块 dmo = new Demo03_静态代码块();
    }
}

二. 内部类(了解)

(一)    概述

1. 定义在一个类中的另一个类就叫做内部类

　　举例：在一个类A的内部定义一个类B，类B就被称为内部类

 

2. 格式:

  public class Outer { // 外部类

         public class Inner { }// 内部类

  }

 

　　人类: 定义成Person, 人类组成很复杂, 身体器官: 心脏, 肝, 肾...

      　　心脏: 血压, 心跳, 颜色, 控制身体机能

 

3. 分类: 根据定义的位置不一样以及是否有名分为了不同的内部类，具体分类如下：

　　1) 成员内部类

　　2) 局部内部类

　　3) 匿名内部类(掌握)

 

 

4. 访问特点:

　　内部类可以直接访问外部类的成员，包括私有成员

　　外部类要访问内部类的成员，必须创建对象

(二)    普通成员内部类

1. 定义位置: 在类中方法外，跟成员变量是一个位置

1. 外界创建成员内部类格式

格式：外部类名.内部类名 对象名 = 外部类对象.内部类对象;

举例：Outer.Inner oi = new Outer().new Inner();

 

2. 访问方式:

(1) 内部类可以直接访问外部类的所有成员，包括私有成员

(2) 外部类访问内部类的成员，必须先创建内部类对象

public class Body {
    int height = 80;

    public void test(){
        System.out.println("我是test");
    }
    // 普通成员内部类
    class Heart{
        String color = "红色";
        int jump = 100;
        int height = 999;
        public void show(){
            // 1. 内部类中可以直接使用外部类中的成员(成员变量, 方法)
           System.out.println(color + "颜色的心脏,每分钟跳" + jump + "下,血压为:" + height
             + "--" + new Body().height);
            test();
        }
    }

    // 2. 外部类如果想使用内部类成员, 需要创建出一个内部类对象
    public void useHeart(){
        System.out.println(height);
        Heart h = new Heart();
        System.out.println(h.color);
        System.out.println(h.jump);
        h.show();
    }
}

public class TestInnerClass {
    public static void main(String[] args) {
        // 1. 测试普通成员内部类使用
        Body b = new Body();
        b.useHeart();

        System.out.println("--------------------------------");
        // 2. 测试普通成员内部类对象在其他类中创建
        // 外部类名.内部类名  对象名 = new 外部类对象().new 内部类对象();
        Body.Heart h = new Body().new Heart();
        // Heart h1 = new Heart();
        System.out.println(h.color);
        System.out.println(h.jump);
        System.out.println(h.height);
        h.show();
    }
}

(三)    私有的成员内部类

1、也是一个成员内部类，在成员内部类前面加上一个private关键字

2、访问方式：

　　(1) 在外部类以外，不能直接访问外部类中的私有成员内部类

　　(2) 可以在外部类中，定义一个访问私有成员内部类的公有方法，让外界可以调用公有方法，间接的访问外部类中的私有成员内部类。

public class Body1 {
    private int height = 80;

    public int getHeight() {
        return height;
    }

    public void setHeight(int height) {
        this.height = height;
    }

    public void test(){
        System.out.println("我是test");
    }
    // 普通成员内部类
    private class Heart1{
        String color = "红色";
        int jump = 100;
        int height = 999;
        public void show(){
            // 1. 内部类中可以直接使用外部类中的成员(成员变量, 方法)
            System.out.println(color + "颜色的心脏,每分钟跳" + jump + "下,血压为:" + height
             + "--" + new Body1().height);
            test();
        }
    }

    // 2. 外部类如果想使用内部类成员, 需要创建出一个内部类对象
    public void useHeart1(){
        System.out.println(height);
        Heart1 h = new Heart1();
        System.out.println(h.color);
        System.out.println(h.jump);
        h.show();
    }
}

public class TestInnerClass {
    public static void main(String[] args) {
        // 3. 测试私有成员内部类: 通过间接方式访问私有成员内部类
        Body1 b1 = new Body1();
        b1.useHeart1();
    }
}

(四)    静态的成员内部类

1、也是一个成员内部类，在成员内部类前面加上一个static关键字

2、访问方式：

(1) 成员内部类是外部类的静态成员，所以可以通过外部类名.内部类名的方式直接访问，而不需要创建外部类的对象

(2) 静态内部类中的非静态成员，需要将所在的内部类对象创建出来之后，才能被调用。

总结：一个类是否需要创建对象，不取决于该类本身是否是静态，而取决于要访问

                 的成员是否是静态

3、静态成员内部类的对象创建格式：    

       外部类名.内部类名 内部类对象名 = new 外部类名.内部类名();

public class Body2 {
    // w表示每天喝多少升水
    static int w = 2;
    // 静态成员内部类
    // 是否需要创建对象调用成员: 如果这个成员是非静态的, 那么创建对象; 如果这个成员是静态成员, 那么不需要创建对象, 类名.直接调用
    static class Shen{
        int day = 1;
        static int wc = 8;
        public void show(){
            System.out.println(day + "天喝了" + w + "升,应该去卫生间"+ wc + "次");
        }
    }
}

public class TestInnerClass {
    public static void main(String[] args) {
        // 4. 测试静态成员内部类:
        // 1) 调用静态成员内部类中的静态成员变量
        System.out.println(Body2.Shen.wc);// 8
        // 2) 调用静态成员内部类中非静态成员变量
        // 静态成员内部类对象创建方式:
        // 外部类名.内部类名 对象名 = new 外部类名.内部类名();
        Body2.Shen sh = new Body2.Shen();
        System.out.println(sh.day);// 1
        sh.show();// 1天喝了2升,应该去卫生间8次
    }
}

(五)    局部内部类

1. 定义位置: 局部内部类是定义在方法中的类

2. 访问方式:

　　(1) 局部内部类，外界是无法直接使用，需要在方法内部创建对象并使用

　　(2) 该类可以直接访问外部类的成员，也可以访问方法内的局部变量

public class Demo_局部内部类 {
    public static void main(String[] args) {
        breath();
    }

    public static void breath(){
        // 1. count作为局部变量不能单独获取到, 只能跟着breath方法运行使用
        int count = 10;
        // 2. 局部内部类, 与局部变量类似,只能在方法中定义使用
        class Fei{
            String color = "black";
            public void show(){
                System.out.println("每天吸" + count + "跟烟,总有一天肺就会变成" + color);
            }
        }
        // 3. 局部变量,直接在方法中创建对象使用
        Fei f = new Fei();
        System.out.println(f.color);
        f.show();
    }
}

三. final关键字

1、final是一个关键字 含义：最终的，最后的，表示不能再改变的。

2、final关键字：可以修饰类、方法、变量

3、修饰类：

        (1) 表示一个最终类，表示不能有子类，【不能被其他类继承】

        (2) 一旦一个类型不能被继承，那么其中所有的方法都不能被重写

        (3) 不影响当前类的方法被调用

4、修饰方法：

       表示一个最终方法，【该方法不能被重写】

5、修饰变量：

       (1) 表示一个最终变量，该【变量变成了常量】，就只能赋值一次

       (2) 当前项目中，常用的常量一般都定义在一个类的成员位置，甚至专门定义一个常量类,常量命名规范: 所有单词全大写, 多个单词之间使用_进行分隔了,举例: SCHOOL_NAME  PI

       (3) 定义常量的好处：见名知意，容易理解；可维护性高

 

final修饰类代码

// final修饰的类没有子类
public final class FinalClass {
    int i = 10;
    static int w = 20;
    public void fun(){
        System.out.println("我是final类中的fun方法");
    }
}

/*public class FinalClassSub extends FinalClass{ // 报错
}*/

final修饰方法:

public class FinalMethod {
    public final void eat(){
        System.out.println("我是final修饰的吃饭功能, 不能被继承,但是可以直接使用");
    }
}

public class FinalMethodSub extends FinalMethod{
    // 子类继承到了父类中的eat方法,但是因为这个方法是final修饰的,只能使用不能重写
    /*public void eat(){
        System.out.println("我是final修饰的吃饭功能, 不能被继承,但是可以直接使用");
    }*/
}

final修饰变量:

public class FinalVariable {
    // 5. final修饰成员变量: 最好直接赋值(扩展: final修饰成员变量, 必须在创建对象完成之前进行手动赋值)
    final String name = "张三";// 最推荐
    final String sex;

    public FinalVariable(){
        sex = "男";
    }
    int w = 99;
    // 1. final修饰的变量值不能发生改变, final固定的数据第一次手动赋值
    // 2. final修饰的变量称为常量: 所有单词全大写, 多个单词之间_分隔
    public static void main(String[] args) {
        final int I = 10;
        // 3. final修饰基本数据类型,其数值不能发生修改
        // I = 19;
        // 4. final修饰引用数据类型,那么表示这个引用地址值不能发生改变
        final FinalVariable fv = new FinalVariable();
        // fv = new FinalVariable();
        fv.w = 888;
    }
}

final代码测试类:

public class TestFinal {
    public static void main(String[] args) {
        // 1. 测试final修饰的类可以正常使用
        FinalClass fc = new FinalClass();
        System.out.println(fc.i);
        System.out.println(FinalClass.w);
        fc.fun();

        // 2. 测试final修饰的方法可以被子类继承, 也可以正常使用
        FinalMethodSub fms = new FinalMethodSub();
        fms.eat();

        FinalMethod fm = new FinalMethod();
        fm.eat();
    }
}

四. 包

1. 包的概述: 用来统一分类管理源代码资源的特殊文件夹；这个文件夹会参与编译。

比如：

      com.ujiuye.demo 下的 Person类进行编译的时候类所在的包参与编译，编译后

        字节码文件名：com.ujiuye.demo.Person

        字节码文件中类名:com.ujiuye.demo.Person【全限定类名】  

 

2. 作用:

　　(1) 统一管理代码资源

　　(2) 保证代码编译后类名唯一

　　(3) 保证代码运行的过程直接进入包找到对应的类

 

3. 命名规则:

　　(1) 使用公司域名的反写【保证每一个包路径唯一】

　　(2) 全部小写

　　(3) 包名和包名之间使用.隔开

 

4. 包的声明:

   使用关键字 package + 包路径【IDE生成类的时候自动声明】

 

5. 导包:

　　同包下：不需要导包

　　不同包：需要导包【jdk的lang包除外】

　　使用 import + 包路径

 

6. 注意:

　　(1) 没有导包格式之前：使用类的时候不导包的直接使用全限定类名进行使用

                 比如：java.util.Scanner sc = new java.util.Scanner(System.in);

　　(2) 使用全限定类名使用类的时候，有点麻烦进行了简化：

                 使用import关键字进行提取导包进行导包

　　(3) 作用

　　　　可以把同名字的类使用包做一个详细的划分

import com.ujiuye.homework.Phone;

public class Test {
    // com.ujiuye.innerclass.Test
    // com.ujiuye.block.Test
    Phone p = new Phone();

    // java.lang包下的所有类型可以直接使用, 不需要导包
    String str = "abc";
}

五. 权限修饰符

1. 概述: 用来限定资源的使用范围的修饰词汇，就叫做权限(使用)修饰符，不同的符号有不同的限定范围

2. 分类: 从小到大权限罗列

  private ：私有的     限定范围：本类中使用

默认的 ：啥也不写    限定范围：本类和本包中使用

protected ：受保护的  限定范围：本类和本包中使用,不同包下的子类内部可以使用

public ：公共的      限定范围：没有范围

 

3. 注意:

1) protected 只修饰方法和变量, 不能修饰类; 保护的是外包子类的内部

2) 总结: 修饰成员变量,为了满足封装特点,使用private修饰;

         修饰类,和普通方法功能, 通常使用public修饰

 

 

// DefaultClass是默认权限修饰的类: 使用范围本包中使用
class DefaultClass {
    // 默认权限成员变量
    String name = "李四";
    // 默认权限方法
    void fun(){
        System.out.println("我是默认的方法fun");
    }
}

public class ProtectedClass {
    protected double height = 175;
    protected void sleep(){
        System.out.println("我是受保护的休眠方法" + height);
    }
}

public class PublicClass {
    public String sex = "女";

    public void happy(){
        System.out.println("happy" + sex);
    }
}

public class TestQuanXian {
    public static void main(String[] args) {
        // 1. 默认修饰的类型, 可以在本包中使用
        DefaultClass sc = new DefaultClass();
        sc.fun();
        System.out.println(sc.name);

        // 2. 受保护权限可以在本包中使用
        ProtectedClass pc = new ProtectedClass();
        System.out.println(pc.height);
        pc.sleep();
    }
}

import com.ujiuye.quanxian.ProtectedClass;

public class ProtectedClassSub extends ProtectedClass {
    // ProtectedClassSub子类继承到了父类中的两个受保护成员
    // double height = 175;  sleep方法
    // 这两个受保护在子类中相当于private使用
    public void useProtected(){
        System.out.println(height);
        sleep();
    }
}

//import com.ujiuye.quanxian.DefaultClass;

import com.ujiuye.quanxian.ProtectedClass;
import com.ujiuye.quanxian.PublicClass;

public class Test {
    public static void main(String[] args) {
        // 1. 测试默认权限不能在其他包中使用
       // DefaultClass sc = new DefaultClass();
       // System.out.println(sc.name);

        // 2. 测试受保护权限在外包子类之外不能使用
        ProtectedClass pc = new ProtectedClass();
        // pc.sleep();

        ProtectedClassSub pcs = new ProtectedClassSub();
        // pcs.sleep();
        // System.out.println(pcs.height);

        // 3. 测试公共修饰的类型可以任意使用, 没有限制
        PublicClass pub = new PublicClass();
        System.out.println(pub.sex);
        pub.happy();
    }
}

修饰符关键字:

private 私有: 封装特性

static 静态: 属于类,跟着类存储在方法区中静态区域中, 就只有一份, 可以被所有对象共享使用

final 最后的, 不可改变的: 修饰类, 修改方法, 修饰变量(常量)

默认权限在类中不写出来, 写了反而代码报错

protected

public

 

六. 匿名内部类

1、没有名字的内部类

2、匿名内部类的使用前提：

        匿名类：继承一个类

       匿名类：实现一个接口

1、格式：

       new 父类类名或者接口名() {

            父类方法的重写或者是接口内容的实现

}

2、本质：

　　(1) 创建了一个类的子类对象、接口的实现类对象

　　(2) 更强调关系的一种写法

5、内部类的名称总结：

       (1) 如果是有名字的内部类，类名【外部类名$内部类名】

       (2) 如果是没有名字的内部类，通过匿名内部类的顺序描述类名，第一个匿名内部类的名称【外部类名$1】，第二个匿名内部类类名【外部类名$2】

public class 匿名内部类 {
    public static void main(String[] args) {
        // 1. 匿名内部类可以作为一个类的子类对象存在
        /*
             new 类名(){// 大括号就表示类的子类实现过程
             };
         */
        new Animal(){
            @Override
            public void eat(){
                System.out.println("不同动物吃不同的实物");
            }
        }.eat();
    }
}

代码块总结

1、局部代码块:
  - 作用
    - 限定 定义在局部代码块的中变量的作用范围
  - 优势
    - 不仅仅是范围的限定，也是变量在内存中储存时间的限定，（使用完成后，局部代码块外无法再调用 内存回收）

2、构造代码块:在构造方法之前调用，通常用于提取无参构造跟有参构造公共代码

3、静态代码块
    1. 可以给类型中的静态成员变量进行赋值
    2. 静态代码块运行时机: 因为静态都属于类, 因此在当前类进入内存时候(进入方法区),JVM虚拟机主动调用
    静态代码块一次
    3. 静态代码块使用场景: 如果有代码只需要执行一次, 并且是在所有其他代码运行之前就执行, 那么这些逻辑
    可以设计在静态代码块中
    举例: 数据库,持久性的存储数据; 需要在交易开始之前, 保证数据库连接成功的
    (登录数据库,读取数据库登录时用户名和密码)
    连接数据库的过程就可以设计在静态代码块中

内部类总结

1、普通成员内部类
  - 定义位置
    - 类中，方法外，跟成员变量同级的位置

  - 访问方式
      1) 内部类可以直接使用外部类包括的私有属性和方法
      2) 外部类访问普通内部类必须通过对象 (类中)
         // 1)
         Wrapper war = new Wrapper();
         Wrapper.Inner inn = war.new Inner();
         // 2)
         Wrapper.Inner inn2 = new Wrapper().new Inner();


2、私有的成员内部类
  - 定义位置 跟普通成员内部类的区别是 前面加上private
    - 访问方式：
    1) 在外部类以外，不能直接访问外部类中的私有成员内部类
    2) 可以在外部类中，定义一个访问私有成员内部类的公有方法，
       让外界可以调用公有方法，间接的访问外部类中的私有成员内部类。


3、静态的成员内部类
  - 定义位置，也是一个成员内部类，在成员内部类前面加上一个static关键字
    - 访问方式：
    1) 是外部类的静态成员，所以可以直接类名.静态内部类 使用
    2) 如果需要调用 静态类的成员，需要观察静态内部类的成员是否是静态的，
        如果是静态的可以直接调用，非静态则需要创建对象调用。

            static class StaticInner {
                    public String name3 = "静态成员内部类-公有局部变量";
                    private String name33 = "静态成员内部类-私有局部变量";
                    static String name333 = "静态成员内部类-静态局部变量";

                    public String getName33() {
                        return name33;
                    }

                    public void staticMethod() {        //  静态的成员内部类方法
                        System.out.println("静态的成员内部类方法");
                    }
                }

            Wrapper.StaticInner inn3 = new Wrapper.StaticInner();
            System.out.println(Wrapper.StaticInner.name333);  // 静态内部类静态属性
            System.out.println(inn3.getName33());  // 静态内部类私有属性
            System.out.println(inn3.name3);  // 静态内部类公有属性
            inn3.staticMethod();   // 静态内部公有有方法

4、局部内部类
  - 定义位置: 局部内部类是定义在方法中的类
    - 访问方式:
    1) 局部内部类，外界是无法直接使用，需要在方法内部创建对象并使用
    2) 该类可以直接访问外部类的成员，也可以访问方法内的局部变量

        public void localFunc() {
                String name4 = "局部变量";

                class LocalInner{
                    private String name5 = "局部内部类";

                    public String getName4() {
                        return name4;
                    }
                }
                // 局部内部类无法在 外部使用，只能在方法中创建对象使用，可以使用方法的局部变量
                LocalInner l = new LocalInner();
                l.getName4();
            }


        public class Demo_局部内部类 {
            public static void main(String[] args) {
                breath();
            }

            public static void breath(){
                // 1. count作为局部变量不能单独获取到, 只能跟着breath方法运行使用
                int count = 10;
                // 2. 局部内部类, 与局部变量类似,只能在方法中定义使用
                class Fei{
                    String color = "black";
                    public void show(){
                        System.out.println("每天吸" + count + "跟烟,总有一天肺就会变成" + color);
                    }
                }
                // 3. 局部变量,直接在方法中创建对象使用
                Fei f = new Fei();
                System.out.println(f.color);
                f.show();
            }
        }