第十五章节 面向对象和封装

前言

    初学java语言的小白，日常记录个人所学、所思、所感、所获。
    请java语言行业的前辈们多多指教， 目前从事汽车制造行业。
    属于零基础自学，愿未来自己感谢今天的选择和努力。加油！

一、面向对象思想的概述

2021、9、9更新
笔记：
对比教学代码和自编代码的优劣，学习吸收其优秀的部分。

import java.util.Arrays;

/*
面向谁就更加看中谁。

面向过程：但需要实现一个功能的时候，每一个具体步骤都要亲力亲为，详细处理每一个细节。
面向对象：当需要实现一个功能的时候，不关心具体的步骤，而是找一个已经具有该功能的人，来帮我做事儿。

题目：
遍历数组

注意：
ln是下一行代码换行，不是本段代码换行
*/
public class Demo01PrintArray {
public static void main(String[] args) {
int[] array = new int[]{10, 20, 30, 40, 50};

    //要求打印格式为：[10,20,30,40,50]
    //以下代码为个人尝试

    System.out.print("[");
    for (int i = 0; i < 5; i++) {
        if(i<4){
        System.out.print(array[i]);
        System.out.print(",");
        }else{
            System.out.print(array[i]);
        }
    }
    System.out.println("]");//ln是下一行代码换行，不是本段代码换行
    System.out.println("======");

//使用面向过程，每一个步骤细节都要亲力亲为
//编程教学
System.out.println(“教学编程”);
System.out.print("[");
for (int i = 0; i < array.length; i++) {
if(i== array.length-1){//如果是最后一个元素
System.out.println(array[i]+"]");
}else{
System.out.print(array[i]+",");
}
}
System.out.println("============");
//对比两段代码的优劣
//使用面向对象
//找一个JDK给我们提供好的Arrays类
//其中有一个toString方法，直接就能把数组变成我们想要的格式的字符串
System.out.println(Arrays.toString(array));
}
}

二、面向对象思想的举例

2021、9、10更新
笔记：
面向过程：即每一步都通过自己来实现
面向对象：通过引进有相应功能的第三方实现。

三、类与对象的关系

2021、9、10更新
笔记：
类：一种相关属性和行为的集合。
属性：描述该事物的状态
行为：该事物能够干什么

类；是对事物的描述，是抽象的。
对象：是类事物的实例，是据图的。
类是对象的模板，对象是类的实体。

四、类的定义

2021、9、10更新
笔记：
1.学习成员变量和成员方法的区别
2.类包括属性和行为两个部分，属性即成员变量，行为即成员方法。
3.成员变量直接写在类当中，方法之外。
4.成员方法直接写在类当中，方法之外
5.成员方法不带static关键字

/*
定义一个类:用来模拟"学生"事物。
其中就有两个组成部分

属性：（是什么）
姓名：
年龄:
行为：（能做什么）
吃饭：
睡觉：
学习

对应到java的类当中：

成员变量（属性）：
数据类型 变量名称：
String name;//姓名
int age;//年龄

成员方法（行为）；
注意：
定义普通方法是带static关键字
public static void eat(){}；//普通方法
成员方法不带static关键字

public  void eat(){}；//吃饭
public void sleep(){};//睡觉
public void study(){};//学习

局部变量和成员变量的区别
局部变量写在方法内部当中，出了方法就不能用
成员变量写在类当中，在整个类当中通用

注意事项：
1.成员方法直接定义在类当中，在方法外边。
2.成员方法不要写static关键字
*/

//定义一个学生类
public class Student {

//成员变量
String name;//姓名
int age;//姓名

//成员方法
//没有static关键字
public void eat(){
    System.out.println("吃饭饭！");
};
public void sleep(){
    System.out.println("睡觉觉！");
};
public void study(){
    System.out.println("学习！");
};

}

五、对象的创建及其使用

