阶段题目

 

Practices

随着类的加载而加载；早于对象的创建；
只要权限允许，可以通过”对象.static属性”的方式进行调用；
存在于方法区的静态域

 

修饰类  最终类不可以被继承
修饰方法: 此方法不可以被重写
修饰变量: 此变量变为一个常量不可以改变其赋值

 

class AprilTwentyThreePerson{
    private AprilTwentyThreePerson(){};

    private  static AprilTwentyThreePerson person = new AprilTwentyThreePerson();
    
    public static AprilTwentyThreePerson getPerson(){
        return person;
    }
}

 

class AprilTwentyThreePerson{
    private AprilTwentyThreePerson(){};
    
    private static AprilTwentyThreePerson person = null;
    
    public static AprilTwentyThreePerson getPerson(){
        if(person == null){
            person = new AprilTwentyThreePerson();
        }
        return person
    }
}

 

默认初始化
显式初始化 、代码块中初始化
构造器中初始化
通过”对象.属性” 或”对象.方法”的方式赋值

 

 

 

 

1: java类是否可以多继承，怎么实现多继承？

 

java没有多继承,但是可以通过接口的形式来达到多继承的目的

interface A
{
  public void doA()
}
interface B
{
  public void doB()
}
....
....
class c implements A,B
{
  public void doA()
  {......
  }
  public void doB()
  {
   .....
   }
  ....
} 

 

 

2:定义类A 和类B 如下

 

class A {
    int a = 1;
    double d = 2.0;

    void show() {
        System.out.println("Class A: a=" + a + "\td=" + d);
    }
}

class B extends A {
    float a = 3.0f;
    String d = "Java program.";
    void show() {
        super.show();
        System.out.println("Class B: a=" + a + "\td=" + d);
    }
}

(1) 若在应用程序的main 方法中有以下语句：

A a=new A();

a.show();

则输出的结果如何？

(2) 若在应用程序的main 方法中定义类B 的对象b：

A b=new B();

b.show();

则输出的结果如何？

 

 

答：输出结果为：
1）Class A: a=1 d=2.0 
2）Class A: a=1 d=2.0
Class B: a=3.0 d=Java program。

 

