详细介绍：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 staticvoid 方法名(){…}
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();
}
}
浙公网安备 33010602011771号