java面向对象周测带答案

java面向对象周测带答案

一、简答题（每题5分，共计40分）
1.什么是类？什么是对象？类与对象的关系是什么？

类本质上就是分类的意思，也就是具有相同共性的一类事物的抽象描述。
类就是一种用户可以自定义的引用数据类型，用于包装描述属性的成员变量，和用于描述行为的成员方法，换句话说，类可以用于描述多个不同类型的数据。
类是一种抽象的概念，用于描述对象创建的模板，而对象是客观存在的实体，本质上就是内存空间中的一块区域，对象的数据结构取决于类。

2.请写出类、属性、行为的定义格式，以及引用和对象的定义格式。

class 类名{
数据类型 成员变量名;
返回值类型 方法名称(形式参数列表){
    方法体；
}
}  
类类型 对象名 = new 类类型();

3.简述方法重载的概念、体现形式以及作用。

当同一个类中方法名相同，参数列表不同的方法之间 构成重载关系。 参数列表的体现形式有：参数个数的不同、参数类型不同、参数顺序不同。
方法的重载与返回值类型和形参变量名无关，但是建议尽量相同。
作用： 对于调用者来说，只需要记忆一个方法名就可以实现所有形式的调用。

4.this关键字的基本概念和常见使用方式是什么？

在构造方法中，this代表当前正在构造的对象。
在普通方法中，this代表当前正在调用的对象，也就是调用对象。
当形参名/局部变量和属性同名时，需要使用this关键字通过.来明确表示属性变量，从而提高代码的可读性和正确性，也就是用于区分同名的成员变量和形参以及局部变量。

5.基本数据类型和引用数据类型分别作为方法参数的效果是什么？。

当基本数据类型作为参数传递时，传递数据内容本身，因此形参改变不会影响到实参；
当引用数据类型作为参数传递时，传递的是引用记录的地址，因此形参指向的内容发生改变时，会直接对实参产生影响。
当引用数据类型作为参数传递后，若形参改变了指向再去改内容，则对实参无影响。。

6.简述封装的实现流程。

a.私有化成员变量，使用private关键字修饰；
b.提供公有的get成员变量和set成员变量方法，并在方法体中进行合理性的判断；
c.在构造方法中调用set成员变量的方法来确保合理性;

7.final关键字修饰类、方法以及属性各自的效果是什么？

final修饰的类表示该类不能被继承。
final修饰的方法不可以被重写，但可以被继承。
final修饰的成员变量必须被初始化，并且只能初始化一次。

8.简述多态的效果。

a.父类引用只能访问父类中的属性和方法。
b.父类引用不能直接访问子类中的属性和方法。
c.父类引用若想访问子类中的属性和方法，则进行强制类型转换，转换为子类变量调用
d.父类引用调用非静态的重写方法时，则调用子类中的版本；
调用静态的重写方法时，则调用父类中的版本。

二、编程题（13题每题10分，45题15分，共计60分）
1．自定义方法将一整数逆序后放入一数组中（要求递归实现）如：1234 变为 {4,3,2,1}。

public void NO1(int num,int[] arr,int i) {
        if(num>0) {
            arr[i] = num%10;
            i++;
            NO1(num/10,arr,i);
        }else {
            return;
        }
    }

 

2．编程实现两种形式（饿汉式和懒汉式）的单例模式。

//懒汉式单例模式
public class text {
 
    //设立静态变量
    private static text tt = null;
 
    private text(){
        //私有化构造函数
        System.out.println("懒汉式单例模式");
    }
    
    //开放一个公有方法，判断是否已经存在实例，有返回，没有新建一个在返回
    public static text getInstance(){
        System.out.println("懒汉式单例模式");
        if(tt == null){
            System.out.println("懒汉式构造函数的实例当前并没有被创建");
            tt = new text();
        }else{
            System.out.println("懒汉式构造函数的实例已经被创建");
        }
        System.out.println("方法调用结束，返回单例");
        return tt;
    }
}

//饿汉式单例模式
public class text2 {
 
    //设立静态变量，直接创建实例
    private static text2 tt = new text2();
 
