Java学习：类的封装、继承和多态

【3.1】声明日期类及使用日期对象

public class MyDate{ //类声明
int year,month,day; //成员变量，表示年月日
void set(int y,int m,int d) //成员方法、设计日期值
{
year=y;
month=m;
day=d;
}
void set(MyDate d) //将当前对象值设置为参数值，重载
{
set(d.year,d.month,d.day); //调用重载的同名成员方法
}
public String toString()
{
return year+“年”+month+“月”+day+“日”;
}
public static void main(String args[])
{
MyDate d1 = new MyDate(); //声明对象、创建实例、引用赋值
d1.set(2012,1,1); //调用类的成员方法
MyDate d2=d1; //对象引用赋值
System.out.println("d1: “+d1.toString()+”,d2: "+d2.toString());
d2.month=10; //修改示例成员变量值
System.out.println("d1: “+d1+”,d2: "+d2); //输出对象字符串描述，默认调用d1.toString()
d2=new MyDate(); //创建另一个示例
d2.set(d1);
System.out.println("d1: “+d1+”,d2: "+d2);
}
}

【3.2】封装的日期类

public class MyDate{ //共有的类，与源程序文件同名
private int year,month,day; //私有成员变量
private static int thisYear; //当前年份，私有静态成员变量
static
{
thisYear = 2012; //静态成员变量初始化
}
public MyDate(int year,int month,int day) //构造方法、指定日期
{
this.set(year,month,day); //调用本类的成员方法
}
public MyDate() //无参数构造方法，制定默认日期，重载
{
this(1970,1,1); //调用本类已声明的其他构造方法
}
public MyDate(MyDate d) //拷贝构造方法，日期同参数，重载
{
this.set(d);
}
public void set(int year,int month,int day) //设置日期值，算法不全
{
this.year=year; //this.year值当前对象的成员变量，year值参数
this.month=(month>=1&&month<=12)?month:1;
this.day=(day>=1&&day<=31)?day:1; //this引用不能省略
}
public void set(MyDate d) //设置日期值，重载
{
set(d.year,d.month,d.day); //调用同名成员方法，不能使用this()
}
public int getYear() //获得年份
{
return this.year;
}
public int getMonth() {return this.month;} //获得月份
public int getDay() {return this.day;} //获得当月日期
public String toString() //返回中文日期字符串，月日占两位
{
return year+“年”+String.format("%02d",month)+“月”+String.format("%02d",day)+“日”;
}
public static int getThisYear() //获得今年年份，静态方法
{
return thisYear;
}
public static boolean isLeapYear(int year) //判断指定年份是否闰年，静态方法
{
return year%4000||year%100!=0&&year%40;
}
public boolean isLeapYear() //判断当前日期的年份是否闰年，重载
{
return isLeapYear(this.year);
}
public boolean equals(MyDate d) //比较当前日期值与d是否相等
{
return thisd||d!=null&&this.yeard.year&&this.monthd.month&&this.dayd.day;
}
public static int daysOfMonth(int year,int month) //返回指定年月的天数，静态方法
{
switch(month) //计算每月的天数
{
case 1:case 3:case 5:case 7:case 8:case 10:case 12:return 31;
case 4:case 6:case 9:case 11:return 30;
case 2:return MyDate.isLeapYear(year)?29:28;
default:return 0;
}
}
public int daysOfMonth() //返回当月天数
{
return daysOfMonth(this.year,this.month);
}
public void tomorrow() //当前日期改为之后一天日期
{
this.day++; //改变this引用的实例值。没有返回值
if(this.day>this.daysOfMonth())
{
this.day=1;
this.month++;
if(this.month>12)
{
this.month=1;
this.year++;
}
}
}
public MyDate yesterday() //当前日期改为之前一天日期
{
MyDate date= new MyDate(this); //执行拷贝构造方法，创建实例，没有改变this
date.day–;
if(date.day0)
{
date.month–;
if(date.month0)
{
date.month=12;
date.year–;
}
date.day=daysOfMonth(date.year,date.month);
}
return date;
}
}

