Java面向对象测试

1.定义一个Father和Child类，并进行测试。

要求如下：
1）Father类为外部类，类中定义一个私有的String类型的属性name，name的值为“zhangjun”。 2）Child类为Father类的内部类，其中定义一个introFather()方法，方法中调用Father类的name属性。

3）定义一个测试类Test，在Test类的main()方法中，创建Child对象，并调用introFather ()方法。

class Father{
	private String name = "zhangjun";
	class Child{
		public void introFather(){
			System.out.println(name);
		}
	}
}

public class Test2{
	public static void main(String[] agrs){
		new Father().new Child().introFather();
	}
	
}

输出结果：zhangjun

2.简述下列程序运行结果:

class A{ 
    int y=6; 
    class Inner{ 
        final static int y=3; //此处不能直接以static int定义，若要以static int定义,则内部类也必须用static定义 static class Inner
        void show(){ 
            System.out.println(y); 
        } 
    } 
} 
class Demo{ 
    public static void main(String [] args){ 
    A.Inner inner=new A().new Inner(); 
    inner.show(); 
    } 
}

实例化内部类对象前，首先实例化外部类，y初始化为6，然后实例化内部类，声明内部y与外部的y无关系，初始化内部y

result : 3;

3.写出下面程序运行结果:

class A{ 
    public A(){ 
        System.out.println(“A”); 
    } 
} 

class B extends A{ 
    public B(){

        //此处系统自动补上super();

        System.out.println(“B”); 
    } 

    public static void main(String[] args){ 
        B b=new B(); 
    } 
}

实例化子类对象时调用子类构造方法会自动先调用父类的构造方法

输出结果：

A

B

4.编程题：

打印出所有的 "水仙花数 "，所谓 "水仙花数 "是指一个三位数，其各位数字立方和等于该数本身。例如：153是一个 "水仙花数 "，因为153=1的三次方＋5的三次方＋3的三次方。 

public class Test3{
	
	public static void main(String[] agrs){
		printWaterFlower();
	}
	
	public static int CalculateAdd1(int a, int b, int c){
		return a*a*a+b*b*b+c*c*c;
	}
	
	public static void printWaterFlower(){

		for(int i=100;i<1000;i++){
			int a = i%10;
			int b = (i/10)%10;
			int c = i/100;
			if(i==CalculateAdd1(a,b,c)){
				System.out.print(i+" ");
			}
		}
		System.out.println();
		
	}
	
}

输出结果：

5.编程题：

定义一个抽象的"Role"类，有姓名，年龄，性别等成员变量
1）要求尽可能隐藏所有变量(能够私有就私有,能够保护就不要公有)，
再通过GetXXX()和SetXXX()方法对各变量进行读写。具有一个抽象的play()方法，
该方法不返回任何值，同时至少定义两个构造方法。Role类中要体现出this的几种用法。
2）从Role类派生出一个"Employee"类，该类具有Role类的所有成员（构造方法除外），
并扩展salary成员变量，同时增加一个静态成员变量“职工编号（ID）”。
同样要有至少两个构造方法，要体现出this和super的几种用法，还要求覆盖play()方法，
并提供一个final sing()方法。
3）"Manager"类继承"Employee"类，有一个final成员变量"vehicle"

在main()方法中制造Manager和Employee对象,并测试这些对象的方法。 

abstract class Role{
	private String name;
	private int age;
	private String sex;
	
	public void setName(String name){
		this.name = name;
	}
	public String getName(){
		return this.name;
	}
	public void setAge(int age){
		this.age = age;
	}
	public int getAge(){
		return this.age;
	}
	public void setSex(String sex){
		this.sex = sex;
	}
	public String getSex(){
		return this.sex;
	}
	public abstract void play();
	public Role(){
		System.out.println("调用了Role的无参构造。");
	}
	public Role(String name, int age, String sex){
		this();
		this.name = name;
		this.age = age;
		this.sex = sex;
	}
}

class Employee extends Role{
	private int salary;
	public static int ID = 1;
	
	public void setSalary(int salary){
		this.salary = salary;
	}
	
	public int getSalary(){
		return this.salary;
	}
	
	public void setID(int ID){
		this.ID = ID;
	}
	
	public int getID(){
		return this.ID;
	}
	
	public Employee(){
		System.out.println("Employee的无参构造被调用。");
	}
	
	public Employee(String name,int age,String sex,int salary,int ID){
		//this();				
		super(name,age,sex);	
		/*1.这里的this和super只能放一个，否则会报错；把this()放第一个位置，报错：super()必须放第一个位置.
                    super放第一个位置，报错：this()必须放第一个位置.
		  2.第一种情况，不放任何构造方法，系统会默认补上super();
		  3.第二种情况，只放this(),系统也会默认补上super(),并且补在this()之前,打印结果:
					调用了Role的无参构造。
					Employee的无参构造被调用。
		  4.第三种情况，只放super(name,age,sex);那么系统就不会再补上super(),只执行带参数的super(name,age,sex);
		*/
		
		this.salary = salary;
		this.ID = ID;
	}
	
	public void play(){
		System.out.println(this.getName()+"正在palying.");	
		//这里的name使用的是Role的name，故不能直接访问，需要通过getName()方法，下同
		System.out.println("姓名："+this.getName()+"，年龄："+this.getAge()+",性别："+this.getSex()+
			",薪水："+this.salary+",ID:"+this.ID);//salary和ID在本类中定义，故可直接访问
	}
	
	public final void sing(){
		System.out.println(this.getName()+" is sing..");
	}
	
}

class Manager extends Employee{
	private final String vehicle = "Bus";
	
//	public void setVehicle(String vehicle){		编译无法通过，由final修饰变量不能更改
//		this.vehicle = vehicle;
//	}

	public String getVehicle(){
		return this.vehicle;
	}
	
	public Manager(String name, int age, String sex, int salary, int ID){
		super(name,age,sex,salary,ID);
	}
	
	public void play(){
		System.out.println(this.getName()+"is playing...");
		System.out.println("姓名："+this.getName()+"，年龄："+this.getAge()+",性别："+this.getSex()+
			",薪水："+this.getSalary()+",ID:"+this.getID()+",车辆："+this.vehicle);
	}	
	
//	public final void sing(){		//编译不能通过，被覆写的方法为final
//		System.out.println(this.getName()+" is sing..");
//	}
	
}

public class Test4 {
	public static void main(String[] agrs){
		System.out.println("Employee default ID:"+Employee.ID);//打印staticID
		Role e = new Employee("张三", 21, "男",5000,102);	//向上转型
		e.play();	
		//e.sing();		//编译不能通过，使用Role声明的对象，无法访问子类创建的方法
		//向下转型，可以使用子类方法，前提是该对象是已经向上转型
		Employee e1 = (Employee)e;
		e1.sing();
		
		System.out.println();
		
		Role m = new Manager("李四",25,"男",6000,202);
		m.play();
		Manager m1 = (Manager)m;	//证明可以隔层向下转型
		m1.sing();//子类不能覆写final方法，但可以继承并使用
	}
	
}

输出结果：