zoukankan html css js c++ java

Java练手题

作者：innerClass
链接：https://www.jianshu.com/p/886252693889
來源：简书
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

【练习题】01.类的成员变量猜数字游戏一个类A有一个成员变量v有一个初值100。定义一个类对A类的成员变量v进行猜。如果大了则提示大了小了则提示小了。等于则提示猜测成功。

import java.util.*;
public class lianxi
{
    public static void main(String[] dsa)
    {
    A a=new A();
    Scanner input=new Scanner(System.in);
    while (1==1)
    {
        System.out.println("请猜测数字");
        int i=input.nextInt();
        if (i<a.v)
        {
            System.out.println("小了");
            continue;
        }
        else if (i>a.v)
        {
            System.out.println("大了");
            continue;
        }
        else
        {
            System.out.println("恭喜你猜对了！");
            break;
        }
    }
    }
}
class A
{
    public int v=100;
}

【练习题】02.类的成员变量请定义一个交通工具(Vehicle)的类其中有: 属性速度(speed)体积(size)等等方法移动(move())设置速度(setSpeed(int speed))加速speedUp(),减速speedDown()等等. 最后在测试类Vehicle中的main()中实例化一个交通工具对象并通过方法给它初始化speed,size的值并且通过打印出来。另外调用加速减速的方法对速度进行改变。

public class Vehicle
{
    private int speed;
    private String size;
    public void move()
    {
    System.out.println("i'm moving");
    }
    public void setSpeed(int speed)
    {
        System.out.println("now i'm running with"+speed+"per hour");
    }
    public void speedUp()
    {
        Vehicle v=new Vehicle();
        v.setSpeed(1000);
    }
    public void speedDown()
    {
    Vehicle v=new Vehicle();
        v.setSpeed(20);
    }
    public static void main(String[] dsa)
    {
    Vehicle v=new Vehicle();
    v.speed=100;
    v.size="50/m^3";
    System.out.println("the initial speed is"+v.speed+"and my size is "+v.size);
    v.speedUp();
    v.speedDown();
    }
}

【练习题】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 class MyTime
{
    private int hour;
    private int minute;
    private int second;
    public MyTime(int x,int y,int z)
    {
    this.hour=x;
    this.minute=y;
    this.second=z;
    }
    public void display()
    {
    System.out.println("the time is "+this.hour+":"+this.minute+":"+this.second);
    }
    public void addHour(int hou)
    {
    this.hour=this.hour+hou;
    }
    public void addSecond(int sec)
    {
    this.second=this.second+sec;
    }
    public void addMinute(int min)
    {
    this.minute=this.minute+min;
    }
    public void subHour(int hou)
    {
    this.hour=this.hour-hou;
    }
    public void subMinute(int min)
    {
    this.minute=this.minute-min;
    }
    public void subSecond(int sec)
    {
    this.second=this.second-sec;
    }
}

【练习题】04.构造方法编写Java程序模拟简单的计算器。定义名为Number的类其中有两个整型数据成员n1和n2应声明为私有。编写构造方法赋予n1和n2初始值再为该类定义加addition、减subtration、乘multiplication、除division等公有成员方法分别对两个成员变量执行加、减、乘、除的运算。在main方法中创建Number类的对象调用各个方法并显示计算结果。

public class Number
{
    private int x;
    private int y;
    public Number(int x,int y)
    {
    this.x=x;
    this.y=y;
    }
    public void plus()
    {
    System.out.println("the result is:"+(this.x+this.y));
    }
    public void except()
    {
    System.out.println("the result is :"+(this.x-this.y));
    }
    public void multiplication()
    {
    System.out.println("the result is :"+(this.x*this.y));
    }
    public void division()
    {
    System.out.println("the result is :"+(this.x/this.y));
    }
    public static void main(String[] dsa)
    {
    Number lian=new Number(4,4);
    lian.plus();
    lian.except();
    lian.multiplication();
    lian.division();
    }
}

【练习题】05.构造方法编写Java程序用于显示人的姓名和年龄。定义一个人类Person该类中应该有两个私有属性姓名name和年龄age。定义构造方法用来初始化数据成员。再定义显示display方法将姓名和年龄打印出来。在main方法中创建人类的实例然后将信息显示。