2021、9、12更新
笔记：
根据一个类创建一个对象，并且使用对象。
创建对象：需要导包、创建、使用三个步骤，注意对应格式。
导包：import 包名称.类名称;
创建：类名称 对象名 = new 类名称（）;
使用：对象名.成员变量名/成员方法名；
注意：带（）的才是方法。

/*
通常情况下，一个类不能直接使用。需要根据类创建一个对象，才能使用。

创建对象：
1.导包：也就是指出需要使用的类，在什么位置。
格式：import 包名称.类名称；
例;import day10.Student;
【注意】对于和当前包属于同一包的情况，可以省略导包语句不写

2.创建
格式：类名称 对象名 = new 类名称();//对象名 随便起
例：Student stu = new Student();

3.使用
如何使用成员变量：对象名.成员变量名;
如何使用成员方法：对象名.成员方法名（参数）;//有参数才在小括号写参数
（也就是，想用谁，就用对象名点谁。）

注意事项：
如果成员变量没有进行赋值，那么将会有一个默认值，规则和数组一样
整数类型：0
浮点数类型:0.0
布尔类型：false
字符类型:/u0000
引用类型:null

*/
public class Demo02Student {

public static void main(String[] args) {

// 一、导包
// import day10.Student;
// 我需要使用的Student类，和我自己的Demo02Student类位于同一个包下，所以省略导包语句不写

    //二、创建
    //格式：类名称 对象名 = new 类名称（）；
    //根据Studengt类，创建一个名为stu的对象

    Student stu = new Student ();

    //三、使用其中的成员对象
    //格式：对象名.成员变量名;

    System.out.println(stu.age);//0 成员变量的默认值
    System.out.println(stu.name);//null 成员变量的默认值
    System.out.println("========");

    //改变对象当中的成员变量数值内容
    //将右侧的字符串，赋值交给stu对象当中的name成员变量
    //将右侧的整数，赋值交给stu对象当中的age成员变量
    stu.name="赵丽颖";
    stu.age=18;
    System.out.println(stu.name);//赵丽颖
    System.out.println(stu.age);//18

    //使用对象的成员方法
    //格式; 对象名。成员方法名（);
    stu.eat();
    stu.study();
    stu.sleep();
}

}

六、手机类练习

2021、9、11更新
笔记：
先创建一个类，在另一类当中创建一个对象，完成调用

package day10;
创建一个类
/*
题目：
定义一个类，用来模拟"手机"事物。

属性：颜色、品牌、价格
行为：打电话、发短信

对应到类当中：
成员变量（属性）：
String brand；//品牌
double price；//价格
String color；//颜色
成员方法（行为）：
public void call(String who){};//打电话
public void sendMessage（）{};//群发短信
*/
public class Phone {

//成员变量
//直接写在类当中
String brand;//品牌
double price;//价格
String color;//颜色

//成员方法

public void call(String who){
    System.out.println("给"+who+"打电话");
};

public void sendMessage(){
    System.out.println("群发短信");
};

}

package day10;
/*
有了main方法才能启动
*/
public class Demo03PhoneOne {

public static void main(String[] args) {

    //根据Phone类，创建一个名为phone one的对象
    //格式：类名称 对象名 = new 类名称（）;
    Phone phoneOne = new Phone();
    System.out.println(phoneOne.brand);//品牌 null
    System.out.println(phoneOne.price);//价格 0.0
    System.out.println(phoneOne.color);//颜色 null
    System.out.println("============");

    phoneOne.brand="苹果";
    phoneOne.price=6999;
    phoneOne.color="玫瑰金";

    System.out.println(phoneOne.brand);//苹果
    System.out.println(phoneOne.price);//6999
    System.out.println(phoneOne.color);//玫瑰金
    System.out.println("============");

    phoneOne.call("周黄平");
    phoneOne.sendMessage();
}

}

七、一个对象的内存图

