Java学习笔记三（封装）

封装概念：将数据封装在对象中，合理隐藏(private)，合理暴露(public)

1 关键字

1.1 this关键字

注释：this代表当前对象

(1) 类调用自身属性方法：this

构造器：this(参数,…)

变量：this.变量名

方法：this.方法名()

public class Test {
    private String str = "abc";
    private void fun() {
    }
    public void doTest() {
        Test t = this();     // 构造器
        String s = this.str; // 变量
        this.fun();          // 调用方法
    }
}

(2) 其它类调用当前类属性方法：实例对象

对象 = new 类(参数,…);

对象.变量名

对象.方法名()

public class Test1 {
    public String str = "abc";
    public void fun1() {
    }
}

class Test2 {
    Test1 t = new Test1(); // 外部实例化对象
    String s = t.str;      // 外部获取成员变量
    t.fun();               // 外部调用函数
}

1.2 static关键字

(1) 静态变量（类变量）：

定义：public static 类型 变量名; 

public class Test1 {
    public static String str;
}

调用：类名.变量名; // 所有对象调用类变量共用一个值

public class Test2 {
    public void fn() {
        Test1.str;
    }
}

注释：成员内部类的静态属性（Jdk16支持）public class out { class in { 静态属性 } } 

public class Out {
	class In {
		public static String Str = "abc";
	}
}

String s = Out.In.Str;

(2) 静态方法（类方法）：

注释：静态方法不能直接使用本类实例属性方法(或this关键字)（必须实例化后调用），实例方法(或this关键字)可以直接使用本类静态方法（不是必须用类名调用）

定义：public static void 方法名(){…}

public class Test1 {
    public static void fn() {...}
}

调用：类名.方法名();

public class Test2 {
    public void fn() {
        Test1.fn();
    }
}

(3) 静态代码块：static { …  }

静态代码块在类加载时调用

public class Test {
    static {
        ...
    }
}

(4) 静态内部类：

定义：public class Out { public static class in { 静态属性…  } }   // 类似静态方法

public class Out { 
    public static class In {
        public static String STR = "abc";
    } 
} 

调用：主类.内部类 变量名 = new 主类.内部类();

Out.In in = new Out.In();

1.3 final关键字

注释：一般用 【public static final 类型 常量名 = 常量值;】 修饰常量

(1) final类：public final class 类名{…} // final修饰的类，不可被继承

(2) final属性：private final 类型 变量名; // final修饰的属性，基本类型(值不可变)，引用类型(地址不可变,属性可变)

(3) final方法：public final void 方法名(){…} // fianl修饰的方法，不可被重写

(4) final参数：public void 方法名(final String str, final 类型 obj) // 方法内部基本类型(值不可变)，引用类型(地址不可变,属性可变)

2 访问权限修饰符

2.1 类（访问权限修饰符）

(1) 默认类：class 类名 {... }   // 类同包类可对其引用

package java.main;
class Test {
    ...
}

java.main.Call // 同包类可引用（import, extends）Test

java.log.Log // 不同包不可引用（import, extends）Test

(2) 公开类：public class 类名 {...}  // 所有的类都可对其引用

package java.main;
public class Test {
    ...
}

java.main.Call // 同包类可引用（import, extends）Test

java.log.Log // 不同包可引用（import, extends）Test

(3) 同文件类：public class 类名 { … } class 类2{..}

同一个文件可以定义多个类，但只有一个可以用public修饰

public class Test1 {
}
class Test2{
}

2.2 [非静态]成员（访问权限修饰符）

私有（private），默认，保护（protected），公开（public）

注释：成员变量，成员方法

(1) 私有：private 类型 变量名; private 返回值 方法名(){…} // 当前类内部，自己可访问

可：java.main.Test // 类内部可使用私有变量与方法

否：java.main.Call // 同包类创建的Test对象，无法使用Test的私有属性与方法

否：java.sub.Sub(extends Test) // 子类内部及new的子类对象，无法使用Test的私有属性与方法

否：java.log.Log // 不同包类创建的Test对象，无法使用Test的私有属性与方法

(2) 默认：类型 变量名; 返回值 方法名(){…} // 同包的类可访问

可：java.main.Test // 类内部可使用默认变量与方法

可：java.main.Call // 同包类创建的Test对象，可使用Test的默认属性与方法

否：java.sub.Sub(extends Test) // 子类内部及new的子类对象，无法使用Test的默认属性与方法

否：java.log.Log // 不同包类创建的Test对象，无法使用Test的默认属性与方法

(3) 保护：protected 类型 变量名; protected 返回值 方法名(){…} // 同包类及子类可访问

可：java.main.Test // 类内部可使用保护变量与方法

可：java.main.Call // 同包类创建的Test对象，可使用Test的保护属性与方法