public class lianxi
{
    private String name;
    private int age;
    public lianxi(String name,int age)
    {
    this.name=name;
    this.age=age;
    }
    public void display()
    {
    System.out.println("name:"+name+"	age:"+age);
    }
    public static void main(String[] dsa)
    {
    lianxi lian=new lianxi("wing",29);
    lian.display();
    }
}

【练习题】06.get方法和set方法定义一个类该类有一个私有成员变量通过构造方法将其进行赋初值并提供该成员的getXXX()和setXXX()方法提示假设有private String name;则有

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

public class lianxi
{
    private int i;
    public lianxi(int i)
    {
        lianxi lian=new lianxi();
    lian.seti(i);
    lian.geti();
    System.out.println("i="+i);
    }
    public lianxi()
    {}
    public int geti()
    {
    return i;
    }
    public void seti(int i)
    {
    this.i=i;
    }
    public static void main(String[] dsa)
    {
    lianxi lian=new lianxi(3);
    }
}

【练习题】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 WuMingFen 
{
    private String theMa;
    private int quantity;
    private boolean likeSoup;
    public WuMingFen (String s,int i,boolean b)
    {
    this.theMa=s;
    this.quantity=i;
    this.likeSoup=b;
    }
    public WuMingFen (String s,int i)
    {
    this.theMa=s;
    this.quantity=i;
    }
    public WuMingFen (String s,boolean b,int i)
    {
    this.theMa=s;
    this.quantity=i;
    this.likeSoup=b;
    if (b==true)
    {
        String b1="带汤的";
        System.out.println(theMa+quantity+"两"+b1);
    }
    }
    public void check()
    {
        if (likeSoup==true)
    {
        String b1="带汤的";
        System.out.println("面码："+theMa+"
分量"+quantity+"
"+b1);
    }
    else
        {
        String b1="不带汤的";
        System.out.println("面码："+theMa+"
分量"+quantity+"
"+b1);
    }
    }
    public static void main(String[] args)
    {
    WuMingFen lian=new WuMingFen ("沙茶面",2,true);
    lian.check();
    }
}

【练习题】08.构造方法的重载定义一个名为Vehicles 交通工具的基类该类中应包含String类型的成员属性brand 商标和color 颜色还应包含成员方法run 行驶在控制台显示“我已经开动了” 和showInfo 显示信息在控制台显示商标和颜色并编写构造方法初始化其成员属性。编写Car 小汽车类继承于Vehicles类增加int型成员属性seats 座位还应增加成员方法showCar 在控制台显示小汽车的信息并编写构造方法。编写Truck 卡车类继承于Vehicles类增加float型成员属性load 载重还应增加成员方法showTruck 在控制台显示卡车的信息并编写构造方法。在main方法中测试以上各类。

public class Vehicles 
{
    public String brand;
    public String color;
    public void run()
    {
    System.out.println("i am running");
    }
    public Vehicles(String b, String b1)
    {
    this.brand=b;
    this.color=b1;
    }
    public void showInfo()
    {
    System.out.println("brand:"+this.brand+"	color:"+this.color);
    }
    public static void main(String[] dad)
    {
    Vehicles lian=new Vehicles ("Lamborgihini","yellow");
    lian.showInfo();
    car c=new car("Aventador","green",6);
    c.showCar();
    Truck t=new Truck("Dongfangxuetielong","Bule",12);
    t.showTruck();
    }
}
class car extends Vehicles 
{
    public int seat;
    public void showCar()
    {
    System.out.println("i am a "+this.brand+"my color is "+this.color+"i have "+this.seat+"seats~");
    }
    public car(String b, String b1,int s)
    {
    super(b,b1);
    this.seat=s;
    }
}
class Truck extends Vehicles 
{
    public float load;
    public void showTruck()
    {
    System.out.println("i am a "+this.brand+"my color is "+this.color+"i can stand "+this.load+"tons of materials");
    }
    public Truck(String b, String b1,float f)
    {
    super(b,b1);
    this.load=f;
    }
}

【练习题】09.构造方法与重载定义一个网络用户类要处理的信息有用户ID、用户密码、email地址。在建立类的实例时把以上三个信息都作为构造函数的参数输入其中用户ID和用户密码时必须的缺省的email地址是用户ID加上字符串"@gameschool.com"

public class UerInfo
{
    private int id;
    private String pwd;
    private String e_add;
    public UerInfo(int i,String s,String s1)
    {
    this.id=i;
    this.pwd=s;
    this.e_add=s1;
    System.out.println(id+"
"+pwd+"
"+e_add);
    }
    public UerInfo(int i,String s)
    {
    this.id=i;
    this.pwd=s;
    this.e_add=id+"@gameschool.com";
    System.out.println(id+"
"+pwd+"
"+e_add);
    }
    public static void main(String[] dsa)
    {
    UerInfo uer=new UerInfo(1201012204,"dwajldwajlj","1111111111@gameschool.com");
    UerInfo u=new UerInfo(1201012204,"dwijadiwjal");
    }
}

【练习题】10.构造方法与重载、包编写Addition类该类中应包含一组实现两数相加运算的重载方法。实现加法运算的方法应接受两个参数即加数和被加数方法将两个参数进行加法运算后返回相加结果。考虑可能针对不同的数据类型进行计算重载一组方法包括整型、长整型、浮点型、双精度浮点型、还有字符串。在main方法中创建Addition类的实例分别调用重载方法测试其效果。应将Addition类打入到包中以自己名字的拼音为包命名。

package cj.lian;
public class lianxi
{
    public void additionInt(int x,int y)
    {
    int sum=x+y;
    System.out.println("sum="+sum);
    }
    public void additionLong(long x,long y)
    {
    long sum=x+y;
    System.out.println("sum="+sum);
    }
    public void additionFloat(float x,float y)
    {
    float sum=x+y;
    System.out.println("sum="+sum);
    }
    public void additionDouble(double x,double y)
    {
    double sum=x+y;
    System.out.println("sum="+sum);
    }
    public void additionString(String x,String y)
    {
    String sum=x+y;
    System.out.println("sum="+sum);
    }
    public static void main(String[] dsa)
    {
        lianxi lian=new lianxi();
        lian.additionInt(1,2);
        lian.additionString("1","2");
    }
}

【练习题】11.构造方法与重载将上次练习题三中编写的MyTime类打到以自己名字的拼音命名的包中并为该类重载一组构造方法以方便使用者能够以多种形式初始化该类的实例。

package java.time;
public class MyTime
{
   private int hour;
   private int minute;
   private int second;
   public MyTime(int x,int y,int z)
   {
   this.hour=x;
   this.minute=y;
   this.second=z;
   }
   public MyTime()
   {}
   public void display()
   {
   System.out.println("the time is "+this.hour+":"+this.minute+":"+this.second);
   }
   public void addHour(int hou)
   {
   this.hour=this.hour+hou;
   }
   public void addSecond(int sec)
   {
   this.second=this.second+sec;
   }
   public void addMinute(int min)
   {
   this.minute=this.minute+min;
   }
   public void subHour(int hou)
   {
   this.hour=this.hour-hou;
   }
   public void subMinute(int min)
   {
   this.minute=this.minute-min;
   }
   public void subSecond(int sec)
   {
   this.second=this.second-sec;
   }
   public static void main(String[] das)
   {
   MyTime t=new MyTime();
   t.display();
   }
}

编译包： javac -d . MyTime.java

【练习题】12.构造方法与重载建立一个汽车类包括轮胎个数汽车颜色车身重量等属性。并通过不同的构造方法创建事例。至少要求汽车能够加速减速停车。要求命名规范代码体现层次有友好的操作提示。

public class car
{
    private int lunzi;
    private String color;
    private double weight;
    public car(){}
    public car(int i,String s,double d)
    {
    this.lunzi=i;
    this.color=s;
    this.weight=d;
    }
    public void SpeedUp()
    {
    System.out.println("i am speeding up~");
    }
    public void SpeedDown()
    {
    System.out.println("i am speeding down~");
    }
    public void Stop()
    {
    System.out.println("i have stopped");
    }
    public static void main(String[] das)
    {
    car c=new car();
    car c1=new car(4,"yellow",1.45);
    c.SpeedUp();
    c.SpeedDown();
    c.Stop();
    }
}

【练习题】13.构造方法与重载创建一个类为该类定义三个构造函数分别执行下列操作 1、传递两个整数值并找出其中较大的一个值 2、传递三个double值并求出其乘积 3、传递两个字符串值并检查其是否相同 4、在main方法中测试构造函数的调用

public class lianxi
{
    public lianxi(int x,int y)
    {
    if (x>y)
    {
        System.out.println("The max is "+x);
    }
    else
        System.out.println("The max is "+y);
    }
    public lianxi(double d1,double d2,double d3)
    {
    double ji=d1*d2*d3;
    System.out.println("The multiply result is "+ji);
    }
    public lianxi(String s1,String s2)
    {
    boolean b;
    if (s1.equals(s2))
    {
        b=true;
        System.out.println(b);
    }
    else
    {
        b=false;
        System.out.println(b);
    }
    }
    public static void main(String[] dasd)
    {
    lianxi c=new lianxi(1,2);
    lianxi c1=new lianxi(1,2,3);
    lianxi c2=new lianxi("nihao","nihao");
    }
}

【练习题】14.Static关键字与普通变量的区别创建一个名称为StaticDemo的类并声明一个静态变量和一个普通变量。对变量分别赋予10和5的初始值。在main()方法中输出变量值。

public class StaticDemo
{
    private static int i=10;
    private int y=5;
    public static void main(String[] das)
    {
    StaticDemo s=new StaticDemo();
    System.out.println("The static digit is "+car.i+"
 and the normal digit is "+s.y);
    }
}

【练习题】15.继承创建一个名称为MainPackage的包使它包含MainClass和MainSubClass类。MainClass类应当包含变量声明其值从构造函数中输出。MainSubClass类从MainClass派生而来。试执行下列操作创建一个名称为SamePackage的类使它导入上述包并创建一个MainSubClass类的对象。

创建MainClass包--

package MainPackage.Main;
public class MainClass
{
public int i=10;
public MainClass()
{
 System.out.println(i);
 }
}

创建MainSubClass包--

package MainPackage.Main;
public class MainSubClass extends MainClass
{
 public MainSubClass (){}
}

创建SamePackage类---

import  MainPackage.Main.MainSubClass;
public class SamePackage 
{
    public static void main(String[] da)
    {
    MainSubClass m=new MainSubClass();
    }
}

【练习题】16.包、继承、构造函数创建一个名称为MainPackage的包使它包含MainClass和MainSubClass类。MainClass类应当包含变量声明其值从构造方法中输出。MainSubClass类从MainClass派生而来。试执行下列操作创建一个名称为SamePackage的类使它导入上述包并创建一个MainSubClass类的对象。

创建MainClass包--

package MainPackage.Main;
public class MainClass
{
public int i=10;
public MainClass()
{
 System.out.println(i);
 }
}

创建MainSubClass包--

package MainPackage.Main;
public class MainSubClass extends MainClass
{
 public MainSubClass (){}
}

创建SamePackage类---

import  MainPackage.Main.MainSubClass;
public class SamePackage 
{
    public static void main(String[] da)
    {
    MainSubClass m=new MainSubClass();
    }
}

【练习题】17.继承创建一个父类和子类父类有一个数据成员子类继承父类的该数据成员通过构造函数初始化并显示该数据成员的值。

 class Father
{
    public int i=10;
}
class Son extends Father
{
    public lianxi()
    {
    System.out.println(i);
    }
    public static void main(String[] dsa)
    {
    Son s=new Son ();
    }
}

【练习题】18.覆盖、继承建立一个汽车Auto类包括轮胎个数汽车颜色车身重量、速度等成员变量。并通过不同的构造方法创建实例。至少要求汽车能够加速减速停车。再定义一个小汽车类Car 继承Auto 并添加空调、CD等成员变量覆盖加速减速的方法

public class Auto
{
    public int luntai;
    public String color;
    public double weight;
    public int speed;
    public Auto(){}
    public void jiasu()
    {
    System.out.println("wo zai jiasu");
    }
    public void jiansu()
    {
    System.out.println("wo zai jiansu");
    }
    public void tingzhi()
    {
        System.out.println("wo bu kai le ");
    }
    public static void main(String[] dsa)
    {
    car c=new car();
    c.jiasu();
    c.jiansu();
    }
}
class car extends Auto
{
    public String air_condition;
    public String cd;
    public void jiasu()
    {
    System.out.println("wo shi jiaoche, wo zai jiasu");
    }
    public void jiansu()
    {
    System.out.println("wo shi jianche,wo zai jiansu");
    }
}
```java
【练习题】19.抽象类与继承 设计一个能细分为矩形、三角形、圆形和椭圆形的“图形”类。使用继承将这些图形分类 找出能作为基类部分的共同特征(如校准点)和方法(如画法、初始化) 并看看这些图形是否能进一步划分为子类。 本题只考虑实现思想 不考虑具体实现的细节 实现方式可自由发挥。
```java
abstract class tuxing
{
    public tuxing()
    {
    System.out.println("i am tuxing");
    }
    public static void main(String[] dsa)
    {
    juxing j=new juxing();
    circle c=new circle();
    tuoyuan t=new tuoyuan();
    }
}
class juxing extends tuxing
{
    public juxing()
    {
    System.out.println(" i am juxing");
    }
}
class circle extends tuxing
{
    public circle()
    {
    System.out.println("i am circle");
    }
}
class tuoyuan extends circle
{
    public tuoyuan()
    {
    System.out.println("i am tuoyuan");
    }
}

【练习题】20.抽象类创建一个Vehicle类并将它声明为抽象类。在Vehicle类中声明一个NoOfWheels方法使它返回一个字符串值。创建两个类Car和Motorbike从Vehicle类继承并在这两个类中实现NoOfWheels方法。在Car类中应当显示“四轮车”信息而在Motorbike类中应当显示“双轮车”信息。创建另一个带main方法的类在该类中创建Car和Motorbike的实例并在控制台中显示消息。

public class lianxi
{
    public static void main(String[] dsa)
    {
    Car c=new Car();
    c.NoOfWheels();
    Motorbike m=new Motorbike();
    m.NoOfWheels();
    }
}
abstract class Vehicle
{
    public void NoOfWheels(){}
}
class Car extends Vehicle
{
    public void NoOfWheels()
    {
    System.out.println("四轮车");
    }
}
class Motorbike extends Vehicle
{
    public void NoOfWheels()
    {
    System.out.println("双轮车");
    }
}

【练习题】21.抽象类创建一个Vehicle类并将它声明为抽象类。在Vehicle类中声明一个NoOfWheels方法使它返回一个字符串值。创建两个类Car和Motorbike从Vehicle类继承并在这两个类中实现NoOfWheels方法。在Car类中应当显示“四轮车”信息而在Motorbike类中应当显示“双轮车”信息。创建另一个带main方法的类在该类中创建Car和Motorbike的实例并在控制台中显示消息。

public class lianxi
{
    public static void main(String[] dsa)
    {
    Car c=new Car();
    c.NoOfWheels();
    Motorbike m=new Motorbike();
    m.NoOfWheels();
    }
}
abstract class Vehicle
{
    public void NoOfWheels(){}
}
class Car extends Vehicle
{
    public void NoOfWheels()
    {
    System.out.println("四轮车");
    }
}
class Motorbike extends Vehicle
{
    public void NoOfWheels()
    {
    System.out.println("双轮车");
    }
}

【练习题】22.接口创建一个名称为Vehicle的接口在接口中添加两个带有一个参数的方法start()和stop()。在两个名称分别为Bike和Bus的类中实现Vehicle接口。创建一个名称为interfaceDemo的类在interfaceDemo的main()方法中创建Bike和Bus对象并访问start()和stop()方法。

public interface Vehicle
{
    public void start();
    public void stop();
}//借口类
public class interfaceDemo
{
    public static void main(String[] dsa)
    {
        Bike bike=new Bike();
        bike.start();
        bike.stop();
        Bus bus=new Bus();
        bus.start();
        bus.stop();
    }
}
class Bike implements Vehicle
{
    public void start()
    {
    System.out.println("i am bike, i am running");
    }
    public void stop()
    {
    System.out.println("i am bke,i am stop");
    }
}
class Bus implements Vehicle
{
    public void start()
    {
    System.out.println("i am bus, i am running");
    }
    public void stop()
    {
    System.out.println("i am bke,i am stop");
    }
}

【练习题】23.接口创建一个名称为Vehicle的接口在接口中添加两个带有一个参数的方法start()和stop()。在两个名称分别为Bike和Bus的类中实现Vehicle接口。创建一个名称为interfaceDemo的类在interfaceDemo的main()方法中创建Bike和Bus对象并访问start()和stop()方法。

public interface Vehicle
{
    public void start();
    public void stop();
}//借口类
public class interfaceDemo
{
    public static void main(String[] dsa)
    {
        Bike bike=new Bike();
        bike.start();
        bike.stop();
        Bus bus=new Bus();
        bus.start();
        bus.stop();
    }
}
class Bike implements Vehicle
{
    public void start()
    {
    System.out.println("i am bike, i am running");
    }
    public void stop()
    {
    System.out.println("i am bke,i am stop");
    }
}
class Bus implements Vehicle
{
    public void start()
    {
    System.out.println("i am bus, i am running");
    }
    public void stop()
    {
    System.out.println("i am bke,i am stop");
    }
}

【练习题】24.抽象类、继承、接口综合设计一个系统 XXX门的实现过程流程设计一张抽象的门Door 那么对于这张门来说就应该拥有所有门的共性开门openDoor()和关门closeDoor() 然后对门进行另外的功能设计,防盗--theftproof()、防水--waterproof()、防弹--bulletproof()、防火、防锈…… 要求利用继承、抽象类、接口的知识设计该门
接口 Imen

public interface Imen
{
    public void threfproof();
    public void waterproof();
    public void fireproof();
    public void bulletproof();
    public void rustproof();
}
public class lianxi
{
    public static void main(String[] args)
    {
    men m=new men();
    m.opendoor();
    m.closedoor();
    }
}
abstract class Door
{
    public void opendoor(){};
    public void closedoor(){};
}
class men extends Door implements Imen
{
    public void opendoor()
    {
    System.out.println("i can open the door");
    }
    public void closedoor()
    {
    System.out.println("i can close the door");
    }
    public void threfproof()
    {
    System.out.println("i can threfproof");
    }
    public void waterproof()
    {
    System.out.println("i can waterproof");
    }
    public void fireproof()
    {
    System.out.println("i can fireproof");
    }
    public void bulletproof()
    {
    System.out.println("i can bulletproof");
    }
    public void rustproof()
    {
    System.out.println("i can rustproof");
    }
    
}

【练习题】25.抽象类、继承、接口综合设计一个系统 xxx纯净水生产线目前流程是从某个地方把水取出来然后经过缓冲过滤加热和放糖的步骤 abstract 水{ public void 水(); } interface 过滤{} interface 缓冲{} interface 加热{} interface 放糖{} class 纯净水1 extends 水 imps 过滤,缓冲{} class 纯净水2 extends 水 imps 缓冲{} class 纯净水2 extends 水 imps 过滤{} 。。。。

（重复上题的方法）

【练习题】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对象,并测试这些对象的方法

abstract class Role1
{
    protected String name;
    protected int age;
    protected String sex;
    public abstract void play();
    public Role1(){}
    public Role1(String s,int i,String s1)
    {
    this.name=s;
    this.age=i;
    this.sex=s1;
    }
    public static void main(String[] dsa)
    {
    Employee e=new Employee();
    e.id=1201012204;
    e.salary=15000;
    e.name="you xiao";
    e.age=20;
    e.sex="Man";
    e.play();
    e.sing();
    Manager m=new Manager();
    System.out.println(e.id);
    System.out.println(e.salary);
    System.out.println(e.name);
    System.out.println(e.age);
    System.out.println(e.sex);
    System.out.println(m.vehicle);
    }
}
class Employee extends Role1
{
    protected int id;
    protected int salary;
    public Employee(){}
    public Employee(String s,int i,String s1,int id,int salary)
    {
    super(s,i,s1);
    this.id=id;
    this.salary=salary;
    }
    public void play()
    {
    System.out.println("i can paly");
    }
    public final void sing()
    {
    System.out.println("i can sing");
    }
}
class Manager extends Employee
{
    protected final String vehicle="Lamborghini";
}

【练习题】27.综合题题目品尝饮料时间 2006-06-18 一、语言和环境 1. 实现语言 Java

环境要求 JDK1.4或以上版本及其联机帮助文档
二、要求 1、使用命令行参数饮料类型输出该饮料类型的味道如当命令行参数为1时结果见图1 2、如果没有该种饮料结果见如图2
三、推荐实现步骤
1、建立一个Java抽象类Drink 应当 a、声明一个抽象方法taste() 该方法负责输出饮料的味道 b、声明int型常量来代表不同的饮料类型咖啡、啤酒、牛奶如 c、声明静态工厂方法getDrink(int drinkType) 根据传入的参数创建不同的饮料对象并返回该对象建议使用switch语句。该方法要求声明DrinkNotFoundException 当没有相对应的饮料类型时抛出该异常。
2、建立Drink的具体子类 a、分别建立Drink的子类 Coffee 代表咖啡 Beer 代表啤酒 Milk 代表牛奶 ; b、实现taste()方法要求在控制台打印各自的味道特征。
3、建立异常类DrinkNotFoundException a、继承Exception b、在Drink的方法getDrink(int drinkType)中声明引发DrinkNotFoundException异常当传入的参数没有相对应的饮料类型时抛出异常。 c、在使用getDrink方法的类中捕捉该异常。
4、建立Test测试类测试以上内容的正确性 a、编写main方法通过命令行传参的方式传入某种饮料的类型。 b、在main方法中调用Drink类的getDrink方法获得相应的饮料对象。注意捕获DrinkNotFoundException。 c、然后调用该饮料对象的taste()方法输出该饮料的味道。
5、编译程序并运行。
四、注意事项 1、仔细审题把题目要求理解准确 2、请注意多态性的运用 3、请注意代码的书写、命名符合规范应有适当的注释。图2

import java.util.*;
abstract class Drink
{
    public abstract void taste();
    protected int i1;
    protected int i2;
    protected int i3;
    public static void getDrink(int drinkType) throws DrinkNotFoundException
    {
        if (drinkType<1||drinkType>3)
    {
        throw new DrinkNotFoundException();
    }
        switch (drinkType)
    {
    case 1:
        System.out.println("咖啡");
        break;
    case 2:
    System.out.println("啤酒");
        break;
    case 3:
    System.out.println("牛奶");
        break;
    }
    }
}
class Coffee extends Drink
{
    public void taste()
    {
    System.out.println("我是咖啡，味道是苦的");
    }
}
class Beer extends Drink
{
    public void taste()
    {
    System.out.println("我是啤酒，味道是涩的");
    }
}
class Milk extends Drink
{
    public void taste()
    {
    System.out.println("我是牛奶，味道是甜的");
    }
}
public class Role1
{
    public static void main(String[] dsa) throws DrinkNotFoundException
    {
        Coffee c=new Coffee();
    c.taste();
    Beer b=new Beer();
    c.taste();
    Milk m=new Milk();
    m.taste();
    Scanner input=new Scanner(System.in);
    System.out.println("请输入一个饮料编号:");
    try
    {
        int i=input.nextInt();
    m.getDrink(i);
    }
    catch (Exception e)
    {
        throw new DrinkNotFoundException("你输入的编号所对应的饮料不存在");
    }
    }
}
class DrinkNotFoundException extends Exception
{
    public DrinkNotFoundException()
    {
    super();
    }
    public DrinkNotFoundException(String mrg)
    {
    super(mrg);
    }
}

作者：innerClass
链接：https://www.jianshu.com/p/886252693889
來源：简书
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

学习，永无止境！

查看全文

相关阅读:
关于int8_t,uint8_t.....等数据类型的理解
 导出函数__declspec(dllexport)
c++中的namespace
GitHub C 和 C++ 开源库的清单（含示例代码）
进制之间的转换一
 为 JSON 字符串创建对象
 HTML5 简单Demo1
主要浏览器的调试工具
 fiddler2抓包工具使用图文教程
 JAVA将秒的总和转换成时分秒的格式

原文地址：https://www.cnblogs.com/litinghappy/p/9018400.html