2021、9、13更新
笔记：
1.黑色×表示从栈内存消失
2.成员变量只经过一次传递，成员方法需两次传递
3.在堆当中，成员方法保存的其实是地址值。
4.只要方法结束，立刻马上从栈内存当中消失

八、两个对象使用同一个方法的内存

2021、9、11更新
笔记：
1.注意:
phone two是重新new的，所以和phone one不会产生任何联系。
2.这几个章节都清重新复习

public class Demo04PhoneTwo {

public static void main(String[] args) {

    //根据Phone类，创建一个名为phone one的对象
    //格式：类名称 对象名 = new 类名称（）;
    Phone phoneOne = new Phone();
    System.out.println(phoneOne.brand);//品牌 null
    System.out.println(phoneOne.price);//价格 0.0
    System.out.println(phoneOne.color);//颜色 null
    System.out.println("============");

    phoneOne.brand="苹果";
    phoneOne.price=6999;
    phoneOne.color="玫瑰金";

    System.out.println(phoneOne.brand);//苹果
    System.out.println(phoneOne.price);//6999
    System.out.println(phoneOne.color);//玫瑰金
    System.out.println("============");

    phoneOne.call("周黄平");
    phoneOne.sendMessage();
    System.out.println("============");

    Phone phoneTwo = new Phone();
    //默认值
    System.out.println(phoneTwo.brand);//品牌 null
    System.out.println(phoneTwo.price);//价格 0.0
    System.out.println(phoneTwo.color);//颜色 null
    System.out.println("============");

    phoneTwo.brand="华为";
    phoneTwo.price=6499.0;
    phoneTwo.color="冰川白";

    System.out.println(phoneTwo.brand);//华为
    System.out.println(phoneTwo.price);//6499.0
    System.out.println(phoneTwo.color);//冰川白
    System.out.println("============");

    phoneTwo.call("余大嘴");
    phoneTwo.sendMessage();
}

}

九、两个引用指向同一个对象的内存

2021、9、14更新
笔记：
二者使用同一个对象时，前一个方法并没有出栈，所以前一个对象的赋值依然保留。

public class Demo05PhoneSame {

public static void main(String[] args) {
Phone phoneOne = new Phone();
    System.out.println(phoneOne.brand);//品牌 null
    System.out.println(phoneOne.price);//价格 0.0
    System.out.println(phoneOne.color);//颜色 null
    System.out.println("============");

    phoneOne.brand="苹果";
    phoneOne.price=6999.0;
    phoneOne.color="玫瑰金";

    System.out.println(phoneOne.brand);//苹果
    System.out.println(phoneOne.price);//6999.0
    System.out.println(phoneOne.color);//玫瑰金
    System.out.println("============");

    phoneOne.call("周黄平");
    phoneOne.sendMessage();
    System.out.println("============");

    Phone phoneTwo =  phoneOne;//如果没有new，那么成员变量默认值为之前phoneone的赋值
    //默认值
    System.out.println(phoneTwo.brand);//苹果
    System.out.println(phoneTwo.price);//6999.0
    System.out.println(phoneTwo.color);//玫瑰金
    System.out.println("============");

    phoneTwo.brand="华为";
    phoneTwo.price=6499.0;
    phoneTwo.color="冰川白";

    System.out.println(phoneTwo.brand);//华为
    System.out.println(phoneTwo.price);//6499.0
    System.out.println(phoneTwo.color);//冰川白
    System.out.println("============");

    phoneTwo.call("余大嘴");
    phoneTwo.sendMessage();
}

}

九、使用对象类作为方法的参数

2021、9、14更新
笔记：
本章节比较迷糊，仍需重新学习。

/*
任何数据类型都能作为方法的参数或返回值

*/

