java5.面向对象编程(中)练习题

Java基础 专栏收录该内容
20 篇文章 0 订阅
1.java类是否可以多继承,怎么实现多继承?
java不可以多继承,可以通过接口实现多继承
定义类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();//父类方法show
则输出的结果如何?
(2) 若在应用程序的main 方法中定义类B 的对象b:
A b=new B();//多态;父类引用指向子类的对象
b.show();//首先调用父类的show,再调用子类的show方法
结果:Class A: a=1 d=2.0
	Class B: a=3.0 d="Java program."
	因为a,多态中虽然不可以访问子类中父类没有的属性,直接访问相同属性的话,得到的结果是父类中的,但是可以通过方法中来访问子类中父类没有的的属性
3.方法重写和重载的区别:
重载:在一个类中,在编译时就已经确定如何执行
重写:编译时看左边,运行时才会根据new的时那个对象来确定执行哪个;
方法的重写Overriding和重载OverloadingJava多态性的不同表现。重写Overriding是父类与子类之间多态性的一种表现,重载Overloading是一个类中多态性的一种表现。如果在子类中定义某方法与其父类有相同的名称和参数,我们说该方法被重写 (Overriding)。子类的对象使用这个方法时,将调用子类中的定义,对它而言,父类中的定义如同被"屏蔽"了。如果在一个类中定义了多个同名的方法,它们或有不同的参数个数或有不同的参数类型,则称为方法的重载(Overloading)
4.Overload的方法是否可以改变返回值的类型?
重载可以改变返回值类型
5.写出错误答案错误的原因
class Demo{
int show(int a,int b){return 0;}//返回值类型为缺省,所以重写方法的返回值类型只能为缺省或者public
}
下面那些函数可以存在于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());
	}
}
//编译失败,因为int和long没有覆盖,所以子类中起始存在两个get方法,调用时不知道调用哪个,所以编译会失败
7.按要求实现下列问题:实现一个名为Person的类和它的子类EmployeeEmployee有两个子类FacultyStaff。具体要求如下:
1Person类中的属性有:姓名name(String类型),地址address(String类型),
电话号码telphone(String类型)和电子邮件地址email(String类型);
2Employee类中的属性有:办公室office(String类型),工资wage(double
类型),受雇日期hiredate(String类型);
3Faculty类中的属性有:学位degree(String类型),级别level(String类型);
4Staff类中的属性有:职务称号duty(String类型)。
5)现有对象Person p1 =new Faculty()Person p2 =new Staff (),请分别为p1的属性赋值“本科”和Staff类的duty赋值“职员”

package classTest4;

import java.security.PrivateKey;

/**
 * describe:
 *
 * @author suoliang
 * @create 2021-06-11:39
 */
public class use2 {
    public static void main(String[] args) {
        Person p1 = new Facutly();
        Person p2 = new Staff();
        if (p1 instanceof Facutly){
            Facutly p11 = (Facutly) p1;
            p11.setDegree("本科");
            System.out.println(p11.getDegree());
        }
        if (p2 instanceof Staff){
            Staff p22 = (Staff)p2;
            p22.setDuty("支援");
            System.out.println(p22.getDuty());
        }
    }
}
class Person{
    private String name;
    private String address;
    private String telphone;
    private String email;
}

class Employee extends Person{
    private String office;
    private double wage;
    private String hiredate;

}

class Facutly extends Employee{
    private String degree;
    private String level;

    public String getDegree() {
        return degree;
    }

    public String getLevel() {
        return level;
    }

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

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

class Staff extends Employee{
    private String duty;

    public String getDuty() {
        return duty;
    }

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

在这里插入图片描述

8.object类的使用说明
8.1我比较两个String总是false,但是它们明明都是"abc" !
因为如果使用==号比较的话,比较的是地址;
一定要使用equals,因为字符串中重写了equals,所以只会比较字面结果
8.2为什么要重写toString()方法?
不重写的话,tostring输出的是类名和地址值
8.3为什么要重写equals()方法?
不重写的话默认比较的是地址值
8.4定义一个person类,属性如下:
(1)身份证号,性别,姓名,年龄,户籍,出生日期(Data类型,需要引用java.uitl.Data)功能:
(2)自我介绍:介绍格式:(toString)
身份证号+姓名+户籍
(3)提供对象比较equals方法,只要身份证号+姓名相同就认为对象相等
package classTest4;

import java.util.Date;

/**
 * describe:
 *
 * @author suoliang
 * @create 2021-06-11:50
 */
public class use3 {
}
class Person1{
     private String name;
     private int id;
     private int age;
     private String place;
     private Date date;

