当前位置：首页 > wzjs >正文

石家庄网站网站建设百度实时热搜榜

wzjs 2025/9/8 20:27:10

石家庄网站网站建设,百度实时热搜榜,企业建站平台哪个好,如何做交互式网站目录 🚀前言🌟构造器💯案例 🤔this关键字💯使用this调用本类中的属性💯使用this调用构造器💯this表示当前对象 🦜封装💯合理隐藏💯合理暴露 🐧实体…

🚀前言
🌟构造器
- 💯案例
🤔this关键字
- 💯使用this调用本类中的属性
- 💯使用this调用构造器
- 💯this表示当前对象
🦜封装
- 💯合理隐藏
- 💯合理暴露
🐧实体类
🐍static关键字
- 💯static修饰成员变量
- 💯static修饰方法
- 💯static的应用场景
- 💯静态方法的注意事项

🚀前言

在这里插入图片描述

大家好！我是 EnigmaCoder。

本文介绍java面向对象编程的简单语法，如构造器、this关键字、封装、实体类、static关键字等。

🌟构造器

构造器：是一种特殊的方法，不能有返回值，而且和类名相同，用于初始化对象。

特点：创建对象时，对象会自动调用构造器（根据有无参数）。
构造器分为无参构造器和有参构造器：

无参构造器：访问权限 类名(){//类自带无参构造器，如果自己写有参构造器，那么类自带的无参构造器就失效了,此时需要自己加上无参构造器。}有参构造器：访问权限 类名(类型1 参数1,类型2 参数2 ...){程序语句;}

三点注意事项：
- 构造器的名称必须与类名称一致。
- 构造器的声明处不能有任何返回值类型的声明。
- 不能在构造器中使用return返回一个值。

💯案例

Student类

public class Student {String name;int age;char sex;public Student(){System.out.println("无参构造器");}public Student(String name,int age){System.out.println("有参构造器");}public Student(String n,int a,char s){name = n;age = a;sex = s;}
}

Test类

public class Test {public static void main(String[] args) {Student s1 = new Student();Student s2 = new Student("张三",18);Student s3 = new Student("李四",20,'男');System.out.println(s3.name);System.out.println(s3.age);System.out.println(s3.sex);}
}

运行结果

无参构造器
有参构造器
李四
20
男

小结

对象s1在创建时未加上参数，所以调用无参构造器；对象s2在创建时加上了参数，则调用拥有相对应的参数列表的有参构造器；对象s3则反映了有参构造器的应用场景，即创造对象时可以立即为对象赋值，可以提高开发效率。

🤔this关键字

this关键字有三个作用：

表示类中的属性。
可以使用this调用本类的构造器。
this表示当前对象。

💯使用this调用本类中的属性

例如在上述Student类中，我们使用了有参构造器：

public Student(String n,int a,char s){name = n;age = a;sex = s;}

该构造器的目标很明确，即为类中的属性赋值，但是，如果不分析前后代码，我们很难知道n、a、s分别表示什么含义，进而无法进行准确的赋值。

为此，我们修改代码：

public Student(String name,int age,char sex){name = name;age = age;sex = sex;}

我们会发现运行结果为：

null
0

显然不是我们想要的结果，这是因为无法确定name、age、sex是类的属性还是构造器的参数。事实上，根据就近原则，两边都是传递的参数。

我们可以使用this关键字来解决这个问题，修改后的代码为：

public Student(String name,int age,char sex){this.name = name;this.age = age;this.sex = sex;}

this可以表示类中的属性，所以等号左边是类的属性，右边是传递进来的值，此时可以成功的将传递进来的值赋值给类中的属性。在开发中，建议在类中访问属性时都加上this关键字。

💯使用this调用构造器

假设我们的需求是每一次调用有参构造器之前先调用一次无参构造器，代码如下：

public class Student {String name;int age;char sex;public Student(){System.out.println("无参构造器");}public Student(String name,int age){System.out.println("有参构造器");}public Student(String name,int age,char sex){this();name = name;age = age;sex = sex;}
}

使用上述的Test类调用Student类，运行结果为：

无参构造器
有参构造器
无参构造器
李四
20
男

显然，拥有三个参数的构造器使用this();的形式调用了本类中的无参构造器。即this关键字可以调用本类中的其它构造器，例如，我们改变需求先调用有两个参数的构造器，可以使用this(name,age);来完成。
注意：（1）使用this关键字时只能放在构造器的首行，否则报错。（2）禁止互相调用，使用this进行构造器调用时必须要有一个构造器作为出口，即程序中至少存在一个构造器是不使用this的，一般以无参构造器为出口。

💯this表示当前对象

观察this表示当前对象：

class Person{public String getInfo(){System.out.println("Person类 -->"+this);   //直接打印thisreturn null;                               //此处返回null，为了让语法不出错}
}public Test{public static void main(String[] args) {Person per1=new Person();Person per2=new Person();System.out.println("MAIN方法 -->"+per1);per1.getInfo();System.out.println("-------------------";System.out.println("MAIN方法 -->"+per2);per2.getInfo();} 
}

运行结果：

 MAIN方法 -->Person@757aefPerson类 -->Person@757aef-------------------MAIN方法 -->Person@d9f9c3Person类 -->Person@d9f9c3

从运行结果来看，直接打印对象和调用getInfo()方法打印的结果一样，而且在getInfo()方法中永远是一个this关键字，也就是说哪个对象调用了类中的方法，则this就表示哪个对象。

🦜封装

封装是java面向对象编程的三大特性之一，其设计思想在于合理隐藏合理暴露。
封装机制为封装在一个整体的变量及方法规定了不同级别的“可见性”或访问权限，以保证外界不能随意更改其内部的属性值，也不能任意调用其内部的功能方法。

💯合理隐藏

观察一下程序的问题：

class Student{String name;int age;Public void tell(){System.out.println("姓名："+name+",年龄："+age);}public class Test{public static void main(String[] args) {Student per=new Student();per.name="张三";per.age="-18";per.tell();}}
}

运行结果如下：

姓名：张三,年龄：-18

我们发现，在程序中将年龄（age）赋值为-18岁，这在程序上没有问题，但对于用户而言，这显然是一个不合法的数据。这是因为程序中用对象直接访问类中的属性，这在面向对象法则中是不允许的。为了避免这样的事发生，在一般的开发中往往要将类中的属性封装。

封装格式如下：

 为属性封装：private 属性类型 属性名称;为方法封装：private 方法返回值 方法名称（参数列表）{}

对上面的Student类进行封装，我们会发现运行报错，这是因为我们只进行了合理隐藏，但没有进行合理暴露。

💯合理暴露

使用public修饰（公开）的get和set方法合理暴露。

只要是被封装的属性，则必须通过setter和getter设置和取得。

class Student{private String name;private int age;Public void tell(){System.out.println("姓名："+this.getName+",年龄："+this.getAge);}public void setName(String name){this.name=name;}public String getName(){return name;}public void setAge(int age){if(age>=0&&age<=150)this.age=age;}public int getAge(){return age;}
}
public class Test{public static void main(String[] args) {Student per=new Student();per.getName="张三";per.getAge="-18";per.tell();}
}

运行结果为：

姓名：张三,年龄：0

经过封装后，可以在setter()方法处加上验证代码，如果是不合法的数据，则不会将值赋值给age属性。

🐧实体类

实体类是一种特殊的类，其满足一下两个需求：

类中的成员变量全部私有，并提供public修饰的getter/setter方法。
类中需要提供一个无参构造器，有参构造器可选。

这里介绍IDEA的生成功能：
第一步：点击右键

第二步：点击Generate（生成）

第三步：点击需要自动生成的功能，然后全选，再点OK即可。

🐍static关键字

💯static修饰成员变量

成员变量按照有无static修饰，分为两种：

静态变量（类变量）：有static修饰，属于类，在计算机里只有一份，会被类的全部对象共享。
实例变量（对象的变量）：无static修饰，属于每个对象的。

访问格式：

静态变量的访问：

类名.静态变量（推荐）
对象.静态变量

实例变量的访问：

对象.实例变量

Student类：

public class Student {// 静态变量:属于类，只加载一次，可以被类和类的所有对象共享static String name;//实例变量：属于对象，每个对象都有一份int age;}

Test类：

public class Test {public static void main(String[] args) {//1.类名.静态成员变量名=值;（推荐）Student.name="王二狗";//2.对象名.静态成员变量名=值;Student s1=new Student();s1.name="张三";Student s2=new Student();s2.name="李小花";System.out.println(Student.name);//以最后一次为准System.out.println(s1.name);//3.对象名.实例变量=值;s1.age=18;s2.age=19;System.out.println(s1.age);System.out.println(s2.age);}
}

运行结果为：

李小花
李小花
18
19

由于name是静态变量，可以被类和类的所有对象共享，所以无论是用对象名还是用类名调用，都以最后一次赋值为准。而age为实例变量，其为对象所有，每个对象的访问相互不影响。

💯static修饰方法

static修饰方法的分类、访问与static修饰成员变量基本相同。

Student类：

public class Student {private double score;//静态方法：有static修饰，属于类持有public static void printHelloWorld(){System.out.println("Hello World");}//实例方法：没有static修饰，属于对象持有public void printPass(){System.out.println(score>=60?"通过":"不通过");}public void setScore(double score) {this.score = score;}
}

Test类：

public class Test {public static void main(String[] args) {//1.类名.静态方法(推荐)Student.printHelloWorld();//2.对象.静态方法Student S1 = new Student();S1.printHelloWorld();//3.对象.实例方法Student s2 = new Student();s2.setScore(100);s2.printPass();}
}

运行结果：

Hello World
Hello World
通过

如果这个方法只是为了做一个功能且不需要直接访问对象，那么这个方法可以使用静态方法。反之，如果这个方法是对象的行为，需要访问对象的数据，那么这个方法必须使用实例方法。

💯static的应用场景

修饰成员变量：

如果某个数据需要一份，并且希望能够被共享（访问、修改），则该数据可以被定义成静态变量来记住。例如，统计一个类产生了多少个对象。

public class Uesr {public static int count;public Uesr(){count++;//每创建一个对象，count就加1}public static void main(String[] args) {new Uesr();new Uesr();new Uesr();System.out.println(Uesr.count);}
}