public class Demo06PhotoParam {//Param 参数

public static void main(String[] args) {
    Phone one = new Phone();
    one.brand="苹果";
    one.price=8888.0;
    one.color="紫色";
    method(one);//传递进去的参数其实就是地址值//调用方法

// System.out.println(one.color);
// System.out.println(one.price);
// System.out.println(one.brand);

}

//定义普通方法，带static
//数组

// public static void method( ){//参数列表为空
//
// }
//
// public static void method(int num ){//定义一个变量为参数
//
// }
//
// public static void method(int [] array ){//定义一个数组为参数
//
// }

//定义一个方法
public static void method( Phone param){//定义一个类为参数
    System.out.println(param.color);
    System.out.println(param.price);
    System.out.println(param.brand);

}

}

十、使用对象类作为方法的返回值

2021、9、15更新
笔记：
本章节比较迷糊，仍需重新学习。

/*
题目：自定义的类作为方法的返回值
*/
public class Demo07PhoneReturn {

public static void main(String[] args) {

    Phone two = getPhone();//将getPhone的地址值赋值交给two
 //这儿的Phone是数据类型

    //注意：two=getPhone（）
    System.out.println(two.brand);

// System.out.println((getPhone().brand));

    System.out.println(two.price);

// System.out.println(getPhone().price);

    System.out.println(two.color);

// System.out.println(getPhone().color);

}

public static Phone/*返回值类型为Phone*/getPhone() {//创建一个方法
    //使用类
    Phone one = new Phone();
    one.color="颜色";
    one.price=8688.0;
    one.brand="苹果13";
    return one;

}

}

十一、成员变量和局部变量的区别

2021、9、17更新
笔记：
注意成员变量和局部的变量的区别

/*

成员变量和局部变量的区别
1.定义的位置不一样【重点】
局部变量定义在方法当中
成员变量定义在方法之外，直接写在类当中
2.作用域不一样【重点】
局部变量：作用在方法当中，出了方法就不能再用了
成员变量：整个类全都可以通用
3.默认值不一样【重点】
局部变量：没有默认值，要想使用，必须先手动进行赋值
成员变量：如果没有赋值，会有默认值，规则和数组一样
4.内存的位置不一样（了解）
局部变量：位于栈内存当中
成员变量：位于堆内存当中
5.生命周期不一样（了解）
（通常情况下，成员变量生命周期长，局部变量生命周期短）
局部变量：随着方法进栈而诞生，随着方法出栈而消失
成员变量：随着对象创建而诞生，随着对象被垃圾回收而消失
*/
public class Demo08VariableDifference {

// 1.定义的位置不一样【重点】
String name; //成员变量
public void method(){//成员方法，没有关键字static
int num;//局部变量
}

// 2.作用域不一样【重点】
/*
String nameA; //成员变量
public void methodA() {//成员方法，没有关键字static
int num = 20;//局部变量
System.out.println(num);
}

public void methodB() {//成员方法，没有关键字static
    System.out.println(num);//错误写法，num超出作用域了
    System.out.println(name); //正确写法 仍可以正常打印输出
}

*/

// 3.默认值不一样【重点】
/*
String nameB; //成员变量
public void methodB(){//成员方法，没有关键字static
int num;//局部变量
System.out.println(age);//报错 没赋值，不能用
System.out.println(name);//默认值null
}
*/

//参数在方法调用的时候，必然会被赋值的。
public void methodC(int param/*参数*/){//这里的int param属于局部变量
    System.out.println(param);//没报错，与局部变量没赋值不能用冲突
}

}

十二、面向对象的三大特征之封装性

2021、9、17更新
笔记：
加油

