本例演示实例成员与类成员的差别,演示析构方法的设计和调用.声明的Person1类包含了实例成员变量,类成员变量,实例成员方法和类成员方法.
public class Person1 {
protected String name; //姓名,实例成员变量,保护成员
protected int age; //年龄
protected static int count=0; //人数,类成员变量,本类及子类对象计数
public Person1(String name,int age) //构造方法
{
this.set(name);
this.set(age);
count++; //人数增加1
}
public Person1(String name) //构造方法重载
{
this(name,0); //调用本类的构造方法
}
public Person1() //构造方法重载
{
this("姓名未知",0);
}
public Person1(Person1 p1) //构造方法重载
{
this(p1.name,p1.age);
}
public void finalize() //析构方法
{
System.out.println("释放对象(" + this.toString()+")"); //调用实例成员方法
this.count--;
}
public void set(String name) //设置成员变量值
{
if(name==null||name=="")
this.name="姓名未知";
else
this.name=name;
}
public void set(int age)
{
if(age>0&&age<100)
this.age=age;
else
this.age=0;
}
public void set(String name,int age)
{
this.set(name);
this.set(age);
}
public void set(Person1 p1)
{
this.set(p1.name);
this.set(p1.age);
}
public String getName() //获得成员变量值
{
return this.name;
}
public int getAge()
{
return this.age;
}
public static void howMany() //类成员方法,只能访问类成员变量
{
System.out.print("Person1.count="+count+" ");
}
public String belongClassName()
{
String str=""; //局部变量,不能使用修饰符
if(this instanceof Person1) //判断当前对象是否属于Person1类
str="Person1";
return str;
}
public String toString()
{
return this.name+","+this.age+"岁";
}
public void print() //实例成员方法,可以访问类成员变量和实例成员变量
{
this.howMany(); //通过对象调用类成员方法
System.out.println(this.belongClassName()+"类 ("+this.toString()+")");
//通过对象调用实例成员方法
}
public int olderThen(Person1 p2) //比较两个人的年龄
{
return this.age-p2.age;
}
public static void main(String args[]) //main方法也是类成员方法
{
Person1 p1=new Person1("李小明",21);
p1.print();
Person1 p2=new Person1("王大伟",19);
p2.print();
System.out.println(p1.getName()+" 比 "+p2.getName()+" 大 "+p1.olderThen(p2)+" 岁 ");
//通过对象调用实例成员方法
p1.finalize(); //调用对象的析构方法
p1=null; //p1为空对象
Person1.howMany(); //通过类名调用类成员方法
System.out.println();
}
}
/*
子类重定义父类成员:
下面声明Student2类重定义父类Person1的成员变量和成员方法演示类中方法的多态性,包括重载和覆盖.
*/
public class Student2 extends Person1 {
private String speciality; //专业，子类私有成员变量
private static int count=0; //人数，隐藏了父类的count
public Student2(String name,int age,String spec)
{
super(name,age); //调用父类的构造方法
this.speciality=spec;
this.count++; //子类对象计数
}
public Student2(String name,int age)
{
this(name,age,"未知");
}
public Student2(String name)
{
this(name,0,"未知");
}
public Student2()
{
this("姓名未知",0,"未知");
}
public Student2(Student2 s1)
{
this(s1.name,s1.age,s1.speciality);
}
public Student2(Person1 p1,String spec)
{
this(p1.name,p1.age,spec);
}
public void finalize() //覆盖父类的析构方法
{
super.finalize(); //调用父类析构方法,父类人数减1
this.count--; //子类人数减1
}
public void setSpeciality(String spec)
{
if(spec==null||spec=="")
this.speciality="不知";
else
this.speciality=spec;
}
public void set(String name,int age,String spec) // 重载父类同名成员方法
{
super.set(name,age);
this.setSpeciality(spec);
}
public String getSpeciality()
{
return this.speciality;
}
public static void howMany() //分别统计父类和子类的人数,覆盖父类的同名类成员方法
{
Person1.howMany(); //调用父类的类成员方法
System.out.print("Student2.count="+count+" "); //显示子类的成员变量值
}
public String belongClassName()
{
String str=super.belongClassName(); //返回父类的类名
if(this instanceof Student2)
str+=",Student2";
return str;
}
public String toString() //覆盖父类的同名方法
{
return super.toString()+"."+speciality+"专业"; //调用父类同名方法
}
public void print() //覆盖父类的同名方法
{
this.howMany();
System.out.println(this.belongClassName()+"类 ("+this.toString()+")");
}
}
class Student2_ex {
public static void main(String args[])
{
Person1 p1=new Person1(); //父类对象
p1.set("李小明",21); //调用父类成员方法
p1.print();
Student2 s1=new Student2(); //子类对象
s1.set("王大伟",19); //调用父类成员方法
s1.print();
Student2 s2=new Student2(); //子类对象
s2.set("张三",18,"计算机"); //调用子类重载的成员方法
s2.print();
s1.finalize(); //覆盖父类的析构方法
s1=null;
Student2.howMany();
System.out.println();
}
}
运行结果如下:
Person1.count=1 Person1类 (李小明,21岁)
Person1.count=2 Student2.count=1 Person1,Student2类 (王大伟,19岁.未知专业)
Person1.count=3 Student2.count=2 Person1,Student2类 (张三,18岁.计算机专业)
释放对象(王大伟,19岁.未知专业)
Person1.count=2 Student2.count=1