    @Override
    public String toString() {
        return "Person1{" +
                "name='" + name + '\'' +
                ", id=" + id +
                ", place='" + place + '\'' +
                '}';
    }
    public boolean equals(Object o){
        if (o == this){return true;}
        if (o == null || o.getClass() != this.getClass()){
            return false;
        }
        Person1 o1 = (Person1) o;
        return this.id == o1.id && this.name == o1.name;
    }
}
9.写出“==”和equals的区别
类似:两个对象a和b,请问a==b和a.equals(b)有什么区别?

==比较的是地址值
equals是可以重写的,重写之后根据自己的意愿返回boolean
创建一个汽车类(Car)
(1)为其定义两个属性:颜色和型号。每个属性都使用private进行封装,为每个属性设置set、get方法。
(2)为该类创建两个构造方法。第一个为无参的构造方法。第二个为带参构造方法
(3)重写toString方法,通过toString输出汽车信息。
(4)重写equals方法,如果汽车的颜色和型号相同就认为是同一辆车。
(5)实例化两个对象,输出两个对象的信息,比较两个对象是否是同一个对象。
package classTest4;

/**
 * describe:
 *
 * @author suoliang
 * @create 2021-06-11:57
 */
public class Car {
    private String color;
    private int id;

    public String getColor() {
        return color;
    }

    public int getId() {
        return id;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public void setId(int id) {
        this.id = id;
    }

    public Car(String color, int id) {
        this.color = color;
        this.id = id;
    }

    @Override
    public String toString() {
        return "Car{" +
                "color='" + color + '\'' +
                ", id=" + id +
                '}';
    }

    @Override
    public boolean equals(Object obj) {
        if (obj == this){ return true;}
        if (obj == null || obj.getClass() != this.getClass()){
            return false;
        }
        Car obj1 = (Car) obj;
        return this.color == obj1.color && this.id == obj1.id;
    }
}
class test{
    public static void main(String[] args) {
        Car car = new Car("12",12);
        Car car1 = new Car("12",12);
        System.out.println(car.equals(car1));
    }
}

在这里插入图片描述

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

/**
 * describe:
 *
 * @author suoliang
 * @create 2021-06-12:05
 */
public class use4 {
    public void culWage(Employee1 employee1){
        System.out.println(employee1.bonus());
    }
    public static void main(String[] args) {
        //普通员工应该输出4500
        use4 use4 = new use4();
        use4.culWage(new CommonEmpl());
        //经理一个输出6000
        use4.culWage(new Manager());
    }
}

class Employee1{
    private String name;
    private int id;
    private double wage = 3000;

    public String getName() {
        return name;
    }

    public int getId() {
        return id;
    }

    public double getWage() {
        return wage;
    }

    public double bonus(){
        return 0.0;
    }
}
class CommonEmpl extends Employee1{
    @Override
    public double bonus() {
        return this.getWage() * 1.5;
    }
}

class Manager extends Employee1{
    @Override
    public double bonus() {
        return this.getWage() * 2.0;
    }
}
编写一个Java应用程序,设计一个汽车类Vehicle,包含的属性有车轮个数wheels和车重weight。小车类CarVehicle的子类,其中包含的属性有载人数loader。卡车类TruckCar类的子类,其中包含的属性有载重量payload。
(1)每个类都有构造方法进行属性初识化
(2)每个类都输出相关数据的toString方法
(3)使用Test类中的main方法定义各类初始化数据后台打印相关数据
package classTest4;

/**
 * describe:
 *
 * @author suoliang
 * @create 2021-06-12:13
 */
public class use5 {
    public static void main(String[] args) {
        Vechile vechile = new Vechile(12, 12.5);
        System.out.println(vechile);
    }
}
class Vechile{
    public Vechile(int wheels, double weight) {
        this.wheels = wheels;
        this.weight = weight;
    }

