全部章节 >>>>
本章目录
2.1 成员变量
在类体中定义的变量为成员变量，作用范围是整个类，只要在这个类中都可以访问到它。
成员变量包括实例属性了类属性。
类属性从类被加载开始存在，直到系统完全销毁该类，类属性的作用域与该类的生命周期相同。
实例属性则从类的实例被创建起开始存在，直到系统销毁该实例，实例属性的作用域与其对应的实例的生命周期相同。
2.1.1 成员变量与局部变量的区别
在类中的位置不同：
成员变量：在类中方法外面。
局部变量：在方法或者代码块中，或者方法的声明上（即在参数列表中）。
在内存中的位置不同：
成员变量：在堆中（方法区中的静态区）。
局部变量：在栈中。
生命周期不同：
成员变量：随着对象的创建而存在，随着对象的消失而消失。
局部变量：随着方法的调用或者代码块的执行而存在，随着方法的调用完毕或者代码块的执行完毕而消失。
初始值：
成员变量：有默认初始值。
局部变量：没有默认初始值，使用之前需要赋值，否则编译器会报错。
2.1.2 成员变量的使用
示例：测试英雄对象中成员属性的赋值和引用
public class Hero {
String name;//英雄名字
int age;//英雄年龄
public static void main(String[] args){
//创建英雄对象hero1
Hero hero1 = new Hero();
hero1.name="德鲁伊"; //为hero1的实例属性name赋值
hero1.age=45;
//创建英雄对象hero2
Hero hero2 = new Hero();
System.out.println("英雄hero1的名字:"+hero1.name
+"\t"+"年龄:"+hero1.age);
System.out.println("英雄hero2的名字:"+hero2.name
+"\t"+"年龄:"+hero2.age);
}
}
实例属性内存分配示意图
2.1.3 实践练习
2.2 this关键字
1、this关键字代表自身
2、this关键字主要用途
- 用this代表自身类的对象（直接使用this、使用this引用成员变量、使用this调用成员方法）。
- 用this在自身的构造方法内部调用其他的构造方法。
2.2.1 使用this关键字引用成员变量和成员方法
示例：测试在方法中使用this关键字引用成员变量和成员方法
public class Hero {
public void jump(){
System.out.println("---英雄遇到了障碍需要跳过去---");
}
public void run(){
System.out.println("---执行run方法英雄正在奔跑---");
Hero hero = new Hero();//创建Hero对象
System.out.println("her对象已经被创建内存地址
为:"+hero.hashCode()+",它将实行jump方法");
hero.jump();//调用run()方法
}
}
public class TestHero {
public static void main(String[] args){
Hero hero = new Hero();//创建Hero对象
System.out.println("hero对象已经被创建内存地址
为:"+hero.hashCode()+",它将实行run方法");
hero.run();//调用run()方法
}
}
2.2.2 解决实例变量与局部变量同名的问题
示例：实例变量与句变量同名（实例变量前没有this）
public class Hero {
String name;
public void setName(String name){
name=name; //此处易混淆，可读性差
}
public static void main(String[] args){
Hero hero=new Hero();
hero.setName("风暴精灵");
System.out.println("hero的名字为:"+hero.name);
}
}
分析：当方法中的局部变量与实例变量同名时，在方法中如果不使用this前缀调用实例变量，则在方法中默认调用方法中的局部变量（形参也是局部变量）。
示例：实例变量与句变量同名（实例变量前有this）
public class Hero {
String name;
public void setName(String name){
this.name=name;
}
public static void main(String[] args){
Hero hero=new Hero();
hero.setName("风暴精灵");
System.out.println("hero的名字为:"+hero.name);
}
}
2.2.3 实践练习
2.3 隐藏和封装
现实生活中的封装
隐藏内部实现细节，封装系统（部件、组件）功能
2.3.1 封装
封装是面向对象的三大特性之一。
封装将对象的状态信息隐藏在对象内部，不允许外部程序直接访问对象内部信息，而是通过该类所提供的方法实现对内部信息的操作和访问。
封装是面向对像编程语言对客观世界的模拟，客观世界中的属性均被隐藏在对象内部，外界无法直接操作和修改。
一个良好的封装可以实现以下目的：
隐藏类的实现细节。
让使用者只能通过事先预定的方法访问数据，从而可以在该方法中加入控制逻辑，限制对属性的不合理访问。
可进行数据检查，从而有利于保证对象信息的完整性。
便于修改，提高代码的可维护性。
实现良好封装的途径：
隐藏对象的属性和实现细节，不允许外部直接访问。
暴露出方法，让方法控制对这些属性进行安全的访问和操作。
封装实际上有两个方面的含义：隐藏该隐藏的，暴露该暴露的。
Java封装的实质：使用访问控制符private隐藏属性，以及public暴露方法。
示例：利用封装隐藏英雄属性以及暴露属性赋值和更新的方法
public class Hero {
//使用private修饰属性，隐藏这些属性
private String name;
private int age;
//public方法公开对name属性赋值
public void setName(String name) {
//执行合理校验，要求用户名必须在2～6之间
if(name.length()>6||name.length()<2){
System.out.println("您输入的名字不符合要求");
return;
}else{
this.name = name;
}
}
//public方法公开对name属性取值
public String getName() {
return name;
}
......
}
2.3.2 Java访问控制符
Java通过修饰符来控制类、属性和方法的访问权限和其他功能，通常放在语句的最前端。
Java支持四种不同的访问权限。
访问控制级别图：
Java访问控制级别表：
| 访问修饰符 |
同一个类中 |
同一个包中 |
子类中 |
所有类中 |
| private |
√ |
— |
— |
— |
| default |
√ |
√ |
— |
— |
| protected |
√ |
√ |
√ |
— |
| public |
√ |
√ |
√ |
√ |
示例：private访问控制符修饰的属性在同一个类中可以访问
public class Person{
private String name="李彦宏";
public static void main(String args[]){
Person person = new Person();
//同一类中可以访问所有属性
System.out.println("姓名是:"+person.name);
}
}
示例：default访问控制符修饰的属性在同一个包中可以访问
package com.vo;
public class Person{
//默认修饰符为default
String name="李彦宏";
}
public class Test{
public static void main(String args[]){
Person person = new Person();
//访问default修饰的属性
System.out.println(person.name);
}
}
示例：default访问控制符修饰的属性在同一个包中可以访问
package com.vo;
public class Person{
//默认修饰符为default
String name="李彦宏";
}
public class Test{
public static void main(String args[]){
Person person = new Person();
//访问default修饰的属性
System.out.println(person.name);
}
}
示例：public访问控制符修饰的属性能够被不同包中的类访问
package com.vo;
public class Person{
//public为公有访问修饰符
public String name="李彦宏";
}
package com.test;
public class Test{
public static void main(String args[]){
Person person = new Person();
//被public修饰的属性在任何位置均可访问
System.out.println(person.name);
}
}
2.3.3 实践练习
2.4 static关键字
- Java类的运行包括类加载和实例化两个阶段。
- 当一个类被加载至 JVM 中，静态成员会被初始化。
- 静态成员不属于某个对象，仅属于静态成员所在的类。
被 static 修饰的成员即为静态成员。
静态代码块
静态属性
静态方法
2.4.1 静态成员变量
静态成员变量属于其所在类，被类中的所有实例共享。
静态成员变量可通过类直接访问，也可通过类的实例访问。
示例：模拟个人银行账户取款10次
public class Bank {
//静态成员变量，账户余额
private static int count = 50000 ;
public static void main(String[] args) {
//实例化10个Bank对象
for(int i=0; i<10; i++){
Bank bank=new Bank();
//每次取款1000元，类的实例调用静态成员属性
bank.count = bank.count - 1000;
//Bank.count=Bank.count-1000; //通过类名之间访问静态成员
System.out.println("当前银行总钱数="+Bank.count);
}
}。
}
所有的静态成员变量都可以通过类名直接访问。
2.4.2 静态方法
- 被static修饰的方法称为静态方法。
- 静态方法也可通过类名直接访问，也可通过对象名访问。
- 静态方法中不能访问非静态的成员，如实例属性、实例方法。
- 静态方法通常作为工具方法，因为静态方法不会因为实例的不同，而影响方法最终的执行效果。
示例：定义一个计算平方的静态方法
public class MathUtils {
//计算平方
public static double square(double num){
return num*num;
}
public static void main(String[] args){
double num=9.6;
double result=MathUtils.square(num);
System.out.println(num+"的平方="+result);
}
}
为什么静态方法不能访问非静态成员？
Java程序运行时首先由JVM加载类。
类加载时会为静态的成员开辟内存空间，而实例成员在类的实例化 阶段才被创建，所以当类加载时静态的成员已经被创建，而此时并不存在实例成员，因此不能在静态方法中访问非静态成员。
但是实例方法可以访问静态成员。
2.4.3 静态代码块
- 如果需要在类加载时执行某一操作，则可以使用静态代码块。
- 静态代码不存在任何方法体中，它在Java虚拟机加载类时执行。
- 如果类中包含多个静态代码块，则Java虚拟机将按照它们在类中出现的顺序依次执行。
- 静态代码块只会被执行一次。
为什么需要静态代码块？什么场合需要用到静态代码块？
静态方法在类加载后，虽然在内存中已经分配了内存空间，但只有显式地调用静态方法时，该方法才会被执行。如果需要在类加载时执行某一操作，则可以使用静态代码块
示例：静态代码块程序演示
public class StaticBlock {
//第一个静态代码块
static{
System.out.println("---第一个静态代码块---");
}
//第二个静态代码块
static{
System.out.println("---第二个静态代码块---");
}
//第三个静态代码块
static{
System.out.println("---第三个静态代码块---");
}
public static void main(String[] args){
System.out.println("---main方法被执行了---");
}
}
虽然main()方法是程序的入口方法，但该方法是在类加载完成后，由JVM虚拟机调用该方法。
而静态代码块是在类加载时就执行。
加载完静态代码块后，才执行main()方法。
2.4.4 实践练习
总结：
- 变量可以分为成员变量和局部变量，成员变量是在类范围定义的变量，局部变量是在方法中定义的变量。
- 成员变量分为类属性和实例属性两种，定义属性时没有static修饰符修饰的就是实例属性。类属性的作用域与该类的生命周期相同，例属性的作用域与其对应的实例的生命周期相同。
- this关键字代表自身。
- 封装将对象的状态信息隐藏在对象内部，不允许外部程序直接访问对象内部信息，而是通过该类所提供的方法实现对内部信息的操作和访问。
- Java访问控制符可见性范围由小到大为：private->default->protected->public。
- 静态成员变量属于其所在类，被类中的所有实例共享，静态成员变量可通过类直接访问，也可通过类的实例访问。静态方法不能访问非静态的成员。