⭐方法（method）
就是我们曾经讲过的方法(类似C的函数).
用于描述一个对象的行为.
class Person { public int age = 18; public String name = "张三"; public void show() { System.out.println("我叫" + name + ", 今年" + age + "岁"); } } class Test { public static void main(String[] args) { Person person = new Person(); person.show(); } } // 执行结果 我叫张三, 今年18岁
此处的 show 方法, 表示 person 这个对象具有一个 “展示自我” 的行为.
这样的 show 方法是和 person 实例相关联的. 如果创建了其他实例, 那么 show 的行为就会发生变化
Person person2 = new Person(); person2.name = "李四"; person2.age = 20; person2.show() // 执行结果 我叫李四, 今年20岁
⭐static 关键字
1、修饰属性
2、修饰方法
3、代码块(本篇中会介绍)
4、修饰类(后面的内部类会讲到)
a) 修饰属性，Java静态属性和类相关, 和具体的实例无关. 换句话说, 同一个类的不同实例共用同一个静态属性.
class TestDemo{ public int a; public static int count; } public class Main{ public static void main(String[] args) { TestDemo t1 = new TestDemo(); t1.a++; TestDemo.count++; System.out.println(t1.a); System.out.println(TestDemo.count); System.out.println("============"); TestDemo t2 = new TestDemo(); t2.a++; TestDemo.count++; System.out.println(t2.a); System.out.println(TestDemo.count); } }
输出结果为：
1 1 ============ 1 2
示例代码内存解析：
count被static和public所修饰，所有类共享
且不属于对象，访问方式为：【类名 . 属性】
b) 修饰方法
如果在任何方法上应用 static 关键字，此方法称为静态方法。
静态方法属于类，而不属于类的对象。
可以直接调用静态方法，而无需创建类的实例。
静态方法可以访问静态数据成员，并可以更改静态数据成员的值。
class TestDemo{ public int a; public static int count; public static void change() { count = 100; //a = 10; error 不可以访问非静态数据成员 } } public class Main{ public static void main(String[] args) { TestDemo.change()；//无需创建实例对象 就可以调用 System.out.println(TestDemo.count); } }
输出结果：
100
注意事项1: 静态方法和实例无关, 而是和类相关. 因此这导致了两个情况:
- 静态方法不能直接使用非静态数据成员或调用非静态方法(非静态数据成员和方法都是和实例相关的).
- this和super两个关键字不能在静态上下文中使用(this 是当前实例的引用, super是当前实例父类实例的引用, 也是和当前实例相关).
注意事项2
- 我们曾经写的方法为了简单, 都统一加上了 static. 但实际上一个方法具体要不要带 static, 都需要是情形而定.
- main 方法为 static 方法.
⭐小结
观察以下代码, 分析内存布局.
class Person { public int age;//实例变量 存放在对象内 public String name;//实例变量 public String sex;//实例变量 public static int count;//类变量也叫静态变量，编译时已经产生，属于类本身，且只有一份。存放在方法区 public final int SIZE = 10;//被final修饰的叫常量，也属于对象。 被final修饰，后续不可更改 public static final int COUNT = 99;//静态的常量，属于类本身，只有一份 被final修饰，后续不可更改 //实例成员函数 public void eat() { int a = 10;//局部变量 System.out.println("eat()!"); } //实例成员函数 public void sleep() { System.out.println("sleep()!"); } //静态成员函数 public static void staticTest(){ //不能访问非静态成员 //sex = "man"; error System.out.println("StaticTest()"); } } public class Main{ public static void main(String[] args) { //产生对象 实例化对象 Person person = new Person();//person为对象的引用 System.out.println(person.age);//默认值为0 System.out.println(person.name);//默认值为null //System.out.println(person.count);//会有警告! //正确访问方式： System.out.println(Person.count); System.out.println(Person.COUNT); Person.staticTest(); //总结：所有被static所修饰的方法或者属性，全部不依赖于对象。 person.eat(); person.sleep(); } }
输出结果为：
0 null 0 99 StaticTest() eat()! sleep()!
数据属性的内存布局：
🗽封装
⭐private 实现封装
private/ public 这两个关键字表示 “访问权限控制” .
- 被
public修饰的成员变量或者成员方法, 可以直接被类的调用者使用.- 被
private修饰的成员变量或者成员方法, 不能被类的调用者使用.换句话说, 类的使用者根本不需要知道, 也不需要关注一个类都有哪些
private的成员. 从而让类调用者以更低的成本来使用类.
直接使用 public
class Person { public String name = "张三"; public int age = 18; } class Test { public static void main(String[] args) { Person person = new Person(); System.out.println("我叫" + person.name + ", 今年" + person.age + "岁"); } } // 执行结果 我叫张三, 今年18岁
- 这样的代码导致类的使用者(main方法的代码)必须要了解 Person 类内部的实现, 才能够使用这个类. 学习成本较高
- 一旦类的实现者修改了代码(例如把 name 改成 myName), 那么类的使用者就需要大规模的修改自己的代码, 维护成本较高.
范例：使用 private 封装属性, 并提供 public 方法供类的调用者使用.
class Person { private String name = "张三"; private int age = 18; public void show() { System.out.println("我叫" + name + ", 今年" + age + "岁"); } } class Test { public static void main(String[] args) { Person person = new Person(); person.show(); } } // 执行结果 我叫张三, 今年18岁
此时字段已经使用 private 来修饰. 类的调用者(main方法中)不能直接使用. 而需要借助 show 方法. 此时类的使用者就不必了解 Person 类的实现细节.
同时如果类的实现者修改了字段的名字, 类的调用者不需要做出任何修改(这时候类的调用者根本访问不到 name, age这样的字段).
注意事项
private 不光能修饰字段, 也能修饰方法
通常情况下我们会把字段设为 private 属性, 但是方法是否需要设为 public, 就需要视具体情形而定. 一般我们希望一个类只提供 “必要的” public 方法, 而不应该是把所有的方法都无脑设为 public.