/*
面向对象三大特征：
封装:就是将一些细节信息隐藏起来，对于外界不可见
封装性在java当中的体现：
1.方法就是一种封装
2.关键字private也是一种封装
（下图 getMax方法就是一种封装，他可以直接隐藏起来）

继承：
多态：
*/
public class Demo09Method {
public static void main(String[] args) {
int[]array ={5,15,25,20,100};
int max = getMax(array);//数据类型 变量名称 赋值 方法名称（数组名称）
System.out.println(“最大值是”+max);

    //定义一个数组，求最大值,标准写法

// int [] array = new int []{5,15,25,20,100};
// int max =array[0];
// for (int i = 0; i < array.length; i++) {
// if(array[i]>max){
// max=array[i];
// }
// }
}
//定义一个方法，求数组的最大值
public static int getMax(int [] array){//修饰符 返回值类型 方法名称（数据类型 变量名称）{}
int max =array[0];
for (int i = 0; i < array.length; i++) {
if(array[i]>max){
max=array[i];
}
}
return max;
}
}

十二、private关键字的作用及使用

2021、9、18更新
笔记：
使用private关键字后，修饰的成员变量只能在本类当中直接访问，否则就会报错，如下图。

首先新建的一个person的类

/*
当成员变量一旦使用了private进行修饰，那么本类当中仍然可以随意访问。
但是！超出了本类范围之外就不可以再直接访问了。
需要定义一对getter/setter方法，间接访问private方法。

好处：输入的数值在我的控制范围之内

格式必须是：setXXXX或者是getXXXX的命名规则
对于Getter来说，不能有参数，返回值类型和成员变量对应。
对于Setter来说，不能有返回值，参数类似和成员变量对应。

*/
public class Person {
//成员变量
String name;//姓名
private int age;//年龄

//成员变量
//没有关键字static
public void show(){
    System.out.println("我叫什么"+name+",年龄"+age);
}

//定义一对getter/setter方法

//这个成员方法专门向成员变量age设置数据
//往里面放
public void setAge/* 方法名称必须是set*/(int num ){

// int num =age;//错误写法
// num =age;//错误写法，是把num的值赋值交给age
if(num<100&&num>=0){
age=num;//正确写法
}else{
System.out.println(“数据不合理”);
}
}
//这个成员方法，专门私语获取age的数据
//往外面拿
public int getAge(){
return age;
}
}

其次新建一个类调用person的类当中的成员方法和成员变量

/*

问题描述：
定义person的年龄时，无法阻止不合理的数值被设置进来。

解决方法：
用private关键字将需要保护的成员变量进行修饰
格式：private int age;//年龄

一旦使用了private进行修饰，那么本类当中仍然可以随意访问。
但是！超出了本类范围之外就不可以再直接访问了。

间接访问private方法，就是定义一对getter/setter方法

课后练习：将name也用上private关键字修饰

*/
public class Demo10Person {
public static void main(String[] args) {
Person per = new Person();
per.show();//调用show成员方法

    //重新赋值成员变量
    per.name="陈奕迅";
    //明显不合理，年龄应该大于等于零，该怎么办

// per.age=-33;//直接访问private内容，错误写法
per.setAge(20);
per.show();
}
}

十三、练习使用private关键字的定义

2021、9、20更新
笔记：
注意：用了private关键字，另一个类是无法直接访问读取的，需要通过set、get方法进行写入和读取

---

首先新建一个student的类

---

/*
注意：set方法没有返回值，数据类型用void
get方法有返回值，数据类型要与返回值类型对应

注意：成员变量的变量名称不能直接用于set方法小括号的变量名称

注意:基本数据类型当中的布尔类型get方法与一般的get方法有区别

对于基本类型当中的布尔型，它的getter方法一定要写成isXXXX的形式，而setXXX使用方法不变

*/
public class Student {

//成员变量
private String name; //姓名
private int age;//年龄
private boolean male;//性别  是不是男的

public void setName(String str){
    name = str;
}
public String getName(){
    return name;
}

public void setAge(int num){
    age = num;
}
public int getAge(){
    return age;
}
public void setMale(boolean boy){
    male=boy;
}

// public boolean getMale(){//错误写法，正确写法是ismal
// }
public boolean isMale(){
return male;
}
}

其次再新建一个类调用

