最后回顾一遍面向对象基础部分，后面就开始慢慢进阶了。
所有题目均来自：https://www.jianshu.com/p/886252693889
在练习中，有意识的规范代码格式，发现新东西，这才是练习的目的。
原帖中源代码就不贴上来了，贴上的的均为本人所编写，类、变量命名参考原帖。
【练习题】01.类的成员变量 猜数字游戏一个类A有一个成员变量v有一个初值100。定义一个类对A类的成员变量v进行猜。如果大了则提示大了小了则提示小了。等于则提示猜测成功。
package practise;
import java.util.Scanner;
public class Variable {
/*
* 01.类的成员变量 猜数字游戏一个类A有一个成员变量v有一个初值100。
* 定义一个类对A类的成员变量v进行猜。
* 如果大了则提示大了小了则提示小了。
* 等于则提示猜测成功。
*/
public static void main(String[] args) {
A a =new A();
Scanner input = new Scanner(System.in);
while(true){
int i = input.nextInt();
if(i > a.v){
System.out.println("猜大了");
continue;
}
if(i < a.v ){
System.out.println("猜小了");
continue;
}
if(i == a.v ){
System.out.println("猜对了");
break;
}
}
}
}
class A{
int v = 100;
}
【练习题】02.类的成员变量 请定义一个交通工具(Vehicle)的类其中有: 属性速度(speed)体积(size)等等 方法移动(move())设置速度(setSpeed(int speed))加速speedUp(),减速speedDown()等等. 最后在测试类Vehicle中的main()中实例化一个交通工具对象并通过方法给它初始化speed,size的值并且通过打印出来。另外调用加速减速的方法对速度进行改变。
package practise;
public class test2 {
/*
* 02.类的成员变量 请定义一个交通工具(Vehicle)的类其中有:
* 属性速度(speed)
* 体积(size)等等
* 方法移动(move())
* 设置速度(setSpeed(int speed))
* 加速speedUp(),
* 减速speedDown()等等.
* 最后在测试类Vehicle中的main()
* 中实例化一个交通工具对象并通过方法给它初始化speed,
* size的值并且通过打印出来。
* 另外调用加速减速的方法对速度进行改变。
*/
public static void main(String[] args) {
// TODO 自动生成的方法存根
Vehicle v = new Vehicle(30);
v.move();
v.prin();
v.setSpeed(20);
v.move();
v.prin();
v.speedUp();
v.move();
v.prin();
v.speedDown();
v.move();
v.prin();
}
}
/*
* 02.类的成员变量 请定义一个交通工具(Vehicle)的类其中有:
* 属性速度(speed)
* 体积(size)等等
* 方法移动(move())
* 设置速度(setSpeed(int speed))
* 加速speedUp(),
* 减速speedDown()等等.
* 最后在测试类Vehicle中的main()
* 中实例化一个交通工具对象并通过方法给它初始化speed,
* size的值并且通过打印出来。
* 另外调用加速减速的方法对速度进行改变。
*/
class Vehicle{
private int speed;
private int size;
public Vehicle(){
this.speed = 0;
this.size = 0;
}
public Vehicle(int speed){
this.speed = speed;
this.size = 0;
}
public void move(){
size+=speed;
}
public void setSpeed(int speed){
this.speed =speed;
}
public void speedUp(){
++speed;
}
public void speedDown(){
--speed;
}
public void prin(){
System.out.println(size);
}
}
【练习题】03.类的成员变量与方法、构造方法 在程序中经常要对时间进行操作但是并没有时间类型的数据。那么我们可以自己实现一个时间类来满足程序中的需要。 定义名为MyTime的类其中应有三个整型成员时hour分minute秒second为了保证数据的安全性这三个成员变量应声明为私有。 为MyTime类定义构造方法以方便创建对象时初始化成员变量。 再定义diaplay方法用于将时间信息打印出来。 为MyTime类添加以下方法 addSecond(int sec) addMinute(int min) addHour(int hou) subSecond(int sec) subMinute(int min) subHour(int hou) 分别对时、分、秒进行加减运算。
注：写这个的时候发现，
错误：找不到或无法加载主类
最后发现原因是：
类文件名冲突：存在使用另一大小写的资源
当时情况是我在MyTime里新建了一个类myTime导致的错误
回顾知识的时候，哪怕只学习到一点新知识，都是进步。
package practise;
public class MyTime {
/*
* 03.类的成员变量与方法、构造方法 在程序中经常要对时间进行操作但是并没有时间类型的数据。
* 那么我们可以自己实现一个时间类来满足程序中的需要。
* 定义名为MyTime的类其中应有三个整型成员时hour分minute秒second
* 为了保证数据的安全性这三个成员变量应声明为私有。
* 为MyTime类定义构造方法以方便创建对象时初始化成员变量。
* 再定义diaplay方法用于将时间信息打印出来。
* 为MyTime类添加以下方法 addSecond(int sec)
* addMinute(int min)
* addHour(int hou)
* subSecond(int sec)
* subMinute(int min)
* subHour(int hou) 分别对时、分、秒进行加减运算。
*/
public static void main(String[] args) {
// TODO 自动生成的方法存根
Time time = new Time(1,2,3);
time.diaplay();
time.subHour(1);
time.diaplay();
time.subMinute(1);
time.subSecond(1);
time.diaplay();
}
}
/*
* 03.类的成员变量与方法、构造方法 在程序中经常要对时间进行操作但是并没有时间类型的数据。
* 那么我们可以自己实现一个时间类来满足程序中的需要。
* 定义名为MyTime的类其中应有三个整型成员时hour分minute秒second
* 为了保证数据的安全性这三个成员变量应声明为私有。
* 为MyTime类定义构造方法以方便创建对象时初始化成员变量。
* 再定义diaplay方法用于将时间信息打印出来。
* 为MyTime类添加以下方法
* addSecond(int sec)
* addMinute(int min)
* addHour(int hou)
* subSecond(int sec)
* subMinute(int min)
* subHour(int hou) 分别对时、分、秒进行加减运算。
*/
class Time{
private int hour;
private int minute;
private int second;
public Time(int hour, int minute, int second) {
this.hour = hour;
this.minute = minute;
this.second = second;
}
public void diaplay(){
System.out.println("当前时间："+hour+":"+minute+":"+second);
}
public void addMinute(int min){
minute = minute+min;
}
public void addHour(int hour){
this.hour+=hour;
}
public void addSecond(int sec){
second+=sec;
}
public void subHour(int hour){
this.hour-=hour;
}
public void subMinute(int minute){
this.minute-=minute;
}
public void subSecond(int second){
this.second-=second;
}
}
【练习题】04.构造方法 编写Java程序模拟简单的计算器。 定义名为Number的类其中有两个整型数据成员n1和n2应声明为私有。编写构造方法赋予n1和n2初始值再为该类定义加addition、减subtration、乘multiplication、除division等公有成员方法分别对两个成员变量执行加、减、乘、除的运算。 在main方法中创建Number类的对象调用各个方法并显示计算结果。
package practise;
/*
* 04.构造方法 编写Java程序模拟简单的计算器。
* 定义名为Number的类其中有两个整型数据成员n1和n2应声明为私有。
* 编写构造方法赋予n1和n2初始值
* 再为该类定义
* 加addition、
* 减subtration、
* 乘multiplication、
* 除division等公有成员方法分别对两个成员变量执行
* 加、减、乘、除的运算。
* 在main方法中创建Number类的对象调用各个方法并显示计算结果。
*/
public class Number {
public static void main(String[] args) {
Numbers n = new Numbers(2,3);
n.multiplication();
n.addition();
n.divusion();
n.subtration();
}
}
class Numbers{
private int n1;
private int n2;
public Numbers(int n1, int n2) {
this.n1 = n1;
this.n2 = n2;
}
public Numbers(){
this.n1=0;
this.n2=0;
}
public int getN1() {
return n1;
}
public void setN1(int n1) {
this.n1 = n1;
}
public int getN2() {
return n2;
}
public void setN2(int n2) {
this.n2 = n2;
}
public void addition(){
System.out.println(n1+n2);
}
public void subtration(){
System.out.println(n1-n2);
}
public void multiplication(){
System.out.println(n1*n2);
}
public void divusion(){
System.out.println(n1/n2);
}
}
【练习题】05.构造方法 编写Java程序用于显示人的姓名和年龄。 定义一个人类Person该类中应该有两个私有属性姓名name和年龄age。定义构造方法用来初始化数据成员。再定义显示display方法将姓名和年龄打印出来。 在main方法中创建人类的实例然后将信息显示。
package practise;
/*
* 05.构造方法 编写Java程序用于显示人的姓名和年龄。
* 定义一个人类Person该类中应该有两个私有属性姓名name和年龄age。
* 定义构造方法用来初始化数据成员。
* 再定义显示display方法将姓名和年龄打印出来。
* 在main方法中创建人类的实例然后将信息显示。
*/
public class PersonDemo {
public static void main(String[] args) {
Person p = new Person("张三",25);
p.display();
p.setName("李四");
p.setAge(30);
p.display();
}
}
class Person{
private String name;
private int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public void display(){
System.out.println("姓名："+name+" 年龄:"+age);
}
}
【练习题】06.get方法和set方法 定义一个类该类有一个私有成员变量通过构造方法将其进行赋初值并提供该成员的getXXX()和setXXX()方法 提示假设有private String name;
这个不再赘述，参考练习5
【练习题】07.构造方法与重载 为“无名的粉”写一个类class WuMingFen 要求： 1.有三个属性 面码:String theMa 粉的分量(两) int quantity 是否带汤 boolean likeSoup 2.写一个构造方法 以便于简化初始化过程 如 WuMingFen f1 = new WuMingFen("牛肉",3,true); 3.重载构造方法 使得初始化过程可以多样化 WuMingFen f2 = new WuMingFen("牛肉",2); 4.如何使得下列语句构造出来的粉对象是酸辣面码、2两、带汤的 WuMingFen f3 = new WuMingFen(); 5.写一个普通方法 check() 用于查看粉是否符合要求。即 将对象的三个属性打印在控制台上。
package practise;
/*
* 07.构造方法与重载 为“无名的粉”写一个类class WuMingFen
* 要求： 1.有三个属性 面码:String theMa
* 粉的分量(两) int quantity
* 是否带汤 boolean likeSoup
* 2.写一个构造方法 以便于简化初始化过程
* 如 WuMingFen f1 = new WuMingFen("牛肉",3,true);
* 3.重载构造方法 使得初始化过程可以多样化 WuMingFen f2 = new WuMingFen("牛肉",2);
* 4.如何使得下列语句构造出来的粉对象是酸辣面码、2两、带汤的 WuMingFen f3 = new WuMingFen();
* 5.写一个普通方法 check() 用于查看粉是否符合要求。即 将对象的三个属性打印在控制台上。
*/
public class WuMingFenDemo {
public static void main(String[] args) {
// TODO 自动生成的方法存根
WuMingFen w = new WuMingFen("酸辣粉",3,true);
w.check();
}
}
class WuMingFen{
private String theMa;
private int quantity;
private boolean likeSoup;
public WuMingFen(String theMa, int quantity, boolean likeSoup) {
super();
this.theMa = theMa;
this.quantity = quantity;
this.likeSoup = likeSoup;
}
public WuMingFen(String theMa, int quantity) {
super();
this.theMa = theMa;
this.quantity = quantity;
}
public void check(){
String str ;
if(likeSoup){
str = "带汤的";
}else{
str = "没汤的";
}
System.out.println(this.theMa+","+this.quantity+","+str);
}
}
【练习题】08.构造方法的重载 定义一个名为Vehicles 交通工具 的基类 该类中应包含String类型的成员属性brand 商标 和color 颜色 还应包含成员方法run 行驶 在控制台显示“我已经开动了” 和showInfo 显示信息 在控制台显示商标和颜色 并编写构造方法初始化其成员属性。 编写Car 小汽车 类继承于Vehicles类 增加int型成员属性seats 座位 还应增加成员方法showCar 在控制台显示小汽车的信息 并编写构造方法。 编写Truck 卡车 类继承于Vehicles类 增加float型成员属性load 载重 还应增加成员方法showTruck 在控制台显示卡车的信息 并编写构造方法。 在main方法中测试以上各类。
package practise;
/*
* 08.构造方法的重载 定义一个名为Vehicles 交通工具 的基类
* 该类中应包含String类型的成员属性brand 商标 和
* color 颜色
* 还应包含成员方法run 行驶
* 在控制台显示“我已经开动了”
* 和showInfo 显示信息
* 在控制台显示商标和颜色
* 并编写构造方法初始化其成员属性。
* 编写Car 小汽车 类继承于Vehicles类
* 增加int型成员属性seats 座位
* 还应增加成员方法showCar 在控制台显示小汽车的信息
* 并编写构造方法。
* 编写Truck 卡车 类继承于Vehicles类
* 增加float型成员属性load 载重
* 还应增加成员方法showTruck 在控制台显示卡车的信息 并编写构造方法。
* 在main方法中测试以上各类。
*/
public class VehiclesDemo {
public static void main(String[] args) {
Vehicles v = new Vehicles("宝马","红色");
v.showInfo();
v.run();
Car c = new Car("宝马","红色",4);
c.showCar();
c.run();
Truck t = new Truck("宝马","红色",100.1f);
t.showTruck();
t.run();
}
}
/*
* 定义一个名为Vehicles 交通工具 的基类
* 该类中应包含String类型的成员属性brand 商标 和
* color 颜色
* 还应包含成员方法run 行驶
* 在控制台显示“我已经开动了”
* 和showInfo 显示信息
* 在控制台显示商标和颜色
* 并编写构造方法初始化其成员属性。
*/
class Vehicles{
public String brand;
public String color;
public void run(){
System.out.println("我已经开动了");
}
public void showInfo(){
System.out.println("商标:"+brand+" \n颜色："+color);
}
public Vehicles(String brand, String color) {
this.brand = brand;
this.color = color;
}
}
/*
* 写Car 小汽车 类继承于Vehicles类
* 增加int型成员属性seats 座位
* 还应增加成员方法showCar 在控制台显示小汽车的信息
* 并编写构造方法。
*/
class Car extends Vehicles{
private int seats;
public void showCar(){
System.out.println("商标:"+this.brand+" \n颜色："+this.color+"\n 座位："+this.seats);
}
public Car(String brand, String color, int seats) {
super(brand, color);
this.seats = seats;
}
}
/*
* 编写Truck 卡车 类继承于Vehicles类
* 增加float型成员属性load 载重
* 还应增加成员方法showTruck 在控制台显示卡车的信息 并编写构造方法。
*/
class Truck extends Vehicles{
private float load;
public Truck(String brand, String color, float load) {
super(brand, color);
this.load = load;
}
public void showTruck(){
System.out.println("商标:"+this.brand+" \n颜色："+this.color+"\n 载重："+this.load);
}
}
【练习题】09.构造方法与重载 定义一个网络用户类 要处理的信息有用户ID、用户密码、email地址。在建立类的实例时 把以上三个信息都作为构造函数的参数输入 其中用户ID和用户密码时必须的 缺省的email地址是用户ID加上字符串"@gameschool.com"
package practise;
/*
* 09.构造方法与重载 定义一个网络用户类
* 要处理的信息有用户ID、用户密码、email地址。
* 在建立类的实例时 把以上三个信息都作为构造函数的参数输入
* 其中用户ID和用户密码时必须的
* 缺省的email地址是用户ID加上字符串"@gameschool.com"
*/
public class UerInfoDemo {
public static void main(String[] args) {
// TODO 自动生成的方法存根
UerInfo u = new UerInfo("zhangsan","123567");
u.prin();
}
}
class UerInfo{
private String userID;
private String password;
private String Email;
public UerInfo(String userID, String password, String email) {
super();
this.userID = userID;
this.password = password;
Email = email;
}
public UerInfo(String userID, String password) {
super();
this.userID = userID;
this.password = password;
this.Email = userID+"@gameschool.com";
}
public void prin(){
System.out.println(userID+","+password+","+Email);
}
}
【练习题】10.构造方法与重载、包 编写Addition类 该类中应包含一组实现两数相加运算的重载方法。 实现加法运算的方法 应接受两个参数 即加数和被加数 方法将两个参数进行加法运算后 返回相加结果。考虑可能针对不同的数据类型进行计算 重载一组方法 包括整型、长整型、浮点型、双精度浮点型、还有字符串。 在main方法中创建Addition类的实例 分别调用重载方法测试其效果。
package practise;
/*
* 10.构造方法与重载、包 编写Addition类
* 该类中应包含一组实现两数相加运算的重载方法。
* 实现加法运算的方法 应接受两个参数
* 即加数和被加数 方法将两个参数进行加法运算后 返回相加结果。
* 考虑可能针对不同的数据类型进行计算 重载一组方法
* 包括整型、长整型、浮点型、双精度浮点型、还有字符串。
* 在main方法中创建Addition类的实例
* 分别调用重载方法测试其效果。
*
*/
public class AdditionDemo {
public static void main(String[] args) {
// TODO 自动生成的方法存根
Addition a = new Addition();
a.addition(1, 2);
a.addition(1.2, 2.3);
a.addition("1", "2");
}
}
class Addition{
// 整型、长整型、浮点型、双精度浮点型、还有字符串。
public void addition(int s1,int s2){
System.out.println(s1+s2);
}
public void addition(long l1,long l2){
long l = l1+l2;
System.out.println(l);
}
public void addition(float f1,float f2){
float f = f1+f2;
System.out.println(f);
}
public void addition(double b1,double b2){
double b = b1+b2;
System.out.println(b);
}
public void addition(String s1,String s2){
String s = s1+s2;
System.out.println(s);
}
}
【练习题】12.构造方法与重载 建立一个汽车类 包括轮胎个数 汽车颜色 车身重量等属性。并通过不同的构造方法创建事例。 至少要求 汽车能够加速 减速 停车。 要求 命名规范 代码体现层次 有友好的操作提示。
package practise;
/*
* 12.构造方法与重载 建立一个汽车类 包括轮胎个数 汽车颜色 车身重量等属性。
* 并通过不同的构造方法创建事例。
* 至少要求 汽车能够加速 减速 停车。
* 要求 命名规范 代码体现层次 有友好的操作提示。
*/
public class CarDemo {
public static void main(String[] args) {
// TODO 自动生成的方法存根
Car2 car = new Car2(4,"黄色",100);
car.addSpeed();
car.prin();
car.addSpeed(50);
car.prin();
car.subSpeed(10);
car.prin();
car.breakCar();
}
}
class Car2{
private int tyreNum;//轮胎数量
private String color;//颜色
private double weight;//重量
private int speed;
public Car2(int tyreNum, String color, double weight) {//有参构造
super();
this.tyreNum = tyreNum;
this.color = color;
this.weight = weight;
this.speed = 0;
}
public Car2() {//无参构造
this.tyreNum = 4;
this.color = "白色";
this.weight = 88.8;
this.speed =0;
}
public int getTyreNum() {
return tyreNum;
}
public void setTyreNum(int tyreNum) {
this.tyreNum = tyreNum;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
public double getWeight() {
return weight;
}
public void setWeight(double weight) {
this.weight = weight;
}
public int getSpeed() {
return speed;
}
public void setSpeed(int speed) {
this.speed = speed;
}
public void addSpeed(){
speed+=1;
}
public void addSpeed(int speed){
this.speed+=speed;
}
public void subSpeed(int Speed){
this.speed-=speed;
}
public void subSpeed(){
this.speed-=1;
}
public void breakCar(){
System.out.println("紧急刹车");
}
public void prin(){
System.out.println("轮胎数量："+tyreNum+"\t车身颜色："+color+"\t车身重量："+weight+"\t当前速度"+speed);
}
}
【练习题】13.构造方法与重载 创建一个类 为该类定义三个构造函数 分别执行下列操作 1、传递两个整数值并找出其中较大的一个值 2、传递三个double值并求出其乘积 3、传递两个字符串值并检查其是否相同 4、在main方法中测试构造函数的调用
package practise;
/*
* 【练习题】13.构造方法与重载 创建一个类
* 为该类定义三个构造函数 分别执行下列操作
* 1、传递两个整数值并找出其中较大的一个值
* 2、传递三个double值并求出其乘积
* 3、传递两个字符串值并检查其是否相同
* 4、在main方法中测试构造函数的调用
*/
public class OverLoadingDemo {
public static void main(String[] args) {
// TODO 自动生成的方法存根
OverLoading o = new OverLoading(2,3);
OverLoading v = new OverLoading(2,2,3);
OverLoading s = new OverLoading("a","a");
}
}
class OverLoading{
public OverLoading(int max1,int max2){
if(max1>max2){
System.out.println("最大值为:"+max2);
return;
}
System.out.println("最大值为:"+max1);
}
public OverLoading(double b1,double b2,double b3){
double b = b1*b2*b3;
System.out.println(b);
}
public OverLoading(String str1,String str2){
if (str1.equals(str2)) {
System.out.println(true);
return;
}
System.out.println(false);
}
}
【练习题】14.Static关键字与普通变量的区别 创建一个名称为StaticDemo的类 并声明一个静态变量和一个普通变量。对变量分别赋予10和5的初始值。在main()方法中输出变量值。
静态变量只在内存中存在一个。
package practise;
/*
* 【练习题】14.Static关键字与普通变量的区别
* 创建一个名称为StaticDemo的类
* 并声明一个静态变量和一个普通变量。
* 对变量分别赋予10和5的初始值。
* 在main()方法中输出变量值。
*/
public class StaticDemo {
public static void main(String[] args) {
// TODO 自动生成的方法存根
Static s = new Static();
Static t = new Static();
s.add();
s.prin();
t.add();
t.prin();
}
}
class Static{
public static int staticInt = 5;
public int s = 10;
public void add(){
staticInt++;
s++;
}
public void prin(){
System.out.println("Static变量值为："+staticInt+"\t普通变量为："+s);
}
}
这一题的输出结果为
Static变量值为：6 普通变量为：11 Static变量值为：7 普通变量为：11
【练习题】20.抽象类 创建一个Vehicle类并将它声明为抽象类。在Vehicle类中声明一个NoOfWheels方法 使它返回一个字符串值。创建两个类Car和Motorbike从Vehicle类继承 并在这两个类中实现NoOfWheels方法。在Car类中 应当显示“四轮车”信息 而在Motorbike类中 应当显示“双轮车”信息。创建另一个带main方法的类 在该类中创建Car和Motorbike的实例 并在控制台中显示消息。
package practise;
/*
* 【练习题】20.抽象类 创建一个Vehicle类并将它声明为抽象类。
* 在Vehicle类中声明一个NoOfWheels方法 使它返回一个字符串值。
* 创建两个类Car和Motorbike从Vehicle类继承
* 并在这两个类中实现NoOfWheels方法。
* 在Car类中 应当显示“四轮车”信息 而在Motorbike类中
* 应当显示“双轮车”信息。
* 创建另一个带main方法的类
* 在该类中创建Car和Motorbike的实例
* 并在控制台中显示消息。
*/
public class VehicleDemo {
public static void main(String[] args) {
// TODO 自动生成的方法存根
System.out.println(new Car4().NoOfWheels());
System.out.println(new Motorbike().NoOfWheels());
}
}
abstract class Vehicle2{
public abstract String NoOfWheels();
}
/*
* 创建两个类Car和Motorbike从Vehicle类继承
* 并在这两个类中实现NoOfWheels方法。
* 在Car类中 应当显示“四轮车”信息 而在Motorbike类中
*/
class Car4 extends Vehicle2{
@Override
public String NoOfWheels() {
// TODO 自动生成的方法存根
return "四轮车";
}
}
class Motorbike extends Vehicle2{
@Override
public String NoOfWheels() {
// TODO 自动生成的方法存根
return "双轮车";
}
}
【练习题】22.接口 创建一个名称为Vehicle的接口 在接口中添加两个带有一个参数的方法start()和stop()。在两个名称分别为Bike和Bus的类中实现Vehicle接口。创建一个名称为interfaceDemo的类 在interfaceDemo的main()方法中创建Bike和Bus对象 并访问start()和stop()方法。
package practise;
/*
* 【练习题】22.接口 创建一个名称为Vehicle的接口
* 在接口中添加两个带有一个参数的方法start()和stop()。
* 在两个名称分别为Bike和Bus的类中实现Vehicle接口。
* 创建一个名称为interfaceDemo的类
* 在interfaceDemo的main()方法中创建Bike和Bus对象
* 并访问start()和stop()方法。
*/
public class VehicleDemo2 {
public static void main(String[] args) {
// TODO 自动生成的方法存根
new Bike().start();
new Bike().stop();
new Bus().start();
new Bus().stop();
}
}
interface Vehicle3{
public void start();
public void stop();
}
class Bike implements Vehicle3{
@Override
public void start() {
System.out.println("start");
}
@Override
public void stop() {
// TODO 自动生成的方法存根
System.out.println("stop");
}
}
class Bus implements Vehicle3{
@Override
public void start() {
System.out.println("start2");
}
@Override
public void stop() {
System.out.println("stop2");
}
}
【练习题】24.抽象类、继承、接口综合 设计一个系统 XXX门的实现过程 流程 设计一张抽象的门Door 那么对于这张门来说 就应该拥有所有门的共性 开门openDoor()和关门closeDoor() 然后对门进行另外的功能设计,防盗--theftproof()、防水--waterproof()、防弹--bulletproof()、防火、防锈…… 要求 利用继承、抽象类、接口的知识设计该门
接口 Imen
接口 Imen
package practise;
/*
* 【练习题】24.抽象类、继承、接口综合
* 设计一个系统 XXX门的实现过程 流程 设计一张抽象的门Door
* 那么对于这张门来说 就应该拥有所有门的共性 开门openDoor()和关门closeDoor()
* 然后对门进行另外的功能设计,
* 防盗--theftproof()、
* 防水--waterproof()、
* 防弹--bulletproof()、
* 防火、防锈…… 要求 利用继承、抽象类、接口的知识设计该门
接口 Imen
*/
public class DoorDemo {
public static void main(String[] args) {
// TODO 自动生成的方法存根
DoorTest d = new DoorTest();
d.bulletproof();
d.waterproof();
d.bulletproof();
d.closeDoor();
d.openDoor();
}
}
abstract class Door{
public abstract void openDoor();
public abstract void closeDoor();
}
interface Imen{
public void theftproof();
public void waterproof();
public void bulletproof();
}
class DoorTest extends Door implements Imen{
@Override
public void theftproof() {
System.out.println("防盗");
}
@Override
public void waterproof() {
// TODO 自动生成的方法存根
System.out.println("防水");
}
@Override
public void bulletproof() {
// TODO 自动生成的方法存根
System.out.println("防弹");
}
@Override
public void openDoor() {
// TODO 自动生成的方法存根
System.out.println("开门");
}
@Override
public void closeDoor() {
// TODO 自动生成的方法存根
System.out.println("关门");
}
}
【练习题】26.综合题 定义一个抽象的"Role"类 有姓名 年龄 性别等成员变量 1. 要求尽可能隐藏所有变量(能够私有就私有,能够保护就不要公有) 再通过GetXXX()和SetXXX()方法对各变量进行读写。具有一个抽象的play()方法 该方法不返回任何值 同时至少定义两个构造方法。Role类中要体现出this的几种用法。 2. 从Role类派生出一个"Employee"类 该类具有Role类的所有成员 构造方法除外 并扩展 salary成员变量 同时增加一个静态成员变量“职工编号 ID ”。同样要有至少两个构造方法 要体现出this和super的几种用法 还要求覆盖play()方法 并提供一个final sing()方法。 3. "Manager"类继承"Employee"类 有一个final成员变量"vehicle" 4. 在main()方法中制造Manager和Employee对象,并测试这些对象的方法
package practise;
/*
* 【练习题】26.综合题 定义一个抽象的"Role"类
* 有姓名 年龄 性别等成员变量
* 1. 要求尽可能隐藏所有变量(能够私有就私有,能够保护就不要公有)
* 再通过GetXXX()和SetXXX()方法对各变量进行读写。
* 具有一个抽象的play()方法 该方法不返回任何值
* 同时至少定义两个构造方法。Role类中要体现出this的几种用法。
* 2. 从Role类派生出一个"Employee"类 该类具有Role类的所有成员
* 构造方法除外 并扩展 salary成员变量
* 同时增加一个静态成员变量“职工编号 ID ”。
* 同样要有至少两个构造方法 要体现出this和super的几种用法
* 还要求覆盖play()方法 并提供一个final sing()方法。
* 3. "Manager"类继承"Employee"类 有一个final成员变量"vehicle"
* 4. 在main()方法中制造Manager和Employee对象,并测试这些对象的方法
*/
public class RoleDemo {
public static void main(String[] args) {
// TODO 自动生成的方法存根
Manager m = new Manager("张三","30","ID","vehicle");
Employee e = new Employee("张三","30","ID");
m.play();
m.sing();
}
}
/*
* * 有姓名 年龄 性别等成员变量
* 1. 要求尽可能隐藏所有变量(能够私有就私有,能够保护就不要公有)
* 再通过GetXXX()和SetXXX()方法对各变量进行读写。
* 具有一个抽象的play()方法 该方法不返回任何值
* 同时至少定义两个构造方法。Role类中要体现出this的几种用法。
*/
abstract class Role{
private String name;
private String age;
private String sex;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getAge() {
return age;
}
public void setAge(String age) {
this.age = age;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public abstract void play();
public Role(String name, String age, String sex) {
super();
this.name = name;
this.age = age;
this.sex = sex;
}
public Role(String name, String age) {
super();
this.name = name;
this.age = age;
this.sex = "男";
}
}
/*
* * 2. 从Role类派生出一个"Employee"类 该类具有Role类的所有成员
* 构造方法除外 并扩展 salary成员变量
* 同时增加一个静态成员变量“职工编号 ID ”。
* 同样要有至少两个构造方法 要体现出this和super的几种用法
* 还要求覆盖play()方法 并提供一个final sing()方法。
*/
class Employee extends Role{
private String userID;
public Employee(String name, String age, String sex,String userID) {
super(name, age, sex);
this.userID = userID;
// TODO 自动生成的构造函数存根
}
public Employee(String name, String age,String userID) {
super(name, age);
this.userID = userID;
}
@Override
public void play() {
System.out.println("重写的Play方法");
}
public final void sing(){
System.out.println("sing方法");
}
public String getUserID() {
return userID;
}
public void setUserID(String userID) {
this.userID = userID;
}
}
/**
3. "Manager"类继承"Employee"类 有一个final成员变量"vehicle"
*/
class Manager extends Employee{
private final String vehicle;
public Manager(String name, String age, String sex, String userID, String vehicle) {
super(name, age, sex, userID);
this.vehicle = vehicle;
}
public Manager(String name, String age, String userID, String vehicle) {
super(name, age, userID);
this.vehicle = vehicle;
}
}