    private text2(){
        //私有化构造函数
        System.out.println("饿汉式单例模式");
    }
    
    //开放一个公有方法，判断是否已经存在实例，有返回，没有新建一个在返回
    public static text2 getInstance(){
        System.out.println("饿汉式单例模式");
        return tt;
    }
}

 

3．编程实现以下需求：
自定义狗类，属性有：名字、牙齿数量，行为有：吃食物、看家。
自定义猫类，属性有：名字、颜色，行为有：吃食物、抓老鼠。
自定义测试类，自定义成员方法实现既能打印狗又能打印猫的所有特征，在main()方法中调用即可。

package text;
    public class an {
        private String  name;
        public an() {
        }
        public an(String name) {
            setName(name);
        }
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
        public void show() {
            System.out.println("名字： "+getName()+"吃食物");
            
        }   
    }
package text;

public class cat extends an{
    private String color;
    public cat(String name,String color) {
        super(name);
        setColor(color);
    }
    public String getColor() {
        return color;
    }
    public void setColor(String color) {
        this.color = color;
    }
    public void show() {
        System.out.println("名字： "+getName()+"颜色: "+getColor()+"吃食物");
        
    }
    public void work() {
        System.out.println("抓老鼠");        
    }
}
package text;

public class dog extends an{
    private int ya;
    public dog(String name,int ya) {
        super(name);
        setYa(ya);
    }
    public int getYa() {
        return ya;
    }
    public void setYa(int ya) {
        this.ya = ya;
    }
    public void show() {
        System.out.println("名字： "+getName()+"牙齿： "+getYa()+"吃食物");
        
    }
    public void work() {
        System.out.println("看家");        
    }
}
package text;

public class text {
    public static void print(an an) {
        an.show();
        if(an instanceof cat) {
            cat cc= (cat)an;
            cc.work();
        }else if (an instanceof dog) {        
            dog dd=(dog)an;
            dd.work();
        }    
    }
    public static void main(String[] args) {
        print(new cat("猫","白色"));
        print(new dog("狗", 18));
    }
}

 

4．编程实现以下需求：
自定义Accout类实现封装，特征有：账户余额，要求提供计算利息兵返回的抽象方法。
自定义FixedAccount类继承Account类并重写抽象方法，在main()方法中使用多态方式构造对象并设置账户余额为2000，最后计算利息并打印出来。

package t;ext

public abstract  class  Accout {
    

    private int money;
        public Accout() {
        
        }
        public Accout(int money) {
            setMoney(money);
        }
        public int getMoney() {
            return money;
        }
        public void setMoney(int money) {
            this.money = money;
        }
        public abstract double getLi();
    }
package text;

public class FixedAccount extends Accout{
    
    public FixedAccount(int i) {
        super(i);
    }

    @Override
    public double getLi() {
        
        return getMoney()*0.03;
    }
    public static void main(String[] args) {
        Accout ac = new FixedAccount(2000);
        double as = ac.getLi();
        System.out.println("利息： "+as);
    }

}

 

5．编程实现以下需求：
自定义TestInterfaceA接口，提供一个打印1~20之间所有奇数的抽象方法。
自定义TestInterfaceB接口，提供一个打印1~20之间所有偶数的抽象方法。
自定义SubAB类实现上述两个接口并重写抽象方法，在main方法中使用多态语法 格式创建对象并调用两个方法实现打印。

package text;

public interface A {
    public abstract void show();
}
package text;

public interface B {
    public abstract void print();
}

    package text;

public class AB {
    
    public static void text(A a) {
        a.show();
    }
    public static void text1(B b) {
            b.print();    
        }
    public static void main(String[] args) {
    
            AB.text(new A() {
                
                @Override
                public void show() {
                    for (int i = 0; i < 20; i++) {
                        if(i%2==1) {
                            System.out.println(i);
                        }
                        
                    }
                }
            });
            
            AB.text1(new B() {
                
                @Override
                public void print() {
                    for (int i = 1; i < 20; i++) {
                        if(i%2==0) {
                            System.out.println(i);
                        }
                    }
                }
            });
}
}