第六章 封装和继承 ② 代码部分
- 1.java中的封装 0701
- 2.继承1 overrides(方法重写) @Override注解 overload(方法重载)->（前边讲过）
- 3.继承2 改造父类方法(扩展)->方法重写 默认原则：必须先有父再有子。
- 4.继承3 有参构造/无参构造的继承
- 5.案例分析 学生老师信息管理
- 1.编写代码结构/顺序 0702
- 2.课前测试 Car/Bus/Taxi/Test
- 3.对象作为参数 Dog/Money/Feeder/Test
- 对象作为参数 实例 Car/Bus/Taxi/Driver/Test
- 4.方法重写 @Override注解
- 5.基本类型对应的包装类
- 6. final关键字
- 7.作业3 方法重写
- 8.作业4 子类通过super.getXxx()调用父类的私有变量
- 9.作业5 类中定义属性变量：对象
1.java中的封装 0701
package com.yzh7.test1;
/**
* @author: hy
* @create: 2022-07-01 10:00:48
*/
public class Student {
private String name;
private int age;
public Student(){}
public Student(String name,int age){
//this.name=name;
//this.age=age;
this.setName(name);
this.setAge(age);
}
public void introduce() {
System.out.println(this.name+" "+this.age);
}
//提供针对属性操作的getter,setter方法
//setter方法:用于设置属性值
public void setName(String name){
this.name=name;
}
//getter方法:用于获取属性值
public String getName(){
return this.name;
}
//针对年龄的getter,setter
public void setAge(int age){
//在setter方法中添加判断逻辑
if (age<0 ||age >120){
System.out.println("年龄不合法，无法设值");
}else {
this.age = age;
}
}
public int getAge(){
return this.age;
}
}
package com.yzh7.test1;
/**
* @author: hy
* @create: 2022-07-01 10:01:04
*/
public class Test {
public static void main(String[] args) {
//创建学对象
//Student s = new Student();
//s.name="张三";
//s.age=-18;
//自我介绍
//s.introduce();
//属性封装:针对属性进行保护，避免出现非法数据
//问题：因为可以直接访问属性，导致进行非法赋值
//解决:1.将属性变为私有
// 2.提供针对属性的getter,setter方法
// 3.在setter方法中添加判断逻辑
Student s = new Student();
s.setName("张三");
s.setAge(-18);
//System.out.println(s.getName());
//System.out.println(s.getAge());
s.introduce();
//调用构造赋值
Student s2 = new Student("李四",-20);
s2.introduce();
}
}
2.继承1 overrides(方法重写) @Override注解 overload(方法重载)->（前边讲过）
package com.yzh7.test2;
/**
* @author: hy
* @create: 2022-07-01 10:48:58
*/
public class Father {
int money = 500;
public Object liveHouse(){
System.out.println("住80年代红砖瓦房.....");
return "xxx";
}
}
package com.yzh7.test2;
/**
* @author: hy
* @create: 2022-07-01 10:49:09
*/
//extends:继承 儿子继承父亲,可以拥有父类非私有的属性和方法
public class Son extends Father{
//overrides(重写):子类可以重写父类方法
public String liveHouse(){
System.out.println("住1000万海景洋房....");
return "aaa";
}
//儿子可以有自己的方法
public void driveCar(){
System.out.println("儿子开跑车");
}
}
package com.yzh7.test2;
/**
* @author: hy
* @create: 2022-07-01 10:49:16
*/
public class Test {
public static void main(String[] args) {
Son son = new Son();
System.out.println("儿子有钱:"+son.money);
//儿子重写了父类方法，此时调用的是子类方法
son.liveHouse();
son.driveCar();
//overrides(方法重写)
//子类继承父类，定义与父类一样的方法，则称为子类重写了父类方法
//重写方法的特征
//a.子类方法与父类方法的方法名一样，参数一样(个数，类型，次序)
//b.子类方法的返回值必须和父类保持一致,子类的返回值要么与父类一样，或者是父类返回值的子类
//c.子类方法的访问修饰符，必须等于或大于父类方法的访问修饰符
//d.子类方法抛出的异常声明，不能超出父类异常声明的范围
//overload(方法重载)
//在同一个类中，方法名相同，参数不同(个数，类型，次序)
//与参数名，返回值，访问修饰符无关
}
}
3.继承2 改造父类方法(扩展)->方法重写 默认原则：必须先有父再有子。
package com.yzh7.test3;
/**
* @author: hy
* @create: 2022-07-01 11:05:59
*/
public class Fu {
int money=500;
String xingshi;
// public Fu(){
//
// }
//父类构造，传入姓氏
public Fu(String xingshi){
this.xingshi=xingshi;
}
public void liveHouse(){
System.out.println("红砖房....");
}
}
package com.yzh7.test3;
/**
* @author: hy
* @create: 2022-07-01 11:06:06
*/
public class Zi extends Fu{
//在继承关系中的构造特点（满足先有父，再有子原则）:
//1.子类的构造会默认调用父类的无参构造，以满足先有父再有子的原则。
//2.当父类没有无参构造，只有有参构造的时候，我们需要在子类构造的
// 第一行代码处，使用super关键字显示调用父类构造
public Zi(){
//必须在子类构造中，调用父类构造
super("张");
System.out.println("xxxxx");
}
public Zi(String xingshi){
//子类的每个构造都要调用父类构造
super(xingshi);
}
//子类要改造父类方法(扩展)->方法重写
public void liveHouse(){
//this:代表当前类对象
//super:代表父类对象
//调用父类方法
super.liveHouse();
System.out.println("住海景洋房....");
}
}
效果图如下：
//1.子类的构造会默认调用父类的无参构造，以满足先有父再有子的原则。
//2.当父类没有无参构造，只有有参构造的时候，我们需要在子类构造的
package com.yzh7.test3;
/**
* @author: hy
* @create: 2022-07-01 11:06:11
*/
public class Test {
public static void main(String[] args) {
Zi zi = new Zi();
System.out.println(zi.money);
zi.liveHouse();
//overrides(方法重写)
//子类继承父类，定义与父类一样的方法，则称为子类重写了父类方法
//重写方法的特征
//a.子类方法与父类方法的方法名一样，参数一样(个数，类型，次序)
//b.子类方法的返回值必须和父类保持一致,子类的返回值要么与父类一样，或者是父类返回值的子类
//c.子类方法的访问修饰符，必须等于或大于父类方法的访问修饰符
//d.子类方法抛出的异常声明，不能超出父类异常声明的范围
//overload(方法重载)
//在同一个类中，方法名相同，参数不同(个数，类型，次序)
//与参数名，返回值，访问修饰符无关
//在继承关系中，要满足，先满足先有父，再有子的原则（无父无子）
//1.在父子继承关系中，当创建子类对象的时候，会默认调用父类的无参构造，先创建父类对象
//2.如果父类没有无参构造,此时需要在子类构造中的第一行代码处，显示调用父类构造
}
}
4.继承3 有参构造/无参构造的继承
package com.yzh7.test4;
/**
* @author: hy
* @create: 2022-07-01 11:29:12
*/
public class ClsA {
// public ClsA(){
//
// }
public ClsA(String str){
System.out.println("调用了A的无参构造:"+str);
}
}
package com.yzh7.test4;
/**
* @author: hy
* @create: 2022-07-01 11:29:25
*/
public class ClsB extends ClsA{
public ClsB(String str){
//默认调用父类的无参构造
//super();
super(str);
System.out.println("调用了B的构造");
}
}
package com.yzh7.test4;
/**
* @author: hy
* @create: 2022-07-01 11:46:23
*/
public class ClsC extends ClsA{
public ClsC(String str) {
//父类没有无参构造，子类必须显示调用父类构造
super(str);
}
}
package com.yzh7.test4;
/**
* @author: hy
* @create: 2022-07-01 11:30:06
*/
public class Test {
public static void main(String[] args) {
new ClsB("aaaa");
}
}
5.案例分析 学生老师信息管理
package com.yzh7.test5;
/**
* @author: hy
* @create: 2022-07-01 12:01:03
*/
public class People {
String name;
String sex;
int age;
public People(String name,String sex,int age){
this.name=name;
this.sex=sex;
this.age=age;
}
public void introduce(){
System.out.println("===================");
System.out.println(this.name+" "+this.sex+" "+this.age);
}
}
package com.yzh7.test5;
/**
* @author: hy
* @create: 2022-07-01 11:58:41
*/
public class Student extends People{
public Student(String name,String sex,int age){
//调用父类构造
super(name,sex,age);
}
}
package com.yzh7.test5;
/**
* @author: hy
* @create: 2022-07-01 11:59:32
*/
public class Teacher extends People{
//老师个性化的属性
//学历
String edu;
//职称
String pos;
//alt+insert ->contructor
public Teacher(String name, String sex, int age, String edu, String pos) {
super(name,sex,age);
this.edu = edu;
this.pos = pos;
}
public void introduce(){
//System.out.println(this.name+" "+this.sex+" "+this.age);
super.introduce();
System.out.println(this.edu+" "+this.pos);
}
}
package com.yzh7.test5;
/**
* @author: hy
* @create: 2022-07-01 12:03:05
*/
public class Test {
public static void main(String[] args) {
Student s = new Student("张三","男",20);
s.introduce();
Teacher t = new Teacher("李老师","女",29,"研究生","讲师");
t.introduce();
}
}
1.编写代码结构/顺序 0702
结构/先后顺序：结构：属性 构造 成员方法 getName(){…} setName(String name){…}
面向对象编程 必须画图 图一画思路就清晰了
2.课前测试 Car/Bus/Taxi/Test
思路图：
项目文件路径：
代码如下：
package com.yzh7.test1;
/**
* @author: hy
* @create: 2022-07-02 09:24:15
*/
public class Car {
protected String name;
protected String color;
public Car(String name, String color) {
this.name = name;
this.color = color;
}
public void run(){
System.out.println("汽车跑");
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
}
上方代码为何要使用getName(){}和setName(){}:
想要了解更具体详细信息，请参考：第六章 封装和继承 ① 笔记
package com.yzh7.test1;
/**
* @author: hy
* @create: 2022-07-02 09:26:19
*/
public class Bus extends Car{
//最大载客量
private int maxNum;
//alt+insert 生成代码:构造方法，getter,setter,方法重写，toString
//alt+enter 修复错误
public Bus(String name, String color,int maxNum) {
//调用父类构造,满足先有父再有子的原则
super(name, color);
this.maxNum=maxNum;
}
//@Override:在编译的时候,系统帮你检查对应方法是否实现了重写
@Override
public void run() {
System.out.println(this.color+"的,载客量"+this.maxNum+"的"+this.name+"开往下一站");
}
public int getMaxNum() {
return maxNum;
}
public void setMaxNum(int maxNum) {
this.maxNum = maxNum;
}
}
//alt+insert 生成代码:构造方法，getter,setter,方法重写，toString
//alt+enter 修复错误
package com.yzh7.test1;
/**
* @author: hy
* @create: 2022-07-02 09:35:25
*/
public class Taxi extends Car{
//所属公司
private String company;
public Taxi(String name, String color,String company) {
super(name, color);
this.company=company;
}
@Override
public void run() {
System.out.println(this.color+"的"+this.company+this.name+"将客人拉往目的地");
}
public String getCompany() {
return company;
}
public void setCompany(String company) {
this.company = company;
}
}
package com.yzh7.test1;
/**
* @author: hy
* @create: 2022-07-02 09:36:17
*/
public class Test {
public static void main(String[] args) {
Bus bus = new Bus("公交车","白色",25);
bus.run();
Taxi taxi = new Taxi("出租车","绿色","大众");
taxi.run();
}
}
3.对象作为参数 Dog/Money/Feeder/Test
代码的路径如下如所示：
代码如下：
package com.yzh7.test2;
/**
* @author: hy
* @create: 2022-07-02 09:45:11
*/
public class Dog {
public void catchFly(){
System.out.println("小狗抓飞盘");
}
}
package com.yzh7.test2;
/**
* @author: hy
* @create: 2022-07-02 09:45:15
*/
public class Money {
public void tuiChe(){
System.out.println("小猴推小车");
}
}
package com.yzh7.test2;
/**
* @author: hy
* @create: 2022-07-02 09:44:59
*/
//饲养员
public class Feeder {
public void train(Dog dog){
System.out.println("饲养员训练小狗");
dog.catchFly();
}
public void train(Money money){
System.out.println("饲养员循环小猴");
money.tuiChe();
}
}
package com.yzh7.test2;
/**
* @author: hy
* @create: 2022-07-02 09:46:59
*/
public class Test {
public static void main(String[] args) {
Feeder feeder = new Feeder();
feeder.train(new Dog());
feeder.train(new Money());
}
}
运行结果如下：
#pic_center
对象作为参数 实例 Car/Bus/Taxi/Driver/Test
图片、代码的路径如下如所示：
代码如下：
package com.yzh70702;
/**
* @author: XYT
* @create-date: 2022/7/2 9:05
*/
public class Car {
protected String name;
protected String color;
public Car(String name,String color){
this.name=name;
this.color=color;
}
public void run(){
System.out.println("*************");
}
}
package com.yzh70702;
/**
* @author: XYT
* @create-date: 2022/7/2 9:02
*/
public class Bus extends Car{
private int maxNum;
public Bus(String name,String color,int maxNum){ //父类两个变量
super(name,color);
this.maxNum=maxNum;
}
public void run(){
//super.run();
System.out.println("载客量"+maxNum+"的"+color+name+"开往下一站");
}
public int getMaxNum() {
return maxNum;
}
public void setMaxNum(int maxNum) {
this.maxNum = maxNum;
}
}
package com.yzh70702;
/**
* @author: XYT
* @create-date: 2022/7/2 9:07
*/
public class Taxi extends Car{
private String company;
public Taxi(String name, String color, String company){
super(name,color);
this.company=company;
}
public void run(){
System.out.println(color+"的"+company+name+"将客人拉往开目的地");
}
//alt+insert快捷键生成getter,setter
public void setCompany(String company) {
this.company = company;
}
public String getCompany() {
return company;
}
}
package com.yzh70702;
/**
* @author: XYT
* @create-date: 2022/7/2 9:58
*/
public class Driver {
private String name;
// public Driver(){
// System.out.println("司机"+name);
// }
public Driver(String name){ //该构造方法的意义:在于将形参上传到类的直属属性变量，然后类的成员方法调用类的直属属性变量;同时该类创建对象的时候，可以直接传参。
this.name=name;
// System.out.println("司机"+name);
}
public void driver(Bus bus){
System.out.print("司机"+name);
bus.run();
}
public void driver(Taxi taxi){
System.out.print("司机"+name);
taxi.run();
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
}
package com.yzh70702;
/**
* @author: XYT
* @create-date: 2022/7/2 9:09
*/
public class Test {
public static void main(String[] args) {
Bus b=new Bus("公共汽车","绿色",50);
//b.run();
Taxi t=new Taxi("出租车","黄色","大众");
//t.run();
Driver dr=new Driver("张三");
dr.driver(b);
dr.driver(t);
}
}
运行结果如下：
4.方法重写 @Override注解
代码的路径如下如所示：
代码如下：
package com.yzh7.test4;
/**
* @author: hy
* @create: 2022-07-02 10:20:07
*/
public class Student{
//属性
private String name;
private String sex;
private int age;
//无参构造
public Student() {
}
//有参构造
public Student(String name, String sex, int age) {
this.name = name;
this.sex = sex;
this.age = age;
}
//getter,setter
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
//重写Object toString方法
// @Override
// public String toString() {
// return this.name+" "+this.sex+" "+this.age ;
// }
//重写toString:用于输出对象的属性内容，方便调试查看
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", sex='" + sex + '\'' +
", age=" + age +
'}';
}
}
package com.yzh7.test4;
/**
* @author: hy
* @create: 2022-07-02 10:19:52
*/
public class Test {
public static void main(String[] args) {
int num = 100;
String str = "abc";
Student s = new Student("张三","男",20);
System.out.println(num);
System.out.println(str);
System.out.println(s);
//ctrl+鼠标点击 查看代码内容
//toString():默认调用Object中toString返回类型名@内存地址
//String res = s.toString();
//System.out.println(res);
}
}
运行结果如下：
#pic_center
5.基本类型对应的包装类
图片、代码的路径如下如所示：
代码如下：
package com.yzh7.test5;
/**
* @author: hy
* @create: 2022-07-02 10:34:42
*/
public class Test {
public static void main(String[] args) {
//int num = 10;
//double d= 1.234;
//基本类型都有对应的对象类型(包装类)
//int Integer ,byte Byte ,short Short ,long Long
//float Float, double Double
//char Character
//boolean Boolean
//int n1 = 10;
//int n2 = 20;
//System.out.println(n1-n2);
//Integer x = 20;
//Integer y = 30;
//System.out.println(x-y);
//int x = 10;
//Integer y = 20;
//x = y;
//y = x;
//System.out.println(x+" "+y);
//包装类除了具有基本类型的基本功能，并且和基本类型相互操作。还有额外的属性和方法
//输出整数的最大值
//System.out.println(Integer.MAX_VALUE);
//System.out.println(Integer.MIN_VALUE);
/*
//方法
//将字符串转为Integer
String s = "222";
Integer num = Integer.valueOf(s);
//将字符串转为int
int num2 = Integer.parseInt(s);
//将int转为Integer
Integer x= Integer.valueOf(100);
System.out.println(num+" "+num2+" "+x);
*/
/*double d = 1.23;
Double d2 = 234.234;
d = d2;
System.out.println(d+" "+d2);
d2 = d;
System.out.println(d+" "+d2);*/
//System.out.println(Double.MAX_VALUE);
//System.out.println(Double.MIN_VALUE);
//方法
//将字符串转为double
double d = Double.parseDouble("123.123");
//将字符串转为Double
Double d2 = Double.valueOf("23.234");
//System.out.println(d+" "+d2);
String s = Double.toString(234.234);
//System.out.println(s);
//基本类型之间可以自动类型转换
int n = 10;
double m = 2.34;
m = n;
//不同类型的包装类无法直接转换
Integer n1 = 10;
Double m1 = 2.34;
//m1 = n1;
//Integer的比较问题
//int aaa = 1000;
//int bbb = 1000;
//-128到127之间都是整形常量数组中的同一个数据
//超出这个范围的数据，都是new出来的对象
//包装类判断相等性都要用equals
Integer aaa = Integer.valueOf(200);
Integer bbb = Integer.valueOf(200);
System.out.println(aaa==bbb);
System.out.println(aaa.equals(bbb));
}
}
运行结果如下：
#pic_center
6. final关键字
代码的路径如下如所示：
代码如下：
package com.yzh7.test6;
/**
* @author: hy
* @create: 2022-07-02 11:13:38
*/
public class Car {
public void run(){
}
}
package com.yzh7.test6;
/**
* @author: hy
* @create: 2022-07-02 11:13:49
*/
public class Bus extends Car{
final int num ;
//静态常量
final static double PI=3.14;
public Bus(){
this.num=100;
//this.num=200;
}
@Override
public void run() {
final int x;
x=10;
//x=20;
System.out.println(x);
}
}
package com.yzh7.test6;
/**
* @author: hy
* @create: 2022-07-02 11:20:18
*/
public class Student {
String name;
int age;
}
package com.yzh7.test6;
/**
* @author: hy
* @create: 2022-07-02 11:16:10
*/
public class Test {
public static void main(String[] args) {
Bus bus = new Bus();
System.out.println(bus.num);
//常量:1.必须赋值 2.赋值之后不能再改变
// 1.全局常量 2.局部常量 3.静态常量
// 1.可以修饰类，则类不能被继承
// 2.修饰方法，则方法不能被重写
// 3.修改变量，则变量不能被重新赋值
final Student s = new Student();
//s中的属性并没有被final修饰，所以可以改变
s.name="xxx";
s.age=20;
//
s.name="bbb";
s.age=23;
//final s不能指向新对象
//s = new Student();
}
}
运行结果如下：
#pic_center
7.作业3 方法重写
代码的路径如下如所示：
代码如下：
package com.yzh70702.zuoye3;
/**
* @author: XYT
* @create-date: 2022/7/3 17:49
*/
public class Animal {
protected String name;
public Animal(String name) {
this.name = name;
}
public void eat(){
System.out.println("吃。。。。。");
}
public void sleep(){
System.out.println(name+"睡觉！！！！");
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
}
package com.yzh70702.zuoye3;
/**
* @author: XYT
* @create-date: 2022/7/3 17:49
*/
public class Tiger extends Animal{
public Tiger(String name) {
super(name);
}
@Override
public void eat() {
System.out.println(name+"吃肉");
}
}
package com.yzh70702.zuoye3;
/**
* @author: XYT
* @create-date: 2022/7/3 17:49
*/
public class Rabbit extends Animal{
public Rabbit(String name) {
super(name);
}
@Override
public void eat() {
System.out.println(name+"吃草");
}
}
package com.yzh70702.zuoye3;
/**
* @author: XYT
* @create-date: 2022/7/3 17:50
*/
public class AnimalTest {
public static void main(String[] args) {
Tiger tig=new Tiger("老虎");
tig.eat();
tig.sleep();
Rabbit rab=new Rabbit("兔子");
rab.eat();
rab.sleep();
}
}
运行结果如下：
8.作业4 子类通过super.getXxx()调用父类的私有变量
代码的路径如下如所示：
代码如下：
package com.yzh70702.zuoye4;
/**
* @author: XYT
* @create-date: 2022/7/3 18:19
*/
public class MyPet {
private String name;
private int age;
private String color;
public MyPet(String name, int age, String color) {
this.name = name;
this.age = age;
this.color = color;
}
public void playWithOwner(){
System.out.println(age+"岁的"+color+name+"和主人一起玩");
}
public void setName(String name) {
this.name = name;
}
public void setAge(int age) {
this.age = age;
}
public void setColor(String color) {
this.color = color;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
public String getColor() {
return color;
}
}
package com.yzh70702.zuoye4;
/**
* @author: XYT
* @create-date: 2022/7/3 18:19
*/
public class Dog extends MyPet{
private String species;
public Dog(String name, int age, String color ,String species) {
super(name, age, color);
this.species=species;
}
public void kanmen(){
System.out.println(super.getAge()+"岁的"+super.getColor()+species+"的"+super.getName()+"看门");
//本题中，父类的属性变量为私有，子类如果想要调用父类属性变量值的话，只能通过super.getXxx()
}
public void setSpecies(String species) {
this.species = species;
}
public String getSpecies() {
return species;
}
}
package com.yzh70702.zuoye4;
/**
* @author: XYT
* @create-date: 2022/7/3 18:20
*/
public class Cat extends MyPet{
private double weight;
public Cat(String name, int age, String color, double weight) {
super(name, age, color);
this.weight=weight;
}
public void zhulaoshu(){
System.out.println(super.getAge()+"岁的"+weight+"斤重的"+super.getColor()+super.getName()+"抓老鼠");
//本题中，父类的属性变量为私有，子类如果想要调用父类属性变量值的话，只能通过super.getXxx()
}
public void setWeight(double weight) {
this.weight = weight;
}
public double getWeight() {
return weight;
}
}
package com.yzh70702.zuoye4;
/**
* @author: XYT
* @create-date: 2022/7/3 18:20
*/
public class Test {
public static void main(String[] args) {
Dog dog=new Dog("柯基",1,"白色","纯种");
dog.kanmen();
dog.playWithOwner();
Cat cat=new Cat("橘猫",2,"橘黄色",2);
cat.zhulaoshu();
cat.playWithOwner();
}
}
运行结果如下：
9.作业5 类中定义属性变量：对象
代码的路径如下如所示：
代码如下：
package com.yzh70702.zuoye5;
/**
* @author: XYT
* @create-date: 2022/7/3 19:58
*/
public class Person {
private String name;
private int age;
private boolean gender;
//private Person parter= new Person("李四",20,false);
//不能这样设置，否则将出现死循环(外部创建的Person对象输入的person2,来和parter作比较，
// parter=new Person(..),而类Person（）拥有属性变量parter..以此类推，造成死循环)
private Person parter;
public Person(){
}
//有参构造
public Person(String name, int age, boolean gender) {
this.name = name;
this.age = age;
this.gender = gender;
}
//创建成员方法进行判断
public boolean isMarry(Person person2){
//性别不同
if(parter.gender!=person2.gender){
//年龄相差不能太大 五岁之内
return parter.age + 5 >= person2.age && person2.age >= parter.age - 5;
}else{
return false;
}
}
public void setName(){
this.name=name;
}
public String getName(){
return name;
}
public void setAge(int age) {
this.age = age;
}
public void setGender(boolean gender) {
this.gender = gender;
}
public void setPerson(Person person) {
this.parter = person;
}
public int getAge() {
return age;
}
public boolean isGender() {
return gender;
}
public Person getPerson() {
return parter;
}
}
package com.yzh70702.zuoye5;
/**
* @author: XYT
* @create-date: 2022/7/3 20:32
*/
public class MarryTest {
public static void main(String[] args) {
Person person=new Person();
Person p1=new Person("李四",20,false);
Person p2=new Person("王五",20,true);
Person p3=new Person("菜龙",21,false);
person.setPerson(p1);
System.out.println(person.isMarry(p1));
System.out.println(person.isMarry(p2));
System.out.println(person.isMarry(p3));
}
}
运行结果如下：
扫一扫
1822
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
