相关链接
Part6 【面向对象】概述&封装
1 面向对象概述
1.1 面向对象思想
- 我们回想一下，前面我们完成一个需求的步骤：首先是搞清楚我们要做什么，然后在分析怎么做，最后我们再代码体现。一步一步去实现，而具体的每一步都需要我们去实现和操作。这些步骤相互调用和协作，完成我们的需求。
- 在上面的每一个具体步骤中我们都是参与者，并且需要面对具体的每一个步骤和过程，这就是面向过程最直接的体现。
- 那么什么是面向过程开发呢? 面向过程开发，其实就是面向着具体的每一个步骤和过程，把每一个步骤和过程完成，然后由这些功能方法相互调用，完成需求。
- 面向过程的代表语言：C语言
- 当需求单一，或者简单时，我们一步一步去操作没问题，并且效率也挺高。可随着需求的更改，功能的增多，发现需要面对每一个步骤很麻烦了，这时就开始思索，能不能把这些步骤和功能在进行封装，封装时根据不同的功能，进行不同的封装，功能类似的用一个类封装在一起，这样结构就清晰了很多。用的时候，找到对应的类就可以了。这就是面向对象的思想。
1.1.1 面向过程思想与面向对象思想
-
A:什么是面向过程
- 面向过程，其实就是面向着具体的每一个步骤和过程，把每一个步骤和过程完成，然后由这些功能方法相互调用，完成需求。
- 例如:吃煎饼果子利用面向过程的思想:
- 1.学习摊煎饼的技术
- 2.买材料鸡蛋,油,葱等等
- 3.开始摊
- 4.吃
- 5.收拾
-
B:什么是面向对象
- 面向对象思想就是不断的创建对象，使用对象，指挥对象做事情。（如果有对象，直接用对象，对我们直接提供服务）
- 例如:吃煎饼果子利用面向对象的思想
- 1.找会摊煎饼的大妈(创建一个摊煎饼大妈的对象)
- 2.调用其摊煎饼的技能(功能),传递进去钱参数
- 3.返回给我们一个煎饼
- 4.吃
1.1.2 面向过程特点与面向对象特点
- A:面向过程：
- 强调的是过程，所有事情都需要自己完成
- B:面向对象:
- 是一种更符合我们思想习惯的思想(懒人思想，我把事情自己不做，交给别人去做)
- 可以将复杂的事情简单化（对使用者来说简单了，对象里面还是很复杂的）
- 将我们从执行者变成了指挥者角色发生了转换
1.2 类与对象概述
- A:我们学习编程是为了什么
- 为了把我们日常生活中实物用学习语言描述出来
- B:我们如何描述现实世界事物
- 属性 就是该事物的描述信息(事物身上的名词)
- 行为 就是该事物能够做什么(事物身上的动词)
- C:Java中最基本的单位是类,Java中用class描述事物也是如此
- 成员变量 就是事物的属性
- 成员方法 就是事物的行为
- D:定义类其实就是定义类的成员(成员变量和成员方法)
- a:成员变量 和以前定义变量是一样的，只不过位置发生了改变。在类中，方法外。
- b:成员方法 和以前定义方法是一样的，只不过把static去掉，后面在详细讲解static的作用。
- E:类和对象的概念
- a:类：是一组相关的属性和行为的集合（我们班所有的同学都具备相同的属性和行为，比如：姓名，年龄，学习，这样就把所有的学生成为学生类）
- b:对象：是该类事物的具体体现（说某个同学时，他都具备自己特有的属性和行为）
- c:举例：
- 类 学生
- 对象 具体的某个学生就是一个对象
- 比如：车是一个类，具体的开的奔驰、宝马，就是对象
案例代码一 类与对象案例 【1.a 学生类】
package com.groupies.day06;
/**
* @author GroupiesM
* @date 2021/3/22
* @introduction 学生类 案例
*
* 类的定义：类是用来描述现实世界事物的
* 事物：
* 属性
* 行为
* 类如何和事物进行对应的呢?
* 类：
* 成员变量
* 成员方法
*
* 成员变量：和我们学习过的变量的定义是一样的，有两个小区别。
* 位置不同：类中，方法外
* 初始化值：成员变量不需要给初始化值也可以使用，因为它有默认值
* 成员方法：和我们学习过的方法的定义是一样的，有一个小区别。
* 去掉了修饰符中的static关键字
*
* 需求：定义一个学生类。
*
* 学生事物：
* 属性：姓名，年龄...
* 行为：学习，吃饭...
*
* 学生类：
* 成员变量：姓名，年龄...
* 成员方法：学习，吃饭...
*/
public class OperatorDemo1POJO {
/*成员变量*/
//姓名
String name;
//年龄
int age;
/*成员方法*/
//学习的方法
public void study() {
System.out.println(name + " 好好学习，天天向上");
}
//吃饭的方法
public void eat() {
System.out.println(name + " 学习饿了要吃饭");
}
}
案例代码一 类与对象案例 【1.b 学生类的测试类】
package com.groupies.day06;
/**
* @author GroupiesM
* @date 2021/3/22
* @introduction 学生类的测试类 类与对象案例
*
* 类的使用：
* 使用一个类，其实就是使用该类的成员。(成员变量和成员方法)
* 而我们要想使用一个类的成员，就必须先拥有该类的对象。
* 那么我们如何拥有一个类的对象呢?
* 创建对象就可以了
* 我们如何创建对象呢?
* 格式：
* 类名 对象名 = new 类名();
* 对象如何访问成员呢?
* 成员变量：
* 对象名.成员变量
* 成员方法：
* 对象名.成员方法(...)
*/
public class OperatorDemo1 {
public static void main(String[] args) {
//类型 对象名 = new 类名();
OperatorDemo1POJO student = new OperatorDemo1POJO();
//实例对象地址：student:com.groupies.day06.OperatorDemoPOJO@23fc625e
System.out.println("student:" + student);
//使用成员变量
System.out.println("姓名" + student.name);
System.out.println("年龄" + student.age);
System.out.println("-------------------");
//给成员变量赋值
student.name = "林青霞";
student.age = 30;
//再次使用成员变量
System.out.println("姓名:" + student.name);
System.out.println("年龄:" + student.age);
System.out.println("-------------------");
//调用成员方法
student.study();
student.eat();
}
}
案例代码二 类与对象案例 【2.a 手机类】
package com.groupies.base.day06;
/**
* @author GroupiesM
* @date 2021/3/22
* @introduction 手机类
*/
public class OperatorDemo2POJO {
/*成员变量*/
//品牌
String brand;
//价格
int price;
//颜色
String color;
/*成员方法*/
//打电话
public void call(String name) {
System.out.println("给" + name + "打电话");
}
//发短信
public void sendMessage(String name) {
System.out.println("给" + name + "发短信");
}
}
2 对象的内存图
2.1 一个对象的内存图
案例代码二 对象的内存图 【2.b 手机类的测试类】
package com.groupies.base.day06;
/**
* @author GroupiesM
* @date 2021/3/22
* @introduction 手机类的测试类
*/
public class OperatorDemo2 {
public static void main(String[] args) {
//创建对象
OperatorDemo2POJO phone = new OperatorDemo2POJO();
//给成员变量赋值
phone.brand = "锤子";
phone.price = 2999;
phone.color = "棕色";
//输出成员变量的值
System.out.println("品牌：" + phone.brand);//锤子
System.out.println("价格：" + phone.price);//2999
System.out.println("颜色：" + phone.color);//棕色
System.out.println("------------");
//调用成员方法
phone.call("林青霞");
phone.sendMessage("林青霞");
}
}
一个对象的内存图图解
2.2 两个对象的内存图(共用方法区)
案例代码二 对象的内存图 【2.c 手机类的测试类（两个对象共用一个方法区）】
package com.groupies.base.day06;
/**
* @author GroupiesM
* @date 2021/3/22
* @introduction 手机类的测试类(两个对象共用一个方法区)
*/
public class OperatorDemo2_1 {
public static void main(String[] args) {
//创建对象
OperatorDemo2POJO phone = new OperatorDemo2POJO();
//给成员变量赋值
phone.brand = "小米5s";
phone.price = 1999;
phone.color = "银色";
//小米5s---1999---银色
System.out.println(phone.brand+"---"+phone.price+"---"+phone.color);
phone.call("林青霞");
phone.sendMessage("林青霞");
//创建对象
OperatorDemo2POJO phone2 = new OperatorDemo2POJO();
//给成员变量赋值
phone2.brand = "IPhone7S";
phone2.price = 7999;
phone2.color = "土豪金";
//IPhone7S---7999---土豪金
System.out.println(phone2.brand+"---"+phone2.price+"---"+phone2.color);
phone2.call("张曼玉");
phone2.sendMessage("张曼玉");
}
}
两个对象的内存图(共用方法区)图解
2.3 两个对象的内存图(两个引用指向同一个堆内存)
案例代码二 对象的内存图 【2.d 手机类的测试类（两个引用指向同一个堆内存）】
package com.groupies.base.day06;
/**
* @author GroupiesM
* @date 2021/3/22
* @introduction 手机类的测试类(两个引用指向同一个堆内存)
*/
public class OperatorDemo2_2 {
public static void main(String[] args) {
//创建对象
OperatorDemo2POJO phone = new OperatorDemo2POJO();
//给成员变量赋值
phone.brand = "OPPO";
phone.price = 2999;
phone.color = "白色";
//OPPO---2999---白色
System.out.println(phone.brand+"---"+phone.price+"---"+phone.color);
//创建对象
OperatorDemo2POJO phone2 = phone;
//给成员变量赋值
phone2.brand = "魅族";
phone2.price = 1999;
phone2.color = "蓝色";
//魅族---1999---蓝色
System.out.println(phone.brand+"---"+phone.price+"---"+phone.color);
//魅族---1999---蓝色
System.out.println(phone2.brand+"---"+phone2.price+"---"+phone2.color);
}
}
两个对象的内存图(两个引用指向同一个堆内存)图解
2.4 成员变量和局部变量区别
案例代码三 对象的内存图 【3.a 成员变量和局部变量区别】
package com.groupies.base.day06;
/**
* @author GroupiesM
* @date 2021/3/22
* @introduction 成员变量和局部变量区别
*
* 成员变量和局部变量的区别：
* A:在类中的位置不同
* 成员变量：在类中，方法外
* 局部变量：在方法中或者方法声明上(形式参数)
* B:在内存中的位置不同
* 成员变量：在堆内存
* 局部变量：在栈内存
* C:生命周期不同
* 成员变量：随着对象的创建而存在，随着对象的消失而消失
* 局部变量：随着方法的调用而存在，随着方法的调用完毕而消失
* D:初始化值不同
* 成员变量：有默认值
* 局部变量：没有默认值，必须先定义，赋值，最后使用
*/
public class OperatorDemo3 {
/**成员变量*/
int x;
public void show() {
//局部变量
int y = 10;
System.out.println(x);
System.out.println(y);
}
}
3 private、this关键字和封装
3.1 private关键字的概述和特点
- private关键字：
- a:是一个权限修饰符；
- b:可以修饰成员(成员变量和成员方法)；
- c:被private修饰的成员只在本类中才能访问。
案例代码四 private关键字 【4.a 学生类】
package com.groupies.base.day06;
/**
* @author GroupiesM
* @date 2021/3/22
* @introduction 学生类 private关键字的概述和特点
*
* 直接使用对象名访问成员变量，会存在数据的安全问题
* 这个时候，我们就应该思考能不能让外界不要直接访问成员变量? 能
* 如何实现呢? 用private关键字
* private:
* 是一个修饰符
* 可以修饰成员变量，也可以修饰成员方法
* 被private修饰的成员只能在本类中被访问
*
* 针对被private修饰的成员变量，我们会相应的给出getXxx()和setXxx()用于获取和设置成员变量的值，
* 方法用public修饰
*/
public class OperatorDemo4POJO {
String name;
private int age;
public int getAge() {
return age;
}
public void setAge(int a) {
if (a < 0 || a > 200) {
System.out.println("输入年龄有误");
} else {
age = a;
}
}
public void show() {
System.out.println("【name:"+name + "】 【age:" + age+"】");
}
}
案例代码四 private关键字 【4.b 学生类的测试类】
package com.groupies.base.day06;
/**
* @author GroupiesM
* @date 2021/3/22
* @introduction 学生类的测试类 private关键字的概述和特点
*
* 直接使用对象名访问成员变量，会存在数据的安全问题
* 这个时候，我们就应该思考能不能让外界不要直接访问成员变量? 能
* 如何实现呢? 用private关键字
* private:
* 是一个修饰符
* 可以修饰成员变量，也可以修饰成员方法
* 被private修饰的成员只能在本类中被访问
*
* 针对被private修饰的成员变量，我们会相应的给出getXxx()和setXxx()用于获取和设置成员变量的值，
* 方法用public修饰
*/
public class OperatorDemo4 {
public static void main(String[] args) {
//创建对象
OperatorDemo4POJO student = new OperatorDemo4POJO();
student.show();//【name:null】 【age:0】
//给成员变量赋值
student.name = "林青霞";
//student.age=30; //不能赋值 报错
student.setAge(-30);//输入年龄有误
student.show();//【name:林青霞】 【age:0】
}
}
3.2 private修饰后的标准类代码
-
private最常见的应用：
-
把成员变量用private修饰；
- 提供对应的getXxx()/setXxx()方法；
-
使用快捷键 alt + insert；
- 构造器：Constructor；
- Get和Set方法： Getter And Setter
案例代码五 private修饰后的标准类代码 【5.a 学生类】
package com.groupies.base.day06;
/**
* @author GroupiesM
* @date 2021/3/22
* @introduction 学生类 private修饰后的标准类代码
*
* private最常见的应用：
* 把成员变量用private修饰
* 提供对应的getXxx()/setXxx()方法
*/
public class OperatorDemo5POJO {
private String name;
private String age;
public String getName() {
return name;
}
public void setName(String n) {
this.name = n;
}
public String getAge() {
return age;
}
public void setAge(String a) {
age = a;
}
}
3.3 封装的概述和好处
- A:封装概述
- 是面向对象三大特征之一;
- 是面向对象编程语言对客观世界的模拟，客观世界里成员变量都是隐藏在对象内部的，外界无法直接操作和修改。就像刚才说的年龄。
- B:封装原则
- 将不需要对外提供的内容都隐藏起来；
- 把属性隐藏，提供公共方法对其访问；
- 成员变量private，提供对应的getXxx()/setXxx()方法。
- C:好处
- 通过方法来控制成员变量的操作，提高了代码的安全性
- 把代码用方法进行封装，提高了代码的复用性
3.4 this关键字的概述和使用
- A:this:代表所在类的对象引用
- 方法被哪个对象调用，this就代表那个对象；
- B:什么时候使用this呢
- 局部变量和成员变量重名。
案例代码六 this关键字的概述和使用 【6.a 学生类】
package com.groupies.base.day06;
/**
* @author GroupiesM
* @date 2021/3/22
* @introduction 学生类 this关键字的概述和使用
*
* 目前代码中的n和a没有做到见名知意，需要改进。
* 如果局部变量名称和成员变量名称一致，在方法中使用的时候采用的是就近原则。
*
* 我们有没有办法把局部变量的name赋值给成员变量的name呢?
* 有
*
* 有什么办法呢?
* 用this关键字就可以解决这个问题
*
* this:代表所在类的对象引用
* 方法被哪个对象调用，this就代表谁。
*
* 使用场景：
* 就是用于解决成员变量被隐藏的问题。
*/
public class OperatorDemo6POJO {
private String name;
private int age;
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;
}
}
案例代码六 this关键字的概述和使用 【6.b 学生类的测试类】
package com.groupies.base.day06;
/**
* @author GroupiesM
* @date 2021/3/22
* @introduction 学生类的测试类 this关键字的概述和使用
*
* 目前代码中的n和a没有做到见名知意，需要改进。
* 如果局部变量名称和成员变量名称一致，在方法中使用的时候采用的是就近原则。
*
* 我们有没有办法把局部变量的name赋值给成员变量的name呢?
* 有
*
* 有什么办法呢?
* 用this关键字就可以解决这个问题
*
* this:代表所在类的对象引用
* 方法被哪个对象调用，this就代表谁。
*
* 使用场景：
* 就是用于解决成员变量被隐藏的问题。
*/
public class OperatorDemo6 {
public static void main(String[] args) {
//创建对象
OperatorDemo6POJO student = new OperatorDemo6POJO();
//null---0
System.out.println(student.getName() + "---" + student.getAge());
student.setName("林青霞");
student.setAge(30);
//林青霞---30
System.out.println(student.getName() + "---" + student.getAge());
}
}
4 面向对象之构造方法
4.1 构造方法的概述和使用
4.1.1 构造方法作用概述
- 给对象的数据进行初始化
4.1.2 构造方法格式
- 方法名与类名相同
- 没有返回值，连void都没有
- 没有具体的返回值
案例代码七 构造方法格式 【7.a 学生类】
package com.groupies.base.day06;
/**
* @author GroupiesM
* @date 2021/3/22
* @introduction 学生类 面向对象之构造方法
*
* 构造方法：
* 给对象的数据进行初始化
*
* 格式：
* 方法名和类名相同
* 没有返回值类型，连void都不能写
* 没有具体的返回值
*
*/
public class OperatorDemo7POJO {
private String name;
public OperatorDemo7POJO() {
System.out.println("这是构造方法");
}
public OperatorDemo7POJO(String name) {
this.name = name;
System.out.println("这是带参构造方法");
}
}
案例代码七 构造方法格式 【7.b 学生类的测试类】
package com.groupies.base.day06;
/**
* @author GroupiesM
* @date 2021/3/22
* @introduction 学生类的测试类 面向对象之构造方法
*
* 构造方法：
* 给对象的数据进行初始化
*
* 格式：
* 方法名和类名相同
* 没有返回值类型，连void都不能写
* 没有具体的返回值
*
*/
public class OperatorDemo7 {
public static void main(String[] args) {
//如何调用构造方法呢
//通过new关键字调用
//无参格式：类名 对象名 = new 构造方法(...);
OperatorDemo7POJO student1 = new OperatorDemo7POJO();
//带参格式：类型 对象名 = new 构造方法(参数1,参数2,...)
OperatorDemo7POJO student2 = new OperatorDemo7POJO("张三");
}
}
4.2 构造方法的注意事项
如果你不提供构造方法，系统会给出默认构造方法
如果你提供了构造方法，系统将不再提供
构造方法也是可以重载的,重载条件和普通方法相同
案例代码八 构造方法的注意事项 【8.a 学生类】
package com.groupies.base.day06;
/**
* @author GroupiesM
* @date 2021/3/22
* @introduction 学生类 构造方法的注意事项
*
* 构造方法：用于给对象的数据进行初始化
*
* 格式：
* 方法名和类名相同
* 没有返回值类型，连void都不能写
* 没有具体的返回值
*
* 构造方法的注意事项：
* A:如果我们没有给出构造方法，系统将给出一个默认的无参数构造方法供我们使用
* B:如果我们给出了构造方法，系统将不再提供默认的构造方法供我们使用。
* 这个时候，我们如果还想使用无参数构造方法，就必须自己提供。
* 我们推荐：自己给出无参数构造方法。
* C:构造方法也是可以重载的。
*
* 给成员变量赋值的方式：
* A:通过setXxx()
* B:通过构造方法
*/
public class OperatorDemo8POJO {
private String name;
private int age;
public OperatorDemo8POJO() {
}
public OperatorDemo8POJO(String name) {
this.name = name;
}
public OperatorDemo8POJO(int age) {
this.age = age;
}
public OperatorDemo8POJO(String name, int age) {
this.name = name;
this.age = age;
}
public void show() {
System.out.println(name + "---" + age);
}
}
案例代码八 构造方法的注意事项 【8.b 学生类的测试类】
package com.groupies.base.day06;
/**
* @author GroupiesM
* @date 2021/3/22
* @introduction 学生类的测试类 构造方法的注意事项
*
* 构造方法：用于给对象的数据进行初始化
*
* 格式：
* 方法名和类名相同
* 没有返回值类型，连void都不能写
* 没有具体的返回值
*
* 构造方法的注意事项：
* A:如果我们没有给出构造方法，系统将给出一个默认的无参数构造方法供我们使用
* B:如果我们给出了构造方法，系统将不再提供默认的构造方法供我们使用。
* 这个时候，我们如果还想使用无参数构造方法，就必须自己提供。
* 我们推荐：自己给出无参数构造方法。
* C:构造方法也是可以重载的。
*
* 给成员变量赋值的方式：
* A:通过setXxx()
* B:通过构造方法
*/
public class OperatorDemo8 {
public static void main(String[] args) {
//如何调用构造方法呢?
//其实通过new关键字就可以
//格式：类名 对象名 = new 构造方法名(...);
OperatorDemo8POJO student = new OperatorDemo8POJO();
student.show();
//public Student(String name)
OperatorDemo8POJO student2 = new OperatorDemo8POJO("林青霞");
student2.show();
//public Student(int age)
OperatorDemo8POJO student3 = new OperatorDemo8POJO(30);
student3.show();
//public Student(String name,int age)
OperatorDemo8POJO student4 = new OperatorDemo8POJO("林青霞",30);
student4.show();
}
}
案例代码九 标准的类代码和测试 【9.a 学生类】
package com.groupies.base.day06;
/**
* @author GroupiesM
* @date 2021/3/22
* @introduction 标准的学生类
*/
public class OperatorDemo9POJO {
//成员变量
private String name;
private int age;
public OperatorDemo9POJO() {
}
public OperatorDemo9POJO(String name, int age) {
this.name = name;
this.age = age;
}
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;
}
}
案例代码九 标准的类代码和测试 【9.b 学生类的测试类】
package com.groupies.base.day06;
/**
* @author GroupiesM
* @date 2021/3/22
* @introduction 标准的学生类的测试类
*/
public class OperatorDemo9 {
public static void main(String[] args) {
//无参构造方法+setXxx()
OperatorDemo9POJO student = new OperatorDemo9POJO();
student.setName("林青霞");
student.setAge(30);
System.out.println(student.getName()+"---"+student.getAge());
//带参构造方法
OperatorDemo9POJO student2 = new OperatorDemo9POJO("林青霞",30);
System.out.println(student2.getName()+"---"+student2.getAge());
}
}
5 课后练习
5.1 练习1 求长方形周长面积
练习1 【1.a 长方形类】
package com.groupies.base.day06;
/**
* @author GroupiesM
* @date 2021/3/23
* @introduction 长方形类
*
* 需求：定义一个长方形类,定义求周长和面积的方法，然后定义一个测试类进行测试。
* 长方形类：
* 属性：长、宽
* 行为：计算周长的方法、计算面积的方法
* 测试类：
* 测试长方形类中的每一个方法
*
* 要求：按照封装的原则进行定义。并提供无参和全参的构造方法。
*/
public class HomeWork1POJO {
/**长*/
private int length;
/**宽*/
private int wide;
public HomeWork1POJO(int length, int wide) {
this.length = length;
this.wide = wide;
}
public int getLength() {
return length;
}
public void setLength(int length) {
this.length = length;
}
public int getWide() {
return wide;
}
public void setWide(int wide) {
this.wide = wide;
}
/**
* @introduction 计算面积的方法
* @return 长方形面积
*/
public int area() {
return length * wide;
}
/**
* @introduction 计算周长的方法
* @return 长方形周长
*/
public int perimeter() {
return (length + wide) * 2;
}
}
练习1 【1.b 长方形类的测试类】
package com.groupies.base.day06;
/**
* @author GroupiesM
* @date 2021/3/23
* @introduction 长方形类的测试类
*
* 需求：定义一个长方形类,定义求周长和面积的方法，然后定义一个测试类进行测试。
* 长方形类：
* 属性：长、宽
* 行为：计算周长的方法、计算面积的方法
* 测试类：
* 测试长方形类中的每一个方法
*
* 要求：按照封装的原则进行定义。并提供无参和全参的构造方法。
*/
public class HomeWork1 {
public static void main(String[] args) {
HomeWork1POJO rectangle = new HomeWork1POJO(3, 4);
int area = rectangle.area();
int perimeter = rectangle.perimeter();
System.out.println("长方形面积为：" + area + "\r\n长方形周长为：" + perimeter);
}
}
5.2 练习2 显示员工信息
练习2 【2.a 员工类】
package com.groupies.base.day06;
/**
* @author GroupiesM
* @date 2021/3/23
* @introduction 员工类
*
* 需求：
* 定义一个员工类：
* 属性：姓名name,工号id,工资salary
* 行为：一个显示所有成员信息的方法
* 测试类：
* 测试员工类中的每一个方法
*/
public class HomeWork2POJO {
/**姓名*/
private String name;
/**工号*/
private int id;
/**工资*/
private double salary;
/**
* @introduction 无参构造
*/
public HomeWork2POJO() {
}
public HomeWork2POJO(String name, int id, double salary) {
this.name = name;
this.id = id;
this.salary = salary;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public double getSalary() {
return salary;
}
public void setSalary(double salary) {
this.salary = salary;
}
public void information() {
System.out.println("员工姓名:" + name + "\r\n员工工号:" + id + "\r\n员工工资:" + salary);
}
}
练习2 【2.b 员工类的测试类】
package com.groupies.base.day06;
/**
* @author GroupiesM
* @date 2021/3/23
* @introduction 员工类的测试类
*
* 需求：
* 定义一个员工类：
* 属性：姓名name,工号id,工资salary
* 行为：一个显示所有成员信息的方法
* 测试类：
* 测试员工类中的每一个方法
*/
public class HomeWork2 {
public static void main(String[] args) {
HomeWork2POJO staff = new HomeWork2POJO("林青霞", 12512362, 1234.56);
/*
员工姓名:林青霞
员工工号:12512362
员工工资:1234.56
*/
staff.information();
}
}
5.3 练习3 键盘录入学员信息并打印
练习3 【3.a 学员类】
package com.groupies.base.day06;
/**
* @author GroupiesM
* @date 2021/3/23
* @introduction 学员类
*
* 分析以下需求，并用代码实现
* 1,实现从控制台接收一个学员信息，并存储到一个对象中
* 2,打印这个对象的所有属性值。
*
*
* 操作步骤描述
* 1,设计，并定义一个学员类：Student，要求有以下属性：
* 学员编号（String）
* 姓名（String）
* 性别（String）
* 身高（double）
* 年龄（int）
* 使用封装的原则，并提供无参和全参的构造方法。
* 2,定义MainApp类，并包含main()方法。
* 3,程序启动后，应分别提示用户输入学员编号、姓名等信息。
* 例如控制台显示：
* C:\>请输入学员编号：
* C:\>....
* C:\>请输入学员姓名：
* C:\>....
* .................
* 4,数据接收到程序中，并定义局部变量存储；
* 5,创建Student对象，通过构造方法将所有数据存储到Student对象中；
* 6,打印对象中的每个属性值。
*/
public class HomeWork3POJO {
/**学员编号*/
private String ID;
/**姓名*/
private String name;
/**性别*/
private String gender;
/**身高*/
private int height;
/**年龄*/
private int age;
/**
* @introduction 无参构造方法
*/
public HomeWork3POJO() {
}
/**
* @introduction 全参构造方法
* @param ID 学员编号
* @param name 姓名
* @param gender 性别
* @param height 身高
* @param age 年龄
*/
public HomeWork3POJO(String ID, String name, String gender, int height, int age) {
this.ID = ID;
this.name = name;
this.gender = gender;
this.height = height;
this.age = age;
}
public String getID() {
return ID;
}
public void setID(String ID) {
this.ID = ID;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getGender() {
return gender;
}
public void setGender(String gender) {
this.gender = gender;
}
public double getHeight() {
return height;
}
public void setHeight(int height) {
this.height = height;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
/**
* @introduction 打印学员信息
*/
public void information() {
System.out.println("学生编号:" + ID);
System.out.println("姓名:" + name);
System.out.println("性别:" + gender);
System.out.println("身高:" + height);
System.out.println("年龄:" + age);
}
}
练习3 【3.a 学员类的测试类】
package com.groupies.base.day06;
import java.util.Scanner;
/**
* @author GroupiesM
* @date 2021/3/23
* @introduction 学员类的测试类
*
* 分析以下需求，并用代码实现
* 1,实现从控制台接收一个学员信息，并存储到一个对象中
* 2,打印这个对象的所有属性值。
*
*
* 操作步骤描述
* 1,设计，并定义一个学员类：Student，要求有以下属性：
* 学员编号（String）
* 姓名（String）
* 性别（String）
* 身高（double）
* 年龄（int）
* 使用封装的原则，并提供无参和全参的构造方法。
* 2,定义MainApp类，并包含main()方法。
* 3,程序启动后，应分别提示用户输入学员编号、姓名等信息。
* 例如控制台显示：
* C:\>请输入学员编号：
* C:\>....
* C:\>请输入学员姓名：
* C:\>....
* .................
* 4,数据接收到程序中，并定义局部变量存储；
* 5,创建Student对象，通过构造方法将所有数据存储到Student对象中；
* 6,打印对象中的每个属性值。
*/
public class HomeWork3 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入学员编号");
String ID = sc.next();
System.out.println("请输入学员姓名");
String name = sc.next();
System.out.println("请输入学员性别");
String gender;
while (true) {
gender = sc.next();
if (!gender.equals("男") && !gender.equals("女")) {
System.out.println("请重新输入学员性别（男/女）");
} else {
break;
}
}
System.out.println("请输入学员身高(cm)");
String height = sc.next();
//正则表达式校验数值
while (true) {
if (!height.matches("\\d+")) {
System.out.println("请输入学员身高(cm)");
height = sc.next();
} else if (Integer.valueOf(height) < 0 || Integer.valueOf(height) > 250) {
System.out.println("请输入合理的身高");
height = sc.next();
} else {
break;
}
}
System.out.println("请输入学员年龄");
String age = sc.next();
//正则表达式校验数值
while (true) {
if (!age.matches("\\d+")) {
System.out.println("请输入学员年龄");
age = sc.next();
} else if (Integer.valueOf(age) < 0 || Integer.valueOf(age) > 200) {
System.out.println("请输入合理的年龄值");
age = sc.next();
} else {
break;
}
}
HomeWork3POJO student = new HomeWork3POJO(ID, name, gender, Integer.valueOf(height), Integer.valueOf(age));
student.information();
}
}
5.4 练习4 调用老师类和学生类的成员方法
练习4 【4.a 老师类】
package com.groupies.base.day06;
/**
* @author GroupiesM
* @date 2021/3/23
* @introduction 老师类
*
* 分析以下需求，并用代码实现
* 1.老师类Teacher
* 属性:
* 姓名name
* 年龄age
* 讲课内容content
* 行为:
* 吃饭
* 讲课
* 2.学生类Student
* 属性:
* 姓名name
* 年龄age
* 学习内容content
* 行为:
* 吃饭eat()
* 学习study()
* 要求:
* 1.按照以上要求定义Teacher类和Student类,属性要私有,生成空参、有参构造，setter和getter方法
* 2.定义测试类,在main方法中创建该类的对象并给属性赋值(演示两种方法:setter方法和构造方法)
* 3.调用成员方法,打印格式如下:
* 年龄为30的周志鹏老师正在吃饭....
* 年龄为30的周志鹏老师正在亢奋的讲着Java基础中面向对象的知识........("Java基础中面向对象"代表老师讲课的内容)
* 年龄为18的韩光同学正在吃饭....
* 年龄为18的韩光同学正在专心致志的听着面向对象的知识....("面向对象"代表学生学习的内容)
*/
public class HomeWork4POJOTeacher {
/**姓名*/
private String name;
/**年龄*/
private int age;
/**讲课内容*/
private String content;
/**
* @introduction 无参构造方法
*/
public HomeWork4POJOTeacher() {
}
/**
* @introduction 全参构造方法
* @param name 姓名
* @param age 年龄
* @param content 讲课内容
*/
public HomeWork4POJOTeacher(String name, int age, String content) {
this.name = name;
this.age = age;
this.content = content;
}
/**
* * 年龄为30的周志鹏老师正在吃饭....
* * 年龄为30的周志鹏老师正在亢奋的讲着Java基础中面向对象的知识........("Java基础中面向对象"代表老师讲课的内容)
*/
public void eat() {
System.out.println("年龄为" + age + "的" + name + "老师正在吃饭....");
}
public void teach() {
System.out.println("年龄为" + age + "的" + name + "老师正在亢奋的讲着" + content + "的知识........");
}
}
练习4 【4.b 学生类】
package com.groupies.base.day06;
/**
* @author GroupiesM
* @date 2021/3/23
* @introduction 学生类
*
* 分析以下需求，并用代码实现
* 1.老师类Teacher
* 属性:
* 姓名name
* 年龄age
* 讲课内容content
* 行为:
* 吃饭
* 讲课
* 2.学生类Student
* 属性:
* 姓名name
* 年龄age
* 学习内容content
* 行为:
* 吃饭eat()
* 学习study()
* 要求:
* 1.按照以上要求定义Teacher类和Student类,属性要私有,生成空参、有参构造，setter和getter方法
* 2.定义测试类,在main方法中创建该类的对象并给属性赋值(演示两种方法:setter方法和构造方法)
* 3.调用成员方法,打印格式如下:
* 年龄为30的周志鹏老师正在吃饭....
* 年龄为30的周志鹏老师正在亢奋的讲着Java基础中面向对象的知识........("Java基础中面向对象"代表老师讲课的内容)
* 年龄为18的韩光同学正在吃饭....
* 年龄为18的韩光同学正在专心致志的听着面向对象的知识....("面向对象"代表学生学习的内容)
*/
public class HomeWork4POJOStudent {
/**姓名*/
private String name;
/**年龄*/
private int age;
/**学习内容*/
private String content;
/**
* @introduction 无参构造方法
*/
public HomeWork4POJOStudent() {
}
/**
* @introduction 全参构造方法
* @param name 姓名
* @param age 年龄
* @param content 学习内容
*/
public HomeWork4POJOStudent(String name, int age, String content) {
this.name = name;
this.age = age;
this.content = content;
}
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 String getContent() {
return content;
}
public void setContent(String content) {
this.content = content;
}
/**
* @introduction 行为：吃饭
*/
public void eat() {
System.out.println("年龄为" + age + "的" + name + "同学正在吃饭....");
}
/**
* @introduction 行为：学习
*/
public void study() {
System.out.println("年龄为" + age + "的" + name + "同学正在专心致志的听着" + content + "的知识........");
}
}
练习4 【4.c 老师类和学生类的测试类】
package com.groupies.base.day06;
/**
* @author GroupiesM
* @date 2021/3/23
* @introduction 老师类和学生类的测试类
*
* 分析以下需求，并用代码实现
* 1.老师类Teacher
* 属性:
* 姓名name
* 年龄age
* 讲课内容content
* 行为:
* 吃饭
* 讲课
* 2.学生类Student
* 属性:
* 姓名name
* 年龄age
* 学习内容content
* 行为:
* 吃饭eat()
* 学习study()
* 要求:
* 1.按照以上要求定义Teacher类和Student类,属性要私有,生成空参 、有参构造，setter和getter方法
* 2.定义测试类,在main方法中创建该类的对象并给属性赋值(演示两种方法:setter方法和构造方法)
* 3.调用成员方法,打印格式如下:
* 年龄为30的周志鹏老师正在吃饭....
* 年龄为30的周志鹏老师正在亢奋的讲着Java基础中面向对象的知识........("Java基础中面向对象"代表老师讲课的内容)
* 年龄为18的韩光同学正在吃饭....
* 年龄为18的韩光同学正在专心致志的听着面向对象的知识....("面向对象"代表学生学习的内容)
*/
public class HomeWork4 {
public static void main(String[] args) {
HomeWork4POJOStudent student = new HomeWork4POJOStudent("林青霞", 66, "面向对象");
HomeWork4POJOTeacher teacher = new HomeWork4POJOTeacher("周伯通", 99, "java基础");
student.eat();//年龄为66的林青霞同学正在吃饭....
student.study();//年龄为66的林青霞同学正在专心致志的听着面向对象的知识........
teacher.eat();//年龄为99的周伯通老师正在吃饭....
teacher.teach();//年龄为99的周伯通老师正在亢奋的讲着java基础的知识........
}
}
21/03/22
M
3万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
