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方法，但可以继承并使用
}
}输出结果：
