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

java面向对象编程【基础篇】之基础语法

news 2025/6/8 7:11:51

目录

  • 🚀前言
  • 🌟构造器
    • 💯案例
  • 🤔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);}
}
  • 修饰方法：

可以用来做工具类。工具类中的方法都是一些静态方法，每个方法用来完成一个功能，以便供给开发人员直接使用。这样提高了代码复用和开发效率。工具类没有创建对象的需求，建议将工具类的构造器私有。

💯静态方法的注意事项

  • 静态方法中可以直接访问静态成员，但不能直接访问实例成员。
  • 实例方法中既可以直接访问静态成员，也能直接访问实例成员。
  • 实例方法中可以出现this关键字，静态方法中则不能出现。

前文提到，静态方法由类持有，属于类，不属于任何对象，其直接访问实例成员，无法确定实例成员为哪个对象持有，而this关键字表示的也是对象，所以同样不支持。

http://www.xdnf.cn/news/112951.html

相关文章：

  • 【产品经理从0到1】Axure介绍
  • Windows申请苹果开发者测试证书Uniapp使用
  • 基于 Spring Boot 的银行柜台管理系统设计与实现(源码+文档+部署讲解）
  • C语言之阶乘2.0
  • 区块链技术：深入共识算法、智能合约与DApps的架构奥秘
  • JAVA设计模式——（五）享元模式（Flyweight Pattern）
  • 快速配置linux远程开发-go语言
  • Web3中心化交易所钱包-批量地址生成业务
  • 测试基础笔记第十一天
  • 第十四届蓝桥杯省B.砍树
  • 如何创建极狐GitLab 议题？
  • 膳食营养诊断活动：科技赋能，共筑全民健康新基石
  • Langchain+RAG+向量数据库
  • GitHub万星项目维护者分享：开源协作的避坑指南
  • C++ 日志系统实战第二步：不定参数函数解析
  • 深入理解 BLE PHY 模式：1M、2M 与 Coded 的演进与应用
  • 手撕C++STL list：深入理解双向链表的实现
  • 解决 Dart Sass 的旧 JS API 弃用警告 的详细步骤和解决方案
  • 【含文档+PPT+源码】基于SpringBoot+Vue旅游管理网站
  • 【无人机】无人机遥控器设置与校准，飞行模式的选择，无线电控制 （RC） 设置
  • 精益数据分析（20/126）：解析经典数据分析框架，助力创业增长
  • day36图像处理OpenCV
  • Windows IIS 配置编辑器 应用程序初始化 ＜applicationInitialization＞
  • 开发并发布一个属于自己的包（npm）
  • 算法笔记.spfa算法(bellman-ford算法的改进)
  • 要从给定的数据结构中提取所有的 itemList 并将其放入一个新的数组中
  • Python爬虫（3）HTML核心技巧：从零掌握class与id选择器，精准定位网页元素
  • mfc学习（一）
  • 基于whisper和ffmpeg语音转文本小程序
  • 【深度学习】#9 现代循环神经网络