可：java.sub.Sub(extends Test) // 子类内部及new的子类对象，可使用Test的保护属性与方法

否：java.log.Log // 不同包类创建的Test对象，无法使用Test的保护属性与方法

(4) 公开：public 类型 变量名; public 返回值 方法名(){…} // 所有类可访问

可：java.main.Test // 类内部可使用公开变量与方法

可：java.main.Call // 同包类创建的Test对象，可使用Test的公开属性与方法

可：java.sub.Sub(extends Test) // 子类内部及new的子类对象，可使用Test的公开属性与方法

可：java.log.Log // 不同包类创建的Test对象，可使用Test的公开属性与方法

package main.java;
public class Test {
	private String str1; //私有
	String str2;         //默认
	protected String str3;// 保护
	public String str4;    //公开
	
	private void fn1() {} //私有
	void fn2() {}         //默认
	protected void fn3() {}// 保护
	public void fn4() {}   //公开

	// 类内部可以直接使用（私有，默认，包含，公开）变量与方法
	public void doTest1() {
		String s1 = this.str1;
		String s2 = this.str2;
		String s3 = this.str3;
		String s4 = this.str4;
		
		this.fn1();
		this.fn2();
		this.fn3();
		this.fn4();
	}
    // 类内部new出的类对象，可以调用对象的（私有，默认，包含，公开）变量与方法
	public void doTest2() {
		Test t = new Test();
		String s1 = t.str1;
		String s2 = t.str2;
		String s3 = t.str3;
		String s4 = t.str4;
		
		t.fn1();
		t.fn2();
		t.fn3();
		t.fn4();
	}
}

package main.java;
// 同包类new出的Test对象可以调用Test的（默认，保护，公开）变量与方法
public class Test2 {
    public void fn() {
    	Test t = new Test();
    	String s2 = t.str2;
    	String s3 = t.str3;
    	String s4 = t.str4;
    	
    	t.fn2();
    	t.fn3();
    	t.fn4();
    }
}

package main.log;

import main.java.Test;

public class SubTest extends Test {
    // Test子类可以使用 继承来的 Test（保护，公开）属性与方法
    public void subFn1() {
    	String t3 = str3;
    	String t4 = str4;
    	fn3();
    	fn4();
    }
    // Test的子类new出的子类可以调用 继承来的Test（保护，公开）属性与方法
    public void subFn3() {
    	SubTest st = new SubTest();
    	String t3 = st.str3;
    	String t4 = st.str4;
    	st.fn3();
    	st.fn4();
    }
    // Test的子类new出的Test类，只可以调用 Test（公开）属性与方法
    public void subFn2() {
    	Test t = new Test();
    	String s4 = t.str4;
    	t.fn4();
    }
}

package main.log;

import main.java.Test;

public class Log {
    // 不同包的类new出的Test对象，只能调用Test（公开）属性与方法
	public void fn() {
    	Test t = new Test();
    	String s4 = t.str4;
    	t.fn4();
	}
}

2.3 [静态]成员（访问权限修饰符）

私有（private），默认，保护（protected），公开（public）

package main.java;

public class Test {
	private static String str1; //私有
	static String str2;         //默认
	protected static String str3;// 保护
	public static String str4;    //公开
	
	private static void fn1() {} //私有
	static void fn2() {}         //默认
	protected static void fn3() {}// 保护
	public static void fn4() {}   //公开
	
    // Test可以使用 Test自身的（私有，默认，保护，公开）静态属性与方法
	public void doTest1() {
		String s1 = Test.str1;
		String s2 = Test.str2;
		String s3 = Test.str3;
		String s4 = Test.str4;
		
		Test.fn1();
		Test.fn2();
		Test.fn3();
		Test.fn4();
	}
}

package main.java;

public class Test2 {
    // 同包的类，可以使用Test（默认，保护，公开）静态属性与方法
    public void fn() {
    	String s2 = Test.str2;
    	String s3 = Test.str3;
    	String s4 = Test.str4;
    	
    	Test.fn2();
    	Test.fn3();
    	Test.fn4();
    }
}

package main.log;

import main.java.Test;

public class SubTest extends Test {
    // 子类可以使用Test的（保护，公开）静态属性与方法
    public void subFn1() {
    	String t3 = Test.str3;
    	String t4 = Test.str4;
    	Test.fn3();
    	Test.fn4();
    }
    // 子类可以使用自身继承来的，Test的（保护，公开）静态属性与方法
    public void subFn2() {
    	String t3 = SubTest.str3;
    	String t4 = SubTest.str4;
    	SubTest.fn3();
    	SubTest.fn4();
    }
}

package main.log;

import main.java.Test;

public class Log {
    // 不同包的类，只能使用Test（公开）静态属性与方法
	public void fn() {
    	String s4 = Test.str4;
    	Test.fn4();
	}
}