    private int wheels;
    private double weight;

    @Override
    public String toString() {
        return "Vechile{" +
                "wheels=" + wheels +
                ", weight=" + weight +
                '}';
    }
}
class Car1 extends Vechile{
    public Car1(int wheels, double weight, int loader) {
        super(wheels, weight);
        this.loader = loader;
    }

    private int loader;

    @Override
    public String toString() {
        return "Car1{" +
                "loader=" + loader +
                "} " + super.toString();
    }
}
class Truck extends Car1{
    public Truck(int wheels, double weight, int loader, double plaload) {
        super(wheels, weight, loader);
        this.plaload = plaload;
    }

    @Override
    public String toString() {
        return "Truck{" +
                "plaload=" + plaload +
                "} " + super.toString();
    }

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

import java.util.Scanner;

/**
 * describe:
 *
 * @author suoliang
 * @create 2021-06-12:17
 */
public class use6 {
    public void randomInput(Travel travel){
        Scanner scanner = new Scanner(System.in);
        boolean isFlag = true;
        while (isFlag){
            System.out.println("请输入一个1到3的整数:");
            int num = scanner.nextInt();
            if (num == 1){
                travel = new Car2();
                travel.Run();
            }
            else if (num == 2){
                travel = new Plane();
                travel.Run();
            }
            else if (num == 3){
                travel = new Lunchaun();
                travel.Run();
            }else {
                isFlag = false;
            }
        }
    }
    public static void main(String[] args) {
        use6 use6 = new use6();
        use6.randomInput(new Travel());
    }
}
class Travel{
    public void Run(){
        System.out.println("交通工具可以移动");
    }
}

class Car2 extends Travel{
    @Override
    public void Run() {
        System.out.println("汽车可以移动");
    }
}

class Plane extends Travel{
    @Override
    public void Run() {
        System.out.println("飞机可以移动");
    }
}

class Lunchaun extends Travel{
    @Override
    public void Run() {
        System.out.println("轮船可以移动");
    }
}

在这里插入图片描述

写出8中基本数据类型的包装类
intInteger 有什么区别
答:Java 提供两种不同的类型:引用类型和原始类型(或内置类型)。
int是java的原始数据类型,Integer是java为int提供的封装类。Java为每个原始类型提供了封装类。
原始类型封装类型及其对应的包装类:boolean Boolean,char Character,byte Byte,short Short,int Integer,long Long,float  Float,doubl  Double
引用类型和原始类型的行为完全不同,并且它们具有不同的语义。
引用类型和原始类型具有不同的特征和用法,它们包括:大小和速度问题,这种类型以哪种类型的数据结构存储,当引用类型和原始类型用作某个类的实例数据时所指定的缺省值。对象引用实例变量的缺省值为 null,而原始类型实例变量的缺省值与它们的类型有关。
public static void main(String[] args) {
		Integer i1 = 128;
		Integer i2 = 128;
		int i3 = 128;
		int i4 = 128;
		System.out.println(i1 == i2);
		System.out.println(i3 == i4);
		System.out.println(i1 == i3);
	}
答案:
false
true
true
Integer个范围,是新new的对象,不是常量对象的i1和i2是对象,他们==比较的是地址。如果-128~127范围,那么使用缓存的常量对象,如果超过比较地址
public static void main(String[] args) {
		double a = 2.0;
		double b = 2.0;
		Double c = 2.0;
		Double d = 2.0;
		System.out.println(a == b);true基本数据类型比较值
		System.out.println(c == d);false:引用数据类型比较地址
		System.out.println(a == d);true基本数据和引用类型比较,比较值
	}
super关键字:找父类中的
class Test {
	Test() {
		System.out.println("Test");
	}
}

class Demo extends Test {
	Demo() {
		// super();默认会调用父类无参构造器
		System.out.println("Demo");
	}

