JavaSE系列Java类与对象，万物皆对象
Posted 未见花闻
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了JavaSE系列Java类与对象，万物皆对象相关的知识，希望对你有一定的参考价值。
⭐️前面的话⭐️
本篇文章带大家认识Java类与对象，我相信大家都听说过面向对象编程，Java正是一种面向对象编程的语言，与C语言不同，C语言是一门面向过程的编程语言。对面向对象与面向过程的区别，我们可以这样理解，面向对象，对象指的是一个事物，是名词性的，面向过程，过程指的是做事情，是动词性的，比如你要把一物品放进冰箱，面向过程是打开冰箱门->放入冰箱->关闭冰箱；面向对象是物品->冰箱。类与对象本身就是非常抽象的概念，需要多认识多实践，下面就开始正文，带你了解Java中的类与对象。
📒博客主页：未见花闻的博客主页
🎉欢迎关注🔎点赞👍收藏⭐️留言📝
📌本文由未见花闻原创，CSDN首发！
📆首发时间：🌴2021年11月3日🌴
✉️坚持和努力一定能换来诗与远方！
💭参考书籍：📚《Java核心技术卷1》，📚《Java核心技术卷2》，📚《Java编程思想》
💬参考在线编程网站：🌐牛客网🌐力扣
🙏作者水平很有限，如果发现错误，一定要及时告知作者哦！感谢感谢！
博主的码云gitee，平常博主写的程序代码都在里面。
📌导航小助手📌
🔮1.初见类与对象
类（ class) 是构造对象的模板或蓝图。我们可以将类想象成制作小甜饼的切割机，将对
象想象为小甜饼。由类构造（construct) 对象的过程称为创建类的实例 （instance ).
对类进行实例化，这个实例化的类就是对象。
C语言是面向过程的，关注的是过程，分析出求解问题的步骤，通过函数调用逐步解决问题。JAVA是基于面向对象的，关注的是对象，将一件事情拆分成不同的对象，靠对象之间的交互完成。面向过程注重的是过程，在整个过程中所涉及的行为，就是功能。面向对象注重的是对象，也就是参与过程所涉及到的主体。是通过逻辑将一个个功能实现连接起来。面向过程： 1.把冰箱打开 2. 把大象放入 3. 冰箱关起来 面向对象： 打开冰箱，储存，关闭都是对冰箱的操作，是冰箱的行为。冰箱就是一个对象，所以只要操作冰箱所具备的功能，都要定义在冰箱中。
类与对象的概念非常地抽象，下面通过介绍类与对象的应用来理解类与对象。
🔮2.类与类的实例化
🎃2.1类的创建
🎁自定义一个类的格式：
class ClassName {
//成员：1.变量（字段/属性） 2.方法
}
（1）类名采用大驼峰形式命名
（2）一个.java文件中只能有一个public修饰的类
（3）类中的成员可以是变量（字段/属性），方法，静态变量与静态方法。
比如：
class Student {
public String name;
public String sex;
public int age;
public String id;
public void setName(String str){
name = str;
}
}
🎃2.2类的实例化
我们所定义出来的类，可以将其理解为一张建筑图纸（蓝图），按照这张图纸的内容建造处一栋房子的过程称为类的实例化，这栋实例化出来的“房子”即对象。
当然，一张设计图纸是可以实例化多个建筑的，这些建筑的属性都是相同的。换言而知，类可以实例化出多个对象。
在Java对类进行实例化的关键字为new，这个关键字我相信大家肯定不陌生，因为在之前的输入和定义数组时都使用这个关键字new。
类 名 变 量 名 = n e w 类 名 ( 构 造 函 数 参 数 ) ; 类名\\ 变量名\\ =\\ new\\ 类名(构造函数参数); 类名 变量名 = new 类名(构造函数参数);
其中这个构造函数参数我们先不管他，这个参数可以没有。
比如我们定义了这样的一个类：
class Student {
public String name;
public String sex;
public int age;
public String id;
public String major;
public void getName() {
System.out.println(name);
}
public void getMajor() {
System.out.println(major);
}
}
那么对这个类的实例化过程为：
public class ClassCreat {
public static void main(String[] args) {
Student stu = new Student();//实例化对象
stu.name = "weijianhuawen";//使用.对这个实例化的对象stu进行访问
stu.sex = "man";
stu.major = "computer";
stu.getMajor();//同理该对象的方法进行访问
stu.getName();
}
}
使用Student类定义出来的变量stu为引用变量，它的值为实例化对象的地址。
🔮3.类的成员
🎃3.1成员变量
在类中方法外定义的变量称为为一个类的成员变量。成员变量又称字段或属性。
class Variable {
public int a
public double pi;
public String str;
}
像上面这样在类中方法之外定义的变量，为成员变量。如果我们需要使用这个类，则需要先用new实例化出一个对象，然后才能对里面的成员进行访问。通过对类实例化出的多个对象，每个对象是独立的，修改一个对象的值，另一个对象的值是不会改变的。最后，类中的成员变量可以自己初始化值也可以不初始化，这和方法中定义的局部变量有了区别，但是一般情况下不自己初始化值，不初始化成员变量值的情况下，会有一个默认值。
public class ClassCreat {
public static void main(String[] args) {
Variable var = new Variable();
System.out.println(var.a);
System.out.println(var.pi);
System.out.println(var.str);
var.pi = 3.14;
var.a = 12;
System.out.println(var.a);
System.out.println(var.pi);
System.out.println("---------------------");
Variable var2 = new Variable();
System.out.println(var2.a);
System.out.println(var2.pi);
}
}
🎃3.2方法
类中可以定义成员变量以外还可以定义方法，比如main方法就是定义在一个类里面的。
class Menthod {
public double a;
public double b;
public double add(double x, double y) {
return x + y;
}
public double sub(double x, double y) {
return x - y;
}
}
我们定义了一个类，里面有两个成员变量和成员方法，如果需要使用这个类，需先实例化成对象，然后才能访问对象中的变量或方法。
public class ClassCreat {
public static void main(String[] args) {
Menthod men = new Menthod();
men.a = 3.14;
men.b = 2.88;
double sum = men.add(men.a, men.b);
double sub = men.sub(men.a, men.b);
System.out.printf("和为%.2f\\n差为%.2f\\n", sum, sub);
}
}
🎃3.3静态变量与静态方法
上面我们在类中方法之外定义的成员变量和成员方法是属于对象的，存储在堆区之中。而静态的变量或者静态的方法是存储在方法区，类也是储存在方法区，所以静态的变量或者方法也称为类变量与类方法。静态变量与静态方法是属于类的，所以不需要对类进行实例化就能使用，当然，由于它是属于类的，你在一个对象中改变静态变量的值，那么在其他对象中访问这个静态变量时，该静态的值会是被修改的值。
class StaticMember {
public static int x;
public static int add(int a, int b) {
return a + b;
}
}
上面所定义的这个类中a是成员变量，b是静态成员变量，还有一个静态方法add。上面说过使用静态的变量或者方法是不需要使用类实例化对象的（当然你也可以实例化出一个对象，然后根据对象访问它，这个是没问题的），a必须实例化出对象才能使用。
public class ClassCreat {
public static void main(String[] args) {
int a = 12;
int sum = StaticMember.add(a, StaticMember.x);
System.out.println(sum);
System.out.println("------------");
StaticMember sm1 = new StaticMember();
sm1.x = 14;
sum = sm1.add(a, sm1.x);
System.out.println(sum);
System.out.println("------------");
StaticMember sm2 = new StaticMember();
sum = sm2.add(a, sm2.x);
System.out.println(sum);
}
}
🔮4.类的封装
🎃4.1privite实现封装
上面我们定义类中的变量或方法时，都是使用了public关键字修饰，使用该关键字修饰的变量或方法，表示该变量或方法是公共的，在其他和当前类当中都可以使用，但是如果使用privite关键字修饰变量或方法，表示该变量或方法是私有的，只有它所属类才能访问使用，在其他类无法对该变量或方法进行访问或调用，这也体现了Java的安全性。
看下面一段代码：
class PriviteMember {
private int add(int a, int b) {
return a + b;
}
}
public class ClassCreat {
public static void main(String[] args) {
PriviteMember pm = new PriviteMember();
int x = 10;
int y = 12;
System.out.println(pm.add(x, y));
}
}
由于我们将PriviteMember类中的add方法私有，然后在另一个类中实例对象并使用add，我们发现编译器报错了！
如果调用add的方法（示例程序中是mian方法）与add在同一个类，再次执行程序：
public class ClassCreat {
private int add(int a, int b) {
return a + b;
}
public static void main(String[] args) {
ClassCreat pm = new ClassCreat();
int x = 10;
int y = 12;
System.out.println(pm.add(x, y));
}
}
我们发现这个方法能够正常运行：
🎃4.2getter和setter方法
关键字privite所修饰的变量或方法只能在同一个类之中使用，那如果我们想在另一个类中对那个被privite变量或方法进行修改或调用，能不能实现呢？其实是可以的，但是是间接性的，就是我们在privite修饰的变量或方法所在类中定义一个public修饰的方法来进行对privite修饰的成员进行访问与修改。
我们可以写出这样的一个类：
class PriviteMember {
private int m;
private double n;
private int add(int a, int b) {
return a + b;
}
public int getterInt() {
return m; //获取m
}
public double getterDouble() {
return n;//获取n
}
public void setterInt(int x) {
m = x;//设置m
}
public void setterDouble(double y) {
n = y;//设置n
}
public int getAdd(int x, int y) {
return add(x, y);//调用私有方法add
}
}
我们在其他类中来调用该类其他公共的变量或方法，能够间接地对私有的成员进行访问与修改。
public class ClassCreat {
public static void main(String[] args) {
PriviteMember pm = new PriviteMember();
pm.setterInt(12);//对m赋值
System.out.println(pm.getterInt());//获取m的值
pm.setterDouble(3.14);//对n赋值
System.out.println(pm.getterDouble());//获取n的值
int a = 14;
int b = 12;
System.out.println(pm.getAdd(a, b));//间接调用私有方法add
}
}
其实在编译器idea中，可以自动生成getter与setter方法，用来设置和获取一个类中私有变量的值或私有方法的返回值。
在idea编译器中，在代码区右键，找到Generate，点进去然后选择Getter或者Setter就能自动帮助你生成设置和获取私有成员变量的值。
根据需要选择Getter或Setter，然后选择需要访问的变量，按住ctrl能够多选。
this关键字修饰，表示的是当前对象中的引用，能够用来访问当前对象的成员变量与方法。
🔮5.构造方法
🎃5.1new执行过程
👻5.1.1new实例化对象过程
使用关键字new实例化对象过程中，其实分为两步：
- 为对象分配内存空间
- 调用构造方法（如果没有类中任何构造方法，会自动生成一个不带参数的构造方法）
👻5.1.2构造方法
构造方法是一种特殊方法, 使用关键字new实例化新对象时会被自动调用，所以构造函数是定义在类中的，他有以下特点：
- 方法名称必须与类名相同。
- 没有返回值。
- 每个类中至少有一个构造函数，如果类中没有定义，则会自动生成一个不带参数的构造方法。
- 构造方法支持重载， 规则和普通方法的重载一致。
- 若类中定义了含参数的构造方法，则默认的无参构造方法将不再生成。
🎃5.2this关键字
关键字this在前面使用Setter生成函数时，发现自动生成的函数中有变量被this修饰，被this关键字修饰，表示的是当前对象中的引用，能够用来访问当前对象的成员变量与方法。
❗️注意！this表示当前对象的引用，而不是当前对象，在构造函数中我们是可以使用this，但是调用构造方法时，该对象还没实例化完成，只是分配了内存，说明对象还没有定义好，但是引用已经生成了，因为内存分配完成了，那么地址也就出来了，引用也自然而然也出来了。所以this表示的是当前对象的引用，而不是当前对象。
关键字this的三种使用方式：
| 方式 | 解释 |
|---|---|
| this.成员变量名 | 访问当前对象的属性（成员变量） |
| this.方法名(对应参数列表) | 调用当前对象的方法 |
| this() | 在构造方法中调用当前对象的其他构造方法，必须位于构造方法的第一行 |
如下代码可以证明this是可以在构造方法中使用的：
class ConstructionMethod {
public int a;
private int b;
public ConstructionMethod() {
System.out.println("这是一个不带参数的构造方法！");
}
public ConstructionMethod(int x) {
this.b = x;
System.out.println("这是一个带有参数的构造方法！可以给成员变量b赋值！赋值后b = " + this.b);
}
public ConstructionMethod(int x, int y) {
this.a = this.add(x, y);
System.out.println("这是一个带有两个参数的构造方法！可以计算两个整数的和！这两个数的和为：" + a);
}
private int add(int m, int n) {
return m + n;
}
}
public class ClassCreat {
public static void main(String[] args) {
ConstructionMethod cm1 = new ConstructionMethod();
System.out.println("------------");
ConstructionMethod cm2 = new ConstructionMethod(12);
System.out.println("------------");
ConstructionMethod cm3 = new ConstructionMethod(18, 2);
}
}
🔮6.代码块
🎃6.1普通代码块
普通代码块就是在方法中使用花括号定义的代码块，例如：
public class ClassCreat {
public static void main(String[] args) {
{
int a = 12;
int b = 48;
String name = "weijianhuawen";
}
}
}
🎃6.2构造代码块
构造代码块为类中方法外定义的代码块，也叫实例代码块，一般用来初始化成员变量（我觉得多此一举），例如：
class CodeBlock {
private int c;
private int d;
public int sum;
//构造代码块 or 实例代码块
{
this.c = 10;
this.d = 12;
sum = this.add(c, d);
}
public int add(int x, int y) {
return x + y;
}
}
❗️注意：构造（实例）代码块优先于构造函数执行。
🎃6.3静态代码块
使用static修饰的构造代码块称为静态代码块，它一般用来初始化静态成员变量的属性。它和类储存在一起，存储在方法区。
class CodeBlock Javase系列之面向对象