演示java面向对象的核心特性(类的封装性,继承性和多态性)

本例演示实例成员与类成员的差别,演示析构方法的设计和调用.声明的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