Java中的封装，static成员，代码块以及内部类。

一、封装

基本概念：封装，用最通俗的话就是，套上外壳，屏蔽细节。对程序而言，就是将程序的属性与实现细节进行隐藏，仅通过一些对外接口进行交互。

1.访问限定符

类可以将数据以及封装数据的方法结合在一起。
访问权限用来控制方法或者字段能否直接在类外使用。

2.包

基本概念：

1.为了更好的管理类，把多个类收集在一起成为一组，称为软件包。

2.包是对类、接口等的封装机制的体现，是一种对类或者接口等的很好的组织方式.

3.在同一个工程中允许存在相同名称的类，只要处在不同的包中即可.

(1)导入包中的类

（1）可以使用 import 语句来导入包。

import java.util.Date;
//这里就是 import 语句引用 java.util 包中的Data类
public class test {
    public static void main(String[] args) {
        Date date = new Date(); // 得到一个毫秒级别的时间戳
        System.out.println(date.getTime()); }
}

（2）可以使用import static导入包中静态的方法和字段。

import static java.lang.Math.*;
public class test {
    public static void main(String[] args) {
        double x = 30;
        double y = 40;
        double result = sqrt(pow(x, 2) + pow(y, 2)); 
        System.out.println(result);
    }
}

(2)自定义包

基本规则：

1.在文件的最上方加上一个 package 语句指定该代码在哪个包中.

