![博主头像](https://img-blog.csdnimg.cn/direct/8aa6349c59b044908b91dce0c5afcfcd.jpeg)
🌠个人主页 : @赶路人- -
🌌个人格言 :要努力成为梧桐,让喜鹊在这里栖息。
要努力成为大海,让百川在这里聚积。
1.封装
什么是封装?
封装(Encapsulation)是面向对象编程中的一种基本概念,指的是将对象的内部状态和行为封装起来,对外只暴露必要的接口或方法,以保证数据的安全性和完整性,同时隐藏实现细节,方便后续的维护和扩展。
在Java中,封装通常通过使用访问修饰符(Access Modifiers)来实现。Java中有三种访问修饰符:public、protected和private。它们用于控制类、属性和方法的可见性和访问权限。
public: 公共的,可以被任何类访问;
protected:受保护的,可以被同一包内的类和该类的子类访问;
private:私有的,只能被该类的内部方法访问。
通过合理地使用访问修饰符,我们可以将类的实现细节隐藏起来,避免外部代码直接访问和修改对象的内部状态,从而提高了代码的安全性和稳定性。
此外,Java还提供了封装的另一种实现方式,即getter和setter方法。getter方法用于获取属性的值,setter方法用于设置属性的值。通过这种方式,我们可以控制属性的读写操作,同时可以在读写属性时添加一些额外的逻辑或验证。
1.1private实现封装
直接使用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 方法供类的调用者使用.
lass Person {
private String name = "李四";
private int age = 20;
public void show() {
System.out.println("我叫" + name + ", 今年" + age + "岁");
}
}
class Test {
public static void main(String[] args) {
Person person = new Person();
person.show();
}
}
执行结果
我叫李四, 今年20岁
- 此时字段已经使用 private 来修饰. 类的调用者(main方法中)不能直接使用. 而需要借助 show 方法. 此时类的使用者就不必了解 Person 类的实现细节.
- 同时如果类的实现者修改了字段的名字, 类的调用者不需要做出任何修改(类的调用者根本访问不到name, age 这样的字段).
那么问题来了~~ 类的实现者万一修改了 public 方法 show 的名字, 岂不是类的调用者仍然需要大量修改代码嘛?
这件事情确实如此, 但是一般很少会发生. 一般类的设计都要求类提供的 public 方法能比较稳定, 不应该频繁发生大的改变. 尤其是对于一些基础库中的类, 更是如此. 每次接口的变动都要仔细考虑兼容性问题.
!
- private 不光能修饰字段, 也能修饰方法
- 通常情况下我们会把字段设为 private 属性, 但是方法是否需要设为 public,就需要视具体情形而定. 一般我们希 望一个类只提供 “必要的” public 方法, 而不应该是把所有的方法都无脑设为 public.
1.2getter和setter方法
当我们使用 private 来修饰字段的时候, 就无法直接使用这个字段了。(详细可查看上面的访问修饰符修饰范围)
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.age = 20;
person.show();
}
}
// 编译出错
//Test.java:13: 错误: age可以在Person中访问private
// person.age = 20;
// ^
//1 个错误
此时如果需要获取或者修改这个 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);
}
}
public static void main(String[] args){
person person = new Person();
person.setName("haoyang");
String name = person.getName();
System.out.println(name);
person.show();
}
运行结果:
haoyang
name:haoyang age:0
!
- getName即为getter方法,表示获取这个成员的值。
- setName即为setter方法,表示设置这个成员的值。
- 当set方法的形参名字和类中的成员属性的名字一样的时候,如果不使用this,相当与自赋值。this表示当前实例的引用。
- 不是所用的字段都一定提供setter/getter方法,而是要根据实际情况决定提供那种方法。
- 在IDEA中可以使用alt + insert(或者 alt + F12)快速生成 setter / getter 方法。在VSCode中可以使用鼠标右键 菜单-> 源代码操作 中自动生成setter / getter方法。
2.构造方法
构造方法是一种特殊方法, 使用关键字new实例化新对象时会被自动调用, 用于完成初始化操作.
new 执行过程
- 为对象分配内存空间
- 调用对象的构造方法
2.1基本语法
语法规则
- 方法名称必须与类名称相同
- 构造方法没有返回值类型声明
- 每一个类中一定至少存在一个构造方法(没有明确定义,则系统自动生成一个无参构造)
! - 如果类中没有提供任何的构造函数,那么编译器会默认生成一个不带有参数的构造函数。
- 若类中定义了构造方法,则默认的无参构造将不再生成。(救急不救穷)
- 构造方法支持重载. 规则和普通方法的重载一致。
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();
}
}
执行结果
name: caocao age: 10 sex: 男
name: zhangfei age: 80 sex:男
2.2this关键字
this:表示当前对象引用(注意不是当前对象,因为使用this时对象还没生成). 可以借助 this 来访问对象的字段和方法。
class Person {
private String name;//实例成员变量
private int age;
private String sex;
//默认构造函数 构造对象
public Person() {
//this调用构造函数
this("abc", 18, "max");//调用构造函数,必须放在第一行进行显示
}
//这两个构造函数之间的关系为重载。
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 person = new Person();//调用不带参数的构造函数
person.show();
}
}
输出结果:
name: abc age: 18 sex: max
可以发现在构造函数的内部,就可以使用this关键字,构造函数是用来构造对象的,对象还没有构造好,就已经使用了this,那this还代表当前对象吗?当然不是,this代表的是当前对象的引用.
3.代码块
字段的初始化方式有:
- 就地初始化
- 使用构造方法初始化
- 使用代码块初始化
前两种方式前面篇幅已经见过了, 接下来介绍第三种方式, 使用代码块初始化
3.1什么是代码块
使用 {} 定义的一段代码.
根据代码块定义的位置以及关键字,又可分为以下四种:
- 普通代码块
- 构造块
- 静态块
- 同步代码块
3.2普通代码块
普通代码块:定义在方法中的代码块
public class Main{
public static void main(String[] args){
{//直接使用{}定义,普通代码块
int x = 1;
System.out.println("x1 = " + x);
}
int x = 2;
System.out.println("x2 = " + x);
}
}
运行结果:
x1 = 1
x2 = 2
(这种用法较少见)
3.3构造代码块
构造块:定义在类中的代码块(不加修饰符)。也叫:实例代码块。构造代码块一般用于初始化实例成员变量.
class Person{
private String name;//实例成员变量
private int age;
private String sex;
public Person() {
System.out.println("I am Person init()!");
}
//实例代码块
{
this.name = "abc";
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);
}
}
public class Main {
public static void main(String[] args) {
Person p1 = new Person();
p1.show();
}
}
运行结果:
I am instance init()!
I am Person init()!
name: abc age: 12 sex: man
!
(初学者)注意看运行结果的顺序和代码编写的顺序,
相信聪明的你一下子就发现了,实例代码块是优于构造函数执行的。
是的,代码块是优于构造函数执行的。
3.4静态代码块
使用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 = "abc";
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);
}
}
public class Main {
public static void main(String[] args) {
Person p1 = new Person();
Person p2 = new Person();//静态代码块是否还会被执行?
}
}
运行结果:
I am static init()!
I am instance init()!
I am Person init()!
Iam instance init()!
I am Person init()!
!
- 静态代码块不管生成多少个对象,其只会执行一次,且是最先执行的。
- 静态代码块执行完毕后, 实例代码块(构造块)执行,再然后是构造函数执行