public class Demo01Student {

public static void main(String[] args) {
    Student stu =new Student();

// stu.Name();//错误写法，用了private关键字，不能直接访问，只能通过set方法访问
stu.setName(“棒棒哒”);
stu.setAge(18);
stu.setMale(true);//注意此数据类型为boolean类型，只能是ture/false

//错误写法，用了private关键字，不能直接访问，只能通过set方法访问
// System.out.println(“姓名：”+name+"，年龄："+age+"，是否是男的"+male);

    System.out.println("姓名："+stu.getName());
    System.out.println("年龄："+stu.getAge());
    System.out.println("是否是男的："+stu.isMale());
}

}

十四、this关键字的作用

2021、9、22更新
笔记：
1.this关键字的作用是区分重名
2.通过谁调用的方法，谁就是this

先写一个person类

/*
this关键字解决重名区分效果
【重点注意】
当方法的局部变量和类的成员变量重名的时候，
根据"就近原则"，优先使用局部变量

如果需要访问本类当中的成员变量，需要使用格式：
this.成员变量名

“通过谁调用的方法，谁就是this”
*/

/*

public class Person {

//成员变量
String name;//我自己的名字

// private String name;//我自己的名字
//成员方法
//who（参数）是对方的名字
//name是自己的名字
public void sayHello(String who){
System.out.println(who+“你好,我是”+name);

}

//有priva关键字
// public void setName(String name1){
// name=name1;
// }
// public String getName(){
// return name;
// }
}
*/

public class Person {

//成员变量
String name;//我自己的名字

//成员方法
//who（参数）是对方的名字
//name是自己的名字
public void sayHello(String name){//此name为成员变量
    System.out.println(name+"你好,我是"+this.name);
    System.out.println(this);
}

}

再写一个Demo02 person类

//“通过谁调用的方法，谁就是this”
public class Demo02Person {

public static void main(String[] args) {

    //调用person类
    Person str = new Person();

    //设置自己的名字

// 有private关键字
// str.setName(“周飞”);

    //没有private关键字
    str.name= "周飞";

    str.sayHello("周黄平");//"通过谁调用的方法，谁就是this"
    //str.方法名称 = Person.name
    //Parson.name那就是=String.name//成员变量，成员变量就是this

    System.out.println(str);//str的地址值和this的地址值完全一样，即；通过谁调用的方法，谁就是this
}

}

十五、构造方法

2021、9、22更新
笔记：
1.注意构造方法的格式：
public 类名称（参数类型 参数名称）{//多个参数用逗号分隔，没有参数就空
方法体
}

先创建一个Student 类

/*
构造方法：
专门用来创建对象的方法，当我们通过关键字new来创建new来创建对象时，其实就是在调用构造方法。
格式：
public 类名称（参数类型 参数名称）{//多个参数用逗号分隔，没有参数就空
方法体
}
public class Student {
方法体
}
2.构造方法替代set方法，但是调用还得使用get方法：

用途：
创建对象
注意事项；
1.构造方法的名称必须和所在的类名称完全一样，就连大小写也要一样。//与普通方法有所区别，普通方法小驼峰式
2.构造方法不要写返回值类型，连void都不要写。
3.构造方法return一个具体的返回值
4.如果没有编写任何构造方法，那么编译器将会默认赠送一个构造方法，没有参数，方法体什么事都不做。public Student(){ }
5.一旦编写了至少一个构造方法，那么编译器将不再赠送构造方法。
6.构造方法也是可以进行重载的。
重载：方法名称相同，参数列表不同。

以下这个类包含以下四个部分：
成员变量：private
无参构造方法：没有构造方法赠送，有构造方法，需要自己写出来才会有无参构造方法：
全参构造方法：
set、get方法：

*/
public class Student {

//成员变量
private String name;
private int age;

// 无参数构造方法
public Student(){//与后一个学生类构成重载
System.out.println(“默认无参构造方法执行啦！”);
// return 100;//错误非法，不能写一个具体的返回值
}

//有参数（全参）构造方法
//用构造方法传值,赋值
// 省略set get方法
public Student(String name,int age){
    System.out.println("全参构造方法执行啦！");
    this.name =name;
    this.age=age;

//构造方法替代了set方法的输入赋值
}

//set get方法
public void setName(String name){
    this.name = name;
}
public String getName(){
    return name;
}

public void setAge(int age){
    this.age = age;
}
public int getAge(){
    return age;
}

}