class MyDate_ex {
public static void main(String args[])
{
System.out.println(“今年是”+MyDate.getThisYear()+",闰年？"+MyDate.isLeapYear(MyDate.getThisYear()));
MyDate d1=new MyDate(2012,12,31);
MyDate d2=new MyDate(d1); //调用拷贝构造方法复制实例
System.out.println("d1: “+d1+”,d2: “+d2+“d1d2?"+(d1d2)+”,d1.equals(d2)?”+d1.equals(d2));
System.out.print(d1+“的明天是 “);
d1.tomorrow();
System.out.println(d1+”\n”+d1+"的昨天是 "+(d2=d1.yesterday()));
}
}

【3.3】Person类，使用对象作为成员变量并实现深拷贝

public class Person {
public String name; //姓名，实例成员变量，保护成员
public MyDate birthday; //生日
public String sex,province,city; //姓名，所在省份，城市
private static int count=0; //静态成员变量，本类及子类实例计数
public Person(String name,MyDate birthday,String sex,String province,String city) //构造方法
{
this.set(name,birthday,sex,province,city); //调用本类声明的成员方法
count++;
}
public Person(String name,MyDate birthday) //构造方法，重载
{
this(name, birthday,"","",""); //调用本类已声明的构造方法
}
public Person() {this("",null); } //构造方法，重载
public Person(Person p) //拷贝构造方法，重载，复制对象
{
this(p.name,new MyDate(p.birthday),p.sex,p.province,p.city); //深拷贝，创建日期实例
}
public void finalize() //析构方法
{
System.out.println(“释放对象（”+this.toString()+")");
Person.count–;
}
//显示对象数，静态成员方法；只能访问静态成员变量，不能访问实例成员，也不能使用this
public static void howMany() { System.out.print(Person.count+“个Person对象，”);}
public void set(String name,MyDate birthday,String sex,String province,String city) //设置属性值
{
this.name=namenull?"":name;
this.birthday=birthday; //引用赋值
this.sex=sexnull?"":sex;
this.province=provincenull?"":province;
this.city=citynull?"":city;
}
//对象的字符串描述，成员变量之间以逗号分隔，若字符串成员变量为null,输出“null”
public String toString()
{
return name+","+(birthday.toString())+","+sex+","+province+","+city;
}
public static void main(String args[]) //main方法也是静态成员方法
{
Person p1=new Person(“李小明”,new MyDate(1997,11,25));
Person p2=new Person(p1); //拷贝构造方法
Person.howMany(); //通过类名调用类成员方法
System.out.println(“p1: “+p1+”; p2: “+p2+”\np1p2? "+(p1p2)+”; p1.namep2.name? "
+(p1.namep2.name)+",p1.birthdayp2.birthday? "+(p1.birthdayp2.birthday));
//显示引用关系
//以下修改p2的姓名和生日
p2.name=“张”+p2.name.substring(1); //改名，一个汉字长度为一个字符
MyDate d=p2.birthday; //获得日期，传递日期对象引用
d.set(d.getYear()+2,d.getMonth(),d.getDay()); //改变日期，设置p2年龄小两岁
System.out.println("p1: “+p1+”; p2: "+p2);
p1.finalize(); //调用析构方法，释放对象
Person.howMany(); //通过类名调用静态成员方法
}
}