	public static void main(String[] args) {
		new Demo();//Test
		new Test();//Test  Demo
	}
}
class Super {
	int i = 0;
	public Super(String a) {
		System.out.println("A");
		i = 1;
	}
	public Super() {
		System.out.println("B");
		i += 2;
	}
}
class Demo extends Super {
	public Demo(String a) {
		// super();
		System.out.println("C");
		i = 5;
	}
	public static void main(String[] args) {
		int i = 4;
		Super d = new Demo("A");
		System.out.println(d.i);//B C 5
	}
}
class Super {
	int i = 0;
	public Super(String s) {
		i = 1;
	}
}

class Demo extends Super {
	public Demo(String s) {
		i = 2;
	}

	public static void main(String[] args) {
		Demo d = new Demo("yes");
		System.out.println(d.i);
	}
	编译失败,父类没有无参构造器
}
package test;
public class  FatherClass{
    public FatherClass(){
       System.out.println("FatherClass Create");
    }
}
子类:
package test;
import test.FatherClass;
public class  ChildClass extends FatherClass{
   public ChildClass(){
     System.out.println("ChildClass Create");
   }
   public static void main(String[] args) {
      FatherClass fc = new FatherClass();
      ChildClass cc = new ChildClass();
   }
}
public class Test {
	public static void main(String[] args) {
		Base b1 = new Base();
		Base b2 = new Sub();
	}
}
class Base{
	Base(){
		method(100);
	}
	public void method(int i){
		System.out.println("base : " + i);
	}
}
class Sub extends Base{
	Sub(){
		super.method(70);
	}
	public void method(int j){
		System.out.println("sub : " + j);
	}
}
base : 100
sub : 100
base : 70
class A {
	private int a;
	public void setA(int a) {
		this.a = a;
	}

	public int getA() {
		return a;
	}
}

class B extends A {
	private int a;

	public void setA(int a) {
		this.a = a;
	}
	// public int getA(){
	// return a;
	// }有了get方法以后得到的是5
}

public class PersonTest {

	public static void main(String[] args) {
		A c = new B();

		c.setA(5);//set的是B里面的5;
		System.out.println(c.getA());//输出的是A里面的0,因为子类中没有get方法
	}
}
class Fu {
	boolean show(char a) {
		System.out.println(a);
		return true;
	}
}

class Demo extends Fu {
	public static void main(String[] args) {
		int i = 0;
		Fu f = new Demo();
		Demo d = new Demo();
		for (f.show('A'); f.show('B') && (i < 2); f.show('C')) {
			i++;
			d.show('D');
		}
	}

	boolean show(char a) {
		System.out.println(a);
		return false;
	}
}//return 再for循环里可以用来终止循环,
class Fu {
	int num = 4;
	void show() {System.out.println("showFu");}}
class Zi extends Fu {
	int num = 5;
	void show() {
		System.out.println("showZi");
	}}
class T {
	public static void main(String[] args) {
		Fu f = new Zi();
		Zi z = new Zi();
		System.out.println(f.num);//5
		System.out.println(z.num);//5
		f.show();//showZi
		z.show();//showZi
	}
}
package classTest4;

/**
 * describe:
 *
 * @author suoliang
 * @create 2021-06-13:01
 */
public class use12 {
    public static void main(String[] args) {
        Per per = new stu();
        per.show();//这里面的a和d是子类中的
        System.out.println(per.a);//直接访问a和d是父类中的,不可以访问子类中的
        System.out.println(per.d);

    }
}
class Per{
    int a = 12;
    double d = 20.0;
    public void  show(){
        System.out.println(a+d);
    }
}

class stu extends Per{
    int a = 20;
    String d = "爱我中华";

    @Override
    public void show() {
        System.out.println(a + d);
    }
}

在这里插入图片描述

  • 0
    点赞
  • 4
    评论
  • 1
    收藏
  • 打赏
    打赏
  • 扫一扫,分享海报

评论 4 您还未登录,请先 登录 后发表或查看评论
©️2022 CSDN 皮肤主题:护眼 设计师:闪电赇 返回首页

打赏作者

漂酿男骸

你的鼓励将是我创作的最大动力

¥2 ¥4 ¥6 ¥10 ¥20
输入1-500的整数
余额支付 (余额:-- )
扫码支付
扫码支付:¥2
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值