再创建一个Demo01Student的类

/*
当我们通过关键字new来创建new来创建对象时，其实就是在调用构造方法。
重载形式的全参数的构造方法：
只是在创建对象时，更加方便我们把现成的数据通过参数的形式设置进来，省去我们多次调用set方法的麻烦。
但是我们更改对象内容的时候，还是需要调用set方法

*/
public class Demo01Student {

public static void main(String[] args) {

    //创建一个对象
    //无参构造
    Student stu1 = new Student();//Student()类名称就是构造方法名
    System.out.println("============");
    //全参构造
    Student stu2 = new Student("娃哈哈",27);

    System.out.println("姓名："+stu2.getName()+"，年龄："+stu2.getAge());//姓名：娃哈哈，年龄：27

// 如果需要改变对象当中的成员变量数据内容，仍然还需要使用SetXXX方法。
stu2.setAge(24);//改变年龄
System.out.println(“姓名：”+stu2.getName()+"，年龄："+stu2.getAge());//姓名：娃哈哈，年龄：24
}
}

十六、定义一个标准的类

2021、9、23更新
笔记：
1.学会用系统生成代码
2.注意一个标准的类所包含的内容

先创建一个Study的类

/*
定义一个标准的类
一个标准的类通常要拥有下面四个组成部分
1.所有的成员变量都要用private关键字进行私有化修饰。
2.为每一个成员变量编写一对Getter/Setter方法。
3.编写一个无参数的构造方法。
4.编写一个全参数的构造方法。
即：
成员方变量
无参构造
全参构造
setget方法

这样标准的类也叫Java Bean

*/
public class Study {

//成员变量
private String name;//姓名
private int age;//年龄

//自动生成Getter和Setter方法
//编辑完以上代码，换行-->选择菜单栏【代码】-->【生成】-->【Getter和Setter】-->【command 全选】

public String getName() {
    return name;
}

public void setName(String name) {
    this.name = name;
}

public int getAge() {
    return age;
}

public void setAge(int age) {
    this.age = age;
}

//自动生成无参构造方法
//编辑完以上代码，换行-->选择菜单栏【代码】-->【生成】-->【构造函数】-->【无选择】

public Study() {

}

//自动生成无参构造方法
//编辑完以上代码，换行-->选择菜单栏【代码】-->【生成】-->【构造函数】-->【command 全选】

public Study(String name, int age) {
    this.name = name;
    this.age = age;
}

}

再创建一个Demo02Study的类

public class Demo02Study {

public static void main(String[] args) {
    Study stu1 = new Study();

    //set方法
    stu1.setName("娃哈哈");
    stu1.setAge(26);

    System.out.println("姓名:"+stu1.getName()+",年龄:"+stu1.getAge());
    System.out.println("============");

    //全参构造方法
    Study stu2 = new Study("关注",18);
    System.out.println("姓名:"+stu2.getName()+",年龄:"+stu2.getAge());
    //变更姓名
    stu2.setName("古力娜扎");
    stu2.setAge(21);
    System.out.println("姓名:"+stu2.getName()+",年龄:"+stu2.getAge());
    //全参构造方法下写Getter和Setter方法，方便后期更改
}

}

心得体会

2021、9、23更新
笔记：
最近这段时间要忙着准备两个考试，更新的速度有点慢了，等考试完后抓紧学习，加油 。 2021、9、23