【3.4】Student继承Person类
public class Student extends Person { //STudent类继承Person类
private String speciality; //专业，子类增加的成员变量
public static void main(String args[])
{
Person p1=new Person(“李小明”,new MyDate(1992,3,15));
Student s1=new Student(); //默认构造方法，执行父类构造方法Person()
Student.howMany(); //继承父类静态方法，执行Person.howMany
System.out.println(“p1: “+p1.toString()+”;s1: “+s1.toString());
s1.set(“王江”,new MyDate(1987,2,27),””,"",""); //s1调用父类的成员方法
s1.finalize();
Student.howMany();

}

【3.5】Student类重定义父类成员
public class Student extends Person { //STudent类继承Person类
private String department,speciality,number; //系，专业，学号，子类增加的成员变量
public boolean member; //团员
private static int count=0; //Student类对象计数
public Student(String name,MyDate birthday,String sex,String province,String city,
String department,String speciality,String number,boolean member) //构造方法
{
super(name,birthday,sex,province,city); //调用父类同参数的构造方法，Person.count++
this.set(department,speciality,number,member);
count++;
}
public Student()
{
this("",new MyDate(),"","","","","","",false);
}
//构造方法，由父类Person实例提供初值，深拷贝p，且父类name等成员变量可见
public Student(Person p,String department,String speciality,String number,boolean member)
{
this(p.name,new MyDate(p.birthday),p.sex,p.province,p.city,department,speciality,number,member);
}
public Student(Student s) //拷贝构造方法，深拷贝
{
this(s.name,new MyDate(s.birthday),s.sex,s.province,s.city,s.department,s.speciality,s.number,s.member);
}
public void finalize() //析构方法，覆盖父类的析构方法
{
super.finalize(); //调用父类析构方法，Person.count–
Student.count–;
}
//显示父类和子类的对象数，覆盖父类同名静态成员方法，不能使用super
public static void howMany()
{
Person.howMany();
System.out.println(Student.count+“个Student对象”);
}
//设置各属性值；重载父类同名成员方法，参数列表不同
public void set(String department,String speciality,String number,boolean member)
{
this.department=departmentnull?"":department;
this.speciality=specialitynull?"":speciality;
this.number=number==null?"":number;
this.member=member;
}
//对象的字符串描述，成员变量之间以逗号分隔，若字符串成员变量为null，则输出“null”
//覆盖父类的toString（）方法
public String toString()
{
return super.toString()+","+department+","+speciality+","+number+(member?"，团员":"");
}

public static void main(String args[])
{Person p1=new Person("李小明",new MyDate(1992,3,15),"男","湖南省","长沙市");Student s1=new Student(p1,"计算机系","计算机科学与技术专业","001",true);Student s2=new Student(s1);       //拷贝构造方法s2.set("张小莉",new MyDate(1992,4,3),"女","湖北省","武汉市");    //调用父类的成员方法s2.set("经济管理系", "信息管理专业", "003", true);     //调用子类重载的成员方法Student.howMany();       //继承父类静态方法，执行Person.howManySystem.out.println("p1: "+p1.toString()+"\ns1: "+s1.toString()+"\ns2: "+s2);s2.finalize();Student.howMany();}

}

【3.6】对象数组的输出、查找算法和合并（有错，课本P88）

public class ObjectArray
{
public static void print(Object value[]) //输出对象数组
{
if(value!=null)
for(int i=0;i<value.length;i++)
if(value[i]!=null)
System.out.println(value[i].toString()); //toString()方法运行时多态
}

public static Object[] concat(Object value1[],Object value2[],Object value3[])     //返回合并的对象数组
{if(value1==null&&value3==null)return value2;if(value2==null&&value3==null)return value1;Object temp[]=new Object[value1.length+value2.length+value3.length];int i=0,j=0;for(j=0;j<value1.length;j++)temp[i++]=value1[j];      //对象引用赋值for(j=0;j<value2.length;j++)temp[i++]=value2[j];for(j=0;j<value3.length;j++)temp[i++]=value3[j];return temp;
}
//输出value对象数组中所有与key相等的元素，顺序查找算法；equals()方法应用
public static void print(Object value[],Object key)
{if(value!=null&&key!=null)for(int i=0;i<value.length;i++){System.out.println(key.equals(value[i]));System.out.println("value[i]: "+value[i]);if(value[i]!=null&&key.equals(value[i]))      //equals()运行时多态，执行key比较规则System.out.println(value[i].toString());    //toString()方法运行时多态}}
public static void main(String args[])
{Person p=new Person("李小明",new MyDate(1992,3,15),"男","湖南","长沙");Person pvalue[]= {p,new Student(p,"计算机","计算机科学与技术","001",true)};Student svalue1[]= {new Student("张莉",new MyDate(1992,4,3),"女","湖北","武汉","经济管理","信息管理","031",true)};Student svalue2[]= {new Student("朱小红",new MyDate(1991,3,12),"女","广东","广州","通信","通信工程","014",true)};Object value[]=concat(pvalue,svalue1,svalue2);     //返回合并的对象数组//svalue1[1].name=svalue1[1].name.substring(0,2);    //影响value数组元素，同时改名//svalue2[1].name=svalue2[1].name.substring(0,2);    //影响value数组元素，同时改名print(value);Person key = new Person(p);       //深拷贝System.out.println("查找： "+key.toString()+", 结果： ");print(value,key);             //查找执行Person对象比较规则key=new Student((Student)pvalue[1]);    //key引用子类实例System.out.println("查找： "+key.toString()+", 结果： ");print(value,key);              //查找执行student对象比较规则Student.howMany();
}

}

Java学习：类的封装、继承和多态相关推荐

面向对象详解笔记方法类对象封装继承重写多态接口
文章目录面向过程&面向对象面向过程面向对象什么是面向对象回顾方法及加深方法的定义修饰符返回类型 break:跳出switch,结束循环和return的区别方法名:注意规范就o ...
【Java学习笔记二】继承和多态
与C++不同的是,在Java中,一个类只能直接继承另一个类,而不允许继承多个类,这个新类称为继承类.派生类或者子类,而被继承的类称为基类或者父类. 继承类能够继承基类的群不属性和行为. 面向对象程序设 ...
java学习笔记03-封装继承抽象类多态接口
封装:在类的属性设置时使用private将数据隐藏.不允许使用a.xingming来调用数据,可以设置get和set函数来对数据进行查看和修改(在其中添加if的判断语句来控制该参数的修改权限和读取权 ...
Java继承_Hachi君浅聊Java三大特性之封装继承多态
Hello,大家好~我是你们的Hachi君,一个来自某学院的资深java小白.最近利用暑假的时间,修得满腔java语言学习心得.今天小宇宙终于要爆发了,决定在知乎上来一场根本停不下来的Hachi君个人 ...
Java学习-类的隐藏机制(封装性)
Java学习-类的隐藏机制(封装性) 1.封装的含义 2.类的setXXX 和 getXXX 3.this关键字 4.总结 1.封装的含义封装(encapsulation)是面向对象的三要素之一(其 ...
python--编写程序：实现乐手弹奏乐器，乐手可以弹奏不同的乐器而发出不同的声音------使用类的封装继承多态的问题/使用面向对象的思想，设计自定义类，描述出租车和家用轿车的信息
编写程序:实现乐手弹奏乐器,乐手可以弹奏不同的乐器而发出不同的声音 ------使用类的封装继承多态的问题 class Instrumnet():#乐器类def make_sound(self):pa ...
❤️什么是Java 面向对象《装、继承、多态、抽象》？建议收藏）❤️
Java 面向对象(详解) 一.面向对象 (1).面向对象编程(Object-Oriented Programming,OOP) (2).面向对象编程的本质就是:以类的方式组织代码,以对象的组织(封装 ...
农夫过河算法java,Java农夫过河问题的继承与多态实现详解
Java农夫过河问题的继承与多态实现详解发布时间:2020-08-22 06:04:29 来源:脚本之家阅读:61 作者:小任性嘛题目描述: 一个农夫带着一匹狼.一只羊.一颗白菜要过河,只有一条 ...
java学习--类与对象
文章目录 java学习--类与对象类的定义与对象的使用类的私有成员的使用 java学习–类与对象类的定义与对象的使用类的定义与对象的使用类的定义步骤: public 类名: //定义成员变量 ...
java语言类间继承关系是,Java语言类间的继承关系是（）。
Java语言类间的继承关系是( ). 更多相关问题 [判断题] 持有OPEN票的游客不需要机票的确认,可直接按票面时间去机场乘坐飞机.() [填空题] 导游服务性质是().().().().() ...

Java学习：类的封装、继承和多态

Java学习：类的封装、继承和多态相关推荐

最新文章

热门文章