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();}
}