3 写出重载与重写的区别。重载（overload)和重写(overried，有的书也叫做“覆盖”）的区别？

 

答：方法的重写Overriding和重载Overloading是Java多态性的不同表现。重写Overriding是父类与子类之间多态性的一种表现，重载Overloading是一个类中多态性的一种表现。如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被重写 (Overriding)。子类的对象使用这个方法时，将调用子类中的定义，对它而言，父类中的定义如同被"屏蔽"了。如果在一个类中定义了多个同名的方法，它们或有不同的参数个数或有不同的参数类型，则称为方法的重载(Overloading)。

 

 

4:Overload的方法是否可以改变返回值的类型？

 

Overloaded的方法是可以改变返回值的类型

 

 

5: 写出错误答案 错误原因

class Demo{
int show(int a,int b){return 0;}
}
下面那些函数可以存在于Demo的子类中。    
A.public int show(int a,int b){return 0;}//可以，覆盖。    
B.private int show(int a,int b){return 0;}//不可以，权限不够。
C.private int show(int a,long b){return 0;}//可以，和父类不是一个函数。没有覆盖，相当于重载。
D.public short show(int a,int b){return 0;}//不可以，因为该函数不可以和给定函数出现在同一类中，或者子父类中。
E.static int show(int a,int b){return 0;}//不可以，静态只能覆盖静态。

 

 

6: 写出程序结果

 

class Super {
    public int get() {
        return 4;
    }
}

class Demo15 extends Super {
    public long get() {
        return 5;
    }

    public static void main(String[] args) {
        Super s = new Demo15();
        System.out.println(s.get());
    }

结果:

编译失败，因为子类父类中的get方法没有覆盖。但是子类调用时候不能明确返回的值是什么类型。
所以这样的函数不可以存在子父类中。

 

7: 按要求实现下列问题：实现一个名为Person的类和它的子类Employee，Employee有两个子类Faculty和Staff。具体要求如下：

 

1）Person类中的属性有：姓名name（String类型），地址address（String类型），
电话号码telphone（String类型）和电子邮件地址email（String类型）；
2）Employee类中的属性有：办公室office（String类型），工资wage（double
类型），受雇日期hiredate（String类型）；
3）Faculty类中的属性有：学位degree（String类型），级别level（String类型）；
4）Staff类中的属性有：职务称号duty（String类型）。
5）现有对象Person p1 =new Faculty()和Person p2 =new Staff ()，请分别为p1的属性赋值“本科”和Staff类的duty赋值“职员”

 

解答:

public class personTest {
    public static void main(String[] args) {
        Pp p1 = new Faculty();  //多态
        Pp p2 = new Staff();
        ((Faculty) p1).setLevel("本科");
        ((Staff)p2).setDuty("职员");

    }

}

class Pp {
    private  String name;
    private  String address;
    private  String telphone;
    private  String email;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    public String getTelphone() {
        return telphone;
    }

    public void setTelphone(String telphone) {
        this.telphone = telphone;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }
}



class Empl extends  Pp {
    private  String offer;
    private  String wage;
    private  String hiredate;

    public String getOffer() {
        return offer;
    }

    public void setOffer(String offer) {
        this.offer = offer;
    }

    public String getWage() {
        return wage;
    }

    public void setWage(String wage) {
        this.wage = wage;
    }

    public String getHiredate() {
        return hiredate;
    }

    public void setHiredate(String hiredate) {
        this.hiredate = hiredate;
    }
}


class Faculty extends  Empl{
    private  String degree;
    private  String level;

    public String getDegree() {
        return degree;
    }

    public void setDegree(String degree) {
        this.degree = degree;
    }

    public String getLevel() {
        return level;
    }

    public void setLevel(String level) {
        this.level = level;
    }
}


class Staff extends  Empl{
    private  String duty;

    public String getDuty() {
        return duty;
    }

    public void setDuty(String duty) {
        this.duty = duty;
    }
}

 

 

 

 

 

Object类的使用说明

1:

我比较两个String总是false，但是它们明明都是"abc" 

 

答:

答：比较String一定要使用equals或equalsIgnoreCase方法，不要使用 ==  
　　==比较的是两个引用（变量）是否指向了同一个对象，而不是比较其内容。

 

为什么重写toString()方法;

因为在System.out.println(类的对象名)时，类的对象名是个引用，如果不重写，就输出引用地址。

其实实际是这样的System.out.println(类的对象名.toString()),只是我们平时默认不用写，它自动加上。

 

为什么重写equals()

判断两个对象在逻辑上是否相等，如根据类的成员变量来判断两个类的实例是否相等，而继承Object中的equals方法只能判断两个引用变量是否是同一个对象。这样我们往往需要重写equals()方法。

因为默认equals在比较两个对象时，是看他们是否指向同一个地址的。但有时，我们需要两个不同对象只要是某些属性相同就认为它们equals（）的结果为true

 

两个对象a和b,请问a==b和a.equals(b)有什么区别?

 

则 a==b 是比较两个对象的引用，只有当 a 和 b 指向的是堆中的同一个对象才会返回 true，而 a.equals(b) 是进行逻辑比较，所以通常需要重写该方法来提供逻辑一致性的比较。例如，String 类重写 equals() 方法，所以可以用于两个不同对象，但是包含的字母相同的比较。 

 

 

下面代码如何优化

if(username.equals(“admin”){
  ....
}

 

解答:

因为前面没有判断为空所以先把具体的不为空的放前面
答案：
if(“admin”.equals(username)){
}

 

 

创建一个汽车类（Car）

 

（1）为其定义两个属性：颜色和型号。每个属性都使用private进行封装，为每个属性设置set、get方法。
（2）为该类创建两个构造方法。第一个为无参的构造方法。第二个为带参构造方法
（3）重写toString方法，通过toString输出汽车信息。
（4）重写equals方法，如果汽车的颜色和型号相同就认为是同一辆车。
（5）实例化两个对象，输出两个对象的信息，比较两个对象是否是同一个对象。

 

 

 

 

1:
编写一个Java应用程序，设计一个汽车类Vehicle，包含的属性有车轮个数wheels和车重weight。小车类Car是Vehicle的子类，其中包含的属性有载人数loader。卡车类Truck是Car类的子类，其中包含的属性有载重量payload。
（1）每个类都有构造方法进行属性初识化
（2）每个类都输出相关数据的toString方法
（3）使用Test类中的main方法定义各类初始化数据后台打印相关数据




2:
定义员工类Employee，包含姓名、工号和工资，包含计算奖金方法bonus，普通员工和经理都是员工，计算奖金的方法为工资*奖金系数，普通员工的奖金系数为1.5（常量），经理为2（常量），分别实现bonus方法，创建对象测试。

定义一个交通工具类，并定义抽象方法，说明交通工具可以移动。继承交通工具而产生汽车、飞机、轮船类，并实现其移动方法。


3:
equals()编程1：
（1）编写一个人类Person，其中包含姓名、性别和年龄的属性，包含构造方法以及显示姓名、性别和年龄的方法。（10分）
（2）再编写一个学生类Student，它继承Person类，其中包含学号属性，包含构造方法以及显示学号的方法。（10分）
（3）在Student类里面重写equals方法，只要是学号和姓名一致就认为是同一个学生。（20分）
（4）最后编写一个测试类，此类里面包含main()方法，在main()方法中定义两个学生s1和s2并给他们赋值，最后显示他们的学号、姓名、性别以及年龄，以及判断两个学生是否是同一个学生。（10分）

 

 

 

.