Java入门——类和对象（下）

墨子裳

于 2024-05-11 10:00:00 发布

阅读量1.1k

点赞数 29

文章标签： java 开发语言

本文链接：https://blog.csdn.net/Lucas_Micheal/article/details/138681379

版权

封装

软件开发的本质就是对程序复杂程度的管理. 如果一个软件代码复杂程度太高, 那么就无法继续维护. 如何管理复杂程度? 封装就是最基本的方法.

在我们写代码的时候经常会涉及两种角色: 类的实现者和类的调用者.

封装的本质就是让类的调用者不必太多的了解类的实现者是如何实现类的, 只要知道如何使用类就行了.这样就降低了类使用者的学习和使用成本, 从而降低了复杂程度.

private实现封装

private/ public 这两个关键字表示 "访问权限控制" .

被 public 修饰的成员变量或者成员方法, 可以直接被类的调用者使用.
被 private 修饰的成员变量或者成员方法, 不能被类的调用者使用.

换句话说, 类的使用者根本不需要知道, 也不需要关注一个类都有哪些 private 的成员. 从而让类调用者以更低的成本来使用类.

直接使用 public

class Person {    
public String name = "张三";    
public int 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 + "岁");     
} 
}

此时字段已经使用 private 来修饰. 类的调用者(main方法中)不能直接使用. 而需要借助 show 方法. 此时类的使用者就不必了解 Person 类的实现细节.
同时如果类的实现者修改了字段的名字, 类的调用者不需要做出任何修改(类的调用者根本访问不到 name, age这样的字段).

getter和setter方法

当我们使用 private 来修饰字段的时候, 就无法直接使用这个字段了.

// 编译出错

Test.java:13: 错误: age可以在Person中访问private person.age = 20;

此时如果需要获取或者修改这个 private 属性, 就需要使用 getter / setter 方法.

class Person {    
private String name;//实例成员变量  
private  int age;   
public void setName(String name){         
//name = name;//不能这样写   
this.name = name;//this引用，表示调用该方法的对象  
}  
public String getName(){   
return name;  
}   
public void show(){   
System.out.println("name: "+name+" age: "+age);  
} 
}

getName 即为 getter 方法, 表示获取这个成员的值.
setName 即为 setter 方法, 表示设置这个成员的值.
当set方法的形参名字和类中的成员属性的名字一样的时候，如果不使用this, 相当于自赋值. this 表示当前实例的引用.
不是所有的字段都一定要提供 setter / getter 方法, 而是要根据实际情况决定提供哪种方法.
在 IDEA 中可以使用 alt + insert (或者 alt + F12) 快速生成 setter / getter 方法. 在 VSCode 中可以使用鼠标右键菜单 -> 源代码操作中自动生成 setter / getter 方法.

构造方法

基本语法

构造方法是一种特殊方法, 使用关键字new实例化新对象时会被自动调用, 用于完成初始化操作.

new 执行过程

为对象分配内存空间

调用对象的构造方法

语法规则

1.方法名称必须与类名称相同

2.构造方法没有返回值类型声明

3.每一个类中一定至少存在一个构造方法（没有明确定义，则系统自动生成一个无参构造）

注意事项

如果类中没有提供任何的构造函数，那么编译器会默认生成一个不带有参数的构造函数

若类中定义了构造方法，则默认的无参构造将不再生成.

构造方法支持重载. 规则和普通方法的重载一致.

class Person {          
private String name;//实例成员变量     
private  int age;     
private String sex;     //默认构造函数    构造对象      
public Person() {           
this.name = "caocao";         
this.age = 10;         
this.sex = "男";     
}     //带有3个参数的构造函数     
public Person(String name,int age,String sex) {         
this.name = name;         
this.age = age;         
this.sex = sex; 
}
public void show(){
System.out.println("name: "+name+" age: "+age+" sex: "+sex);     
}     
} 
public class Main{      
public static void main(String[] args) {         
Person p1 = new Person();//调用不带参数的构造函数  如果程序没有提供会调用不带参数的构造函数         
p1.show();         
Person p2 = new Person("zhangfei",80,"男");//调用带有3个参数的构造函数         p2.show();     } }

this关键字

this表示当前对象引用(注意不是当前对象). 可以借助 this 来访问对象的字段和方法.

在上面的代码中，我们会发现在构造函数的内部，我们可以使用this关键字，构造函数是用来构造对象的，对象还没有构造好，我们就使用了this，那this还代表当前对象吗？当然不是，this代表的是当前对象的引用。

认识代码块

什么是代码块

使用{}定义的一段代码.

根据代码块定义的位置以及关键字，又可分为以下四种：

普通代码块
构造块
静态块
同步代码块

普通代码块

普通代码块：定义在方法中的代码块.

public class Main{  
public static void main(String[] args) {   
{ //直接使用{}定义，普通方法块    
int x = 10 ;    
System.out.println("x1 = " +x);   
}   
int x = 100 ;   
System.out.println("x2 = " +x);  
} 
}

构造代码块

构造块：定义在类中的代码块(不加修饰符)。也叫：实例代码块。构造代码块一般用于初始化实例成员变量。

class Person{   
private String name;//实例成员变量  
private  int age;  private String sex;        
public Person() {   System.out.println("I am Person init()!");  }       
//实例代码块  {   
this.name = "bit";   this.age = 12;   this.sex = "man";         System.out.println("I am instance init()!");  
}   
public void show(){
System.out.println("name: "+name+" age: "+age+" sex: "+sex);  
}  
}

实例代码块优先于构造函数执行。

静态代码块

使用static定义的代码块。一般用于初始化静态成员属性。

class Person{ 
private String name;//实例成员变量  
private  int age;  
private String sex;  
private static int count = 0;//静态成员变量    由类共享数据  方法区   
public Person(){   System.out.println("I am Person init()!");  }       
//实例代码块  
{   
this.name = "bit";   
this.age = 12;   
this.sex = "man";         
System.out.println("I am instance init()!");  
}       
//静态代码块 
 static {   
count = 10;//只能访问静态数据成员          
System.out.println("I am static init()!");  
public void show(){   
System.out.println("name: "+name+" age: "+age+" sex: "+sex);  
}  
}

静态代码块不管生成多少个对象，其只会执行一次，且是最先执行的。
静态代码块执行完毕后, 实例代码块（构造块）执行，再然后是构造函数执行。

toString方法

我们刚刚注意到，我们在把对象的属性进行打印的时候，都自己实现了show函数，其实，我们大可不必。接下来我们看一些示例代码：

class Person {     
private String name;     
private int age;     
public Person(String name,int age) {         
this.age = age;         
this.name = name;     
}     
public void show() {         
System.out.println("name:"+name+" " + "age:"+age);     
}     
//重写Object的toString方法     
@Override     
public String toString() {         
return "Person{" +                 "name='" + name + '\'' +                 ", age=" + age +                 '}';     
} 
}

toString 方法会在 println 的时候被自动调用.
将对象转成字符串这样的操作我们称为序列化.
toString 是 Object 类提供的方法, 我们自己创建的 Person 类默认继承自 Object 类, 可以重写 toString 方法实现我们自己版本的转换字符串方法.
@Override 在 Java 中称为 "注解", 此处的 @Override 表示下面实现的 toString 方法是重写了父类的方法.
IDEA快速生成Object的toString方法快捷键：alt+f12(insert)