1. 权限修饰符

1.1 package（了解）

1. 包的概念

   包就是文件夹，用来管理类文件的

2. 包的定义格式

   • package 包名; (多级包用.分开)
     • 例如：package com.itheima.demo;
     • 注意：包名不能以数字开头，不能为关键字，否则无法创建Java文件

3. 带包编译&带包运行

   • 带包编译：javac –d . 类名.java
     • 例如：javac -d . com.itheima.demo.HelloWorld.java
   • 带包运行：java 包名+类名
     • 例如：java com.itheima.demo.HelloWorld

1.2 import（理解）

• 导包的意义

  使用不同包下的类时，使用的时候要写类的全路径，写起来太麻烦了

  为了简化带包的操作，Java就提供了导包的功能

• 导包的格式

  格式：import 包名;

  范例：import java.util.Scanner;

• 示例代码（没有使用导包，创建的Scanner对象）

package com.heima;

public class Demo {
	public static void main(String[] args) {
		// 1. 没有导包，创建Scnaner对象
		java.util.Scanner sc = new java.util.Scanner(System.in);
	}
}

示例代码（使用导包后，创建的Scanner对象）

package com.heima;

import java.util.Scanner;

public class Demo {
	public static void main(String[] args) {
		// 1. 没有导包，创建Scnaner对象
		Scanner sc = new Scanner(System.in);
	}
}

1.3 权限修饰符（理解）

1.3.1 权限修饰符的概念

• 用来控制成员能够被访问的范围
• 可以修饰成员变量，方法，构造器，内部类，不同权限修饰符修饰的成员能够被访问的范围是不同的

1.3.2 权限修饰符对应权限

1.3.3 权限修饰符的使用

• 成员变量一般为私有
• 类、方法、构造器一般公开public
• 如果该成员只希望本类访问，使用private修饰
• 如果该成员只希望在本包和子类访问，使用protected修饰
• 如果该成员只希望在本包中访问，使用缺省（默认不写）修饰符

1.3.4 示例代码

demo10——Fu

package day10.demo10;

public class Fu {
    private void show1() {
        System.out.println("private");
    }

    void show2() {
        System.out.println("默认");
    }

    protected void show3() {
        System.out.println("protected");
    }

    public void show4() {
        System.out.println("public");
    }

    public static void main(String[] args) {
        //创建Fu的对象，测试看有哪些方法可以使用
        Fu f = new Fu();
        f.show1();
        f.show2();
        f.show3();
        f.show4();
    }
}

demo10——Zi

package day10.demo10;

public class Zi extends Fu {
    public static void main(String[] args) {
        //创建Zi的对象，测试看有哪些方法可以使用
        Zi z = new Zi();
        z.show2();
        z.show3();
        z.show4();
    }
}

demo11——Zi

package day10.demo11;

import day10.demo10.Fu;

public class Zi extends Fu {
    public static void main(String[] args) {
        //创建Zi的对象，测试看有哪些方法可以使用
        Zi z = new Zi();
        z.show3();
        z.show4();
    }
}

demo11——Demo

package day10.demo11;

import day10.demo10.Fu;

public class Demo {
    public static void main(String[] args) {
        Fu f = new Fu();
        f.show4();
    }
}

2. 代码块

2.1 代码块概述

• 代码块是类的成分之一（成员变量、构造器、方法、代码块、内部类）
• 在Java类中，使用 { } 括起来的代码被称为代码块
• 代码块分为构造代码块和静态代码块

2.2 构造代码块

• 格式：

  {
       // 执行代码
  }
  

• 特点：

  • 无static修饰。属于对象，与对象的创建一起执行的。
  • 每次调用构造器初始化对象，实例代码块都要自动触发执行一次。
  • 实例代码块实际上是提取到每一个构造器中去执行的。（反编译的代码中，构造代码块中的内容在每个构造方法前面。）

• 使用场景：将多个构造方法中相同的代码，抽取到构造代码块中，提高代码的复用性。

• 示例代码：

  User

  public class User {
      {
          System.out.println("构造代码块1");
      }
  
      public User() {
          System.out.println("无参构造方法");
      }
  
      public User(int a) {
          System.out.println("带参构造方法");
      }
  
      {
          System.out.println("构造代码块2");
      }
  }
  

  Demo1

  public class Demo1 {
      public static void main(String[] args) {
          User u1 = new User();
          User u2 = new User(5);
      }
  }
  

2.3 静态代码块

• 格式：

  static {
  	// 执行代码
  }
  

• 特点：随着类的加载而自动触发执行，并且只会执行一次。

• 使用场景：在启动程序前，类的加载的时候，做一些静态数据初始化的操作，以便后续对象可以使用

2.4 静态代码块案例：斗地主游戏

2.4.1 需求：完成纸牌的初始化

在游戏开始前，程序会预先初始化54张牌，后续才能进行发牌和打牌。

2.4.2 分析

不管玩家玩了多少局，54张牌的数据是固定的，而且只需要一份，在游戏开始前54张牌就要准备好。

使用静态代码块完成纸牌的初始化。

1. 定义一个静态的ArrayList集合存储牌。（内存中只有一份）。
2. 使用静态代码块，初始化纸牌数据到ArrayList集合中。（只会执行一次）

2.4.3 代码实现

CardPlay

import java.util.ArrayList;

/*
    目标：使用静态代码块完成斗地主游戏纸牌的初始化

    花色：{"♠","♥","♣","♦"}
    牌号：{"2","A","K","Q","J","10","9","8","7","6","5","4","3"}
    大王、小王
 */
public class CardPlay {
    //创建ArrayList集合，存储54张牌（纸牌只需要一份，使用static修饰
    private static ArrayList<String> cardList = new ArrayList<>();

    static {
        cardList.add("大王");
        cardList.add("小王");

        String[] colors = {"♠","♥","♣","♦"};
        String[] numbers = {"2","A","K","Q","J","10","9","8","7","6","5","4","3"};

        //外循环：牌号numbers
        for (int i = 0; i < numbers.length; i++) {
            //内循环：花色colors
            for (int j = 0; j < colors.length; j++) {
                cardList.add(numbers[i] + colors[j]); //
            }
        }
        
        System.out.println(cardList);
    }
}

2.5 代码块练习

2.5.1 题目

分析如下程序，写出执行结果

public class BlockDemo {
	public static void main(String[] args) {
		Person p = new Person();
		p.sayHello();
		
		Person q = new Person();
		q.sayHello();
	}
}

class Person {
    static int eyeNum;
    int age;
    
    //非静态块
    {
        System.out.println("non-static block");
        age = 18;
    }
    
    //静态块
    static {
        System.out.println("static block");
        eyeNum = 2;
    }
    
    public Person() {
        System.out.println("构造方法");        
    }
    
    public void sayHello() {
        age++;
        eyeNum++;
        System.out.println("age：" + age);
        System.out.println("eyeNum：" + eyeNum);
    }
}

2.5.2 答案

static block

non-static block

构造方法

age：19

eyeNum：3

non-static block

构造方法

age：19

eyeNum：4