2.包名需要尽量指定成唯一的名字, 通常会用公司的域名的颠倒形式(例如 com.baidu.deom1）

3.包名要和代码路径相匹配. 例如创建 com.baidu.demo1 的包, 那么会存在一个对应的路径 com/baidu/demo1 来存储代码.

4.如果一个类没有 package 语句, 则该类被放到一个默认包中.

简单教学：在IDEA中建立一个包。



在输入新的类名后

如图：自己定义的类就出现在src文件夹中

(3)用自定义包进行访问控制权限举例

代码1（对自定义包的定义）：

package MoYang.deom1;

public class book {
    private String cpu; // cpu
    private String memory; // 内存
	//注：这里的两个定义为private是私有，只可用于同一个包中的同一类。
	
    public String screen; // 屏幕
    String brand; // 品牌（此处默认为default）
    public book(String brand, String cpu, String memory, String screen) {
        this.brand = brand;
        this.cpu = cpu;
        this.memory = memory;
        this.screen = screen; }
}

代码2（对自定义包引用）：

import MoYang.deom1.book;
//这里要精确到包中的类，即定义的book类

public class test {
    public static void main(String[] args) {
        book p = new book("HW", "i7", "8G", "13*14");
        System.out.println(p.screen); //
        System.out.println(p.cpu); // 报错：cup是私有的，不允许被其他类访问 //
        System.out.println(p.brand); // 报错：brand是default，不允许被其他包中的类访问 
        }
}

二、static成员

在Java中，被static修饰的成员，称之为静态成员，也可以称为类成员，其不属于某个具体的对象，是所有对象所共享的。

1.static修饰成员变量

static修饰的成员变量，称为静态成员变量。
静态成员变量最大的特性：不属于某个具体的对象，是所有对象所共享的。

public class test {
        public String name;
        public String gender;
        public int age;
        public double score;
        public static String classRoom = "class1"; 
        // ...
        public static void main(String[] args) { 
            // 静态成员变量可以直接通过类名访问
            System.out.println(test.classRoom);
            
            test s1 = new test("Li leilei", "男", 18, 3.8);
            test s2 = new test("Han MeiMei", "女", 19, 4.0);
            test s3 = new test("Jim", "男", 18, 2.6);
            System.out.println(s1.classRoom);
            System.out.println(s2.classRoom);
            System.out.println(s3.classRoom);
        }
}

2.static修饰成员方法

**被static修饰的成员方法称为静态成员方法，是类的方法，不是某个对象所特有的。**静态成员一般是通过静态方法来访问的。

public class test {
        private static String classRoom = "class1";
// 一般都会将类中的成员变量设置为私有的，通过public公开的成员方法使用

    public static String getClassRoom(){
        return classRoom;
    }
        public static void main(String[] args) {
            // 静态成员变量可以直接通过类名访问
            System.out.println(test.getClassRoom());
    }
}

静态方法特性:

1. 不属于某个具体的对象，是类方法
2. 可以通过对象调用，也可以通过类名.静态方法名(…)方式调用，更推荐使用后者
3. 不能在静态方法中访问任何非静态成员变量

三、代码块

使用 {} 定义的一段代码称为代码块。
代码块形式:
普通代码块
构造块
静态块
同步代码块（后续补充）

1.普通代码块

public class Main{
public static void main(String[] args) { 
//直接使用{}定义，普通方法块 
	{ 
	int x = 10 ; 
	System.out.println("x1 = " +x); 
	}
	int x = 100 ; 
	System.out.println("x2 = " +x); 
	} 
}

这种方法不常用。

2.构造代码块

构造块：定义在类中的代码块(不加修饰符)。也叫：实例代码块。构造代码块一般用于初始化实例成员变量。

public class Student{ 
//实例成员变量
	private String name;
	private String gender;
	private int age;
	private double score;
	public Student() { 
		System.out.println("I am Student init()!"); 
		}
//实例代码块 
	{ 
		this.name = "bit";
		this.age = 12; 
		this.sex = "man";
			System.out.println("I am instance init()!"); 
	}
public void show(){ 
		System.out.println("name: "+name+" age: "+age+" sex: "+sex); 
	} 
}
public class Main {
	public static void main(String[] args) { 
			Student stu = new Student(); 
			stu.show(); 
		}
}

3.静态代码块

使用static定义的代码块称为静态代码块。一般用于初始化静态成员变量。

public class Student{
private String name;
private String gender;
private int age;
private double score;
private static String classRoom;

	//实例代码块 
	{ 
		this.name = "bit"; 
		this.age = 12;
		this.gender = "man"; 
		System.out.println("I am instance init()!"); 
	}

	// 静态代码块 
	static {
			classRoom = "class1"; 
			System.out.println("I am static init()!"); 
			}
	public static void main(String[] args) { 
		Student s1 = new Student(); 
		Student s2 = new Student(); 
	}
}

注:

1.静态代码块不管生成多少个对象，其只会执行一次

2.静态成员变量是类的属性，因此是在JVM加载类时开辟空间并初始化的

3.如果一个类中包含多个静态代码块，在编译代码时，编译器会按照定义的先后次序依次执行(合并)

4.实例代码块只有在创建对象时才会执行

四、内部类

内部类分为：实例内部类、静态内部类、局部内部类。

1.实例内部类

即未被static修饰的成员内部类。

//先创建一个类
public class OutClass {
	private int a; 
	static int b; 
	int c;
public void methodA(){ 
	a = 10; System.out.println(a); 
}
public static void methodB(){ 
	System.out.println(b); 
}

// 实例内部类：未被static修饰
class InnerClass{ 
	int c;
public void methodInner(){ 
// 在实例内部类中可以直接访问外部类中：任意访问限定符修饰的成员 
	a = 100; 
	b = 200;
	methodA();
	methodB(); // 如果外部类和实例内部类中具有相同名称成员时，优先访问的是内部类自己的 
	c = 300; 
	System.out.println(c); // 如果要访问外部类同名成员时候，必须：外部类名称.this.同名成员名字
	OutClass.this.c = 400; 
	System.out.println(OutClass.this.c); 
	}
}

public static void main(String[] args) { 
// 外部类：对象创建 以及 成员访问
	OutClass outClass = new OutClass(); 
	System.out.println(outClass.a); 
	System.out.println(OutClass.b); 
	System.out.println(outClass.c); 
	outClass.methodA(); 
	outClass.methodB();

// 要访问实例内部类中成员，必须要创建实例内部类的对象 
// 而普通内部类定义与外部类成员定义位置相同，因此创建实例内部类对象时必须借助外部类 
// 创建实例内部类对象
	OutClass.InnerClass innerClass1 = new OutClass().new InnerClass(); 
// 上述语法比较怪异，也可以先将外部类对象先创建出来，然后再创建实例内部类对象
	OutClass.InnerClass innerClass2 = outClass.new InnerClass();
	innerClass2.methodInner();

2.静态内部类

被static修饰的内部成员类称为静态内部类。

public class OutClass {
	private int a; 
	static int b;
public void methodA(){ 
	a = 10; 
	System.out.println(a); 
}
public static void methodB(){ 
	System.out.println(b); 
}

// 静态内部类：被static修饰的成员内部类 
static class InnerClass{
	public void methodInner(){ 
	// 在内部类中只能访问外部类的静态成员 
	// a = 100; // 编译失败，因为a不是静态类成员变量 
	b =200; 
	// methodA(); // 编译失败，因为methodA()不是静态成员方法
	methodB(); 
	}
}
	public static void main(String[] args) { 
	// 静态内部类对象创建 & 成员访问
		OutClass.InnerClass innerClass = new OutClass.InnerClass();
		innerClass.methodInner();
		} 
}

注:
1. 在静态内部类中只能访问外部类中的静态成员
2. 创建静态内部类对象时，不需要先创建外部类对象

3.局部内部类

定义在外部类的方法体或者{}中，该种内部类只能在其定义的位置使用

public class OutClass { 
	int a = 10;
public void method(){ 
	int b = 10; 
	// 局部内部类：定义在方法体内部 
	// 不能被public、static等访问限定符修饰
class InnerClass{
	public void methodInnerClass(){
	System.out.println(a); 
	System.out.println(b); 
		} 
	}
// 只能在该方法体内部使用，其他位置都不能用 
	InnerClass innerClass = new InnerClass(); 
	innerClass.methodInnerClass(); 
}
public static void main(String[] args) { 
	// OutClass.InnerClass innerClass = null; 编译失败 
	} 
}

注:

1. 局部内部类只能在所定义的方法体内部使用
2. 不能被public、static等修饰符修饰
3. 几乎不会使用