java门基础学习(五)

文章目录

（一）、继承
(二）方法重写
（三）、导包
（四）、final修饰符
（五）、static修饰符
（六）、多态

（一）、继承

继承:代码的复用性 和维护性何时使用继承呢?is a(什么是什么的一种)多个类(子类)之中,有相同的属性和方法(特征),把多个类中相同的特征提取到一个新的类(父类)之中,并让子类和父类产生联系
格式:public class 子类 extends 父类{}
特点:子类可以有父类的内容,子类可以有自己独有的内容继承中变量的访问特点:1.先在子类局部查找2.找不到,去子类成员范围查找3.再找不到,去父类成员范围查找4.都找不到报错(不考虑父类还有父类)
super:表示当前类父类的对象 用法与this类似继承中构造的访问特点:1.子类构造中默认第一句都是父类的无参构造,所以无参构造无论是否使用都进行书写2.因为子类会继承父类中的数据，可能还会使用父类中的数据，所以子类初始化之前，一定先初始化父类3.子类构造中默认第一句都是super();4.如果父类中没有无参构造如何解决4.1:使用super调用父类的有参构造4.2:把父类构造加上
继承中方法的访问特点:1.先再子类中查找2.找不到,再去父类中查找3.都找不到报错(不考虑父类还有父类)

(二）方法重写

方法重写:父类中同一个方法,在子类中有不同的实现特点:1.继承中2.子类和父类有相同的方法声明(方法定义)3.子类中的方法重写不能比父类方法访问修饰符权限低重载:同一个类中  方法名相同 参数列表不同 和返回值无关
重写: 继承中     方法名相同 参数列表相同 返回值相同注意:1.只能单继承,不能多继承2.支持多层继承3.私有化成员不能被继承4.继承中构造方法不能被继承,只能被调用(在子类构造方法)

（三）、导包

在包下创建一个java源文件时,文件第一句就是package 包名(多级包名以.作为分隔)导包:使用不同包下的类时,需要给上当前这个要使用类的路劲(包名+类名,多级包使用.分割)导包的格式:import 包名+类名;例如:import java.util.Scanner;注意:导包的两种方法1.导入一个包下的某一个类格式:import 包名+类名;2.导入一个包下所有的类格式:import 包名.*;

修饰符  同一个类中   同包  不同类，不同包 子类   不同包非子类public        √           √          √            √protected  √           √          √default     √           √private        √

（四）、final修饰符

final(最终的):可以修饰变量,方法,类
修饰变量:变量必须初始化(初始化和变量定义一起使用),不能再次修改
修饰方法:不能被重写
修饰类:不能被继承
修饰引用数据类型:地址值不能被更改,地址值标识空间中内容可以发生修改
使用格式:放在public之后,或者数据类型之前
例如:1.public final intage=30;2.public fianl void test(){}3.public final class Student{}4.final ArrayList<String> list= new ArrayList<String>();

（五）、static修饰符

static:表示静态,static修饰的会随着类加载而加载
修饰变量,修饰方法
修饰变量:可以被多个对象共享
修饰方法:只能使用static所修饰的成员注意:1.静态成员方法只能访问static修饰成员变量和成员方法，因为static修饰的成员是在类加载时加载2.static所修饰的可以通过类名.的方法时去调用static修饰的成员随着类加载而加载
非static修饰的成员随着对象的创建而加载


public class Static {static int age=10;//定义一个静态成员变量，也叫类成员String name="zs";//定义一个非静态成员变量static{System.out.println("这是static修饰的代码块1");}public Static(){System.out.println("这是无参构造");}static{System.out.println("这是static修饰的代码块2");}public static void show1(){System.out.println(age);
//         System.out.println(name);报错，静态方法只能调用静态成员变量}public  void show2(){System.out.println(age);System.out.println(name);}
}class TestStatic{public static void main(String[] args) {//加载类时，static修饰的变量方法，代码块也随着加载，从上到下顺序加载System.out.println(Static.age);//类名调用类成员，类成员随着类的加载而加载
//        System.out.println(Static.name);不能加载非静态成员Static.show1();//类方法和类成员同样，静态可以类名调用，非静态不行Static s=new Static();//加载完成类后，创建一个类的实例对象，//使用对象调用变量System.out.println(s.name);System.out.println(s.age);//使用对象调用方法s.show1();s.show2();}
}

（六）、多态

多态:一个类在不同的时候,有不同的形态
实现多态的前提1.继承2.重写3.父类的引用指向子类的对象  instanceof 关键字
多态的好处和弊端:好处:提高了程序的扩展性弊端:不能使用子类独有的功能
类型转换:向上转型：父类 父类名=new 子类();例如:Animal animal=new Cat();向下转型:子类 子类名=(子类)父类对象;例如:Cat cat=(Cat)animal;向上转型适用于,使用子类中的重写的方法向下转型适用于,使用子类中的独有的方法
判断父类的引用指向哪一个子类:只有两个结果 true或false使用instanceof:格式:对象 instanceof 类或接口;例如:animal instanceof Dog

继承作业

一、选择题

1.   以下关于继承条件下构造方法执行过程的代码的执行结果是（  A）。（选择一项）
class Person {
public Person() {System.out.println("execute Person()");
}
}
class Student extends Person {  public Student() {      System.out.println("execute Student() ");
}
}
class PostGraduate extends Student {
public PostGraduate() { System.out.println("execute PostGraduate()");
}
}
public class TestInherit {
public static void main(String[] args) {new PostGraduate();
}
}A. execute Person()execute Student() execute PostGraduate()
B.  execute PostGraduate()
C.  execute PostGraduate()execute Student() execute Person()
D.  没有结果输出2.    以下关于this和super关键字的说法错误的是（ DB ）。（选择二项）A. this关键字指向当前对象自身，super关键字指向当前对象的直接父类
B.  在main方法中(不)可以存在this或super关键字，但不能同时存在。
C.  this和super关键字都可以访问成员属性，成员方法和构造方法
D.  在一个类的构造方法中可以同时使用this和super来调用其他构造方法3.   给出下面的代码段，在代码说明//assignment x=a,y=b处写入如下（  D ）个代码是正确的。（选择一项）
public class Base {
int w, x, y, z;
public Base(int a, int b) {x = a;y = b;
}
public Base(int a, int b, int c, int d) {// assignment x=a,y=bw = d;z = c;
}
}A  Base(a,b);
B.  x=a,y=b;
C.  this(a),this(b);
D.  this(a,b)4. 以下Java程序编译运行后的输出结果是（  A ）。（选择一项）
class HelloA {
public HelloA( ) {System.out.println("HelloA");
}
{   System.out.println("I'm A class");
}
static {System.out.println("static A");
}
}
public class HelloB extends HelloA {
public HelloB( ) {System.out.println("HelloB");
}
{   System.out.println("I'm B class");
}
static {System.out.println("static B");
}
public static void main(String[] args) {new HelloB( );
}
}A  static Astatic BI'm A classHelloAI'm B classHelloB
C.  static AI'm A classHelloAstatic BI'm B classHelloB
B.  static Astatic BI'm A classI'm B classHelloAHelloB
D   static Astatic BHelloAHelloB I'm A classI'm B class5. 下列选项中关于Java中super关键字的说法正确的是（  AD  ）。（选择二项）A super关键字是在子类对象内部指代其父类对象的引用
B.  super关键字不仅可以指代子类的直接父类，还可以指代父类的父类
C.  子类通过super关键字只能调用父类的方法，而不能调用父类的属性
D.  子类通过super关键字可以调用父类的构造方法

二、判断题

1.如果定义一个类时没有使用extends，则它的父类是java.lang.Object。（  T  ）2.对子类实例化对象需要调用超类的构造函数进行初始化工作，完成对子类中的超类（父类）实例变量的初始化，则子类可以继承超类的构造函数。（   X）
注：可以调用但不是继承3.在Java中任何一个子类的构造方法都必须调用其父类的构造方法（包括隐式调用），并且调用父类的构造方法的语   句必须是子类构造方法的第一条语句。（X  ）4.Java中的类不允许多重继承，一个类只能有有一个直接父类。（T）5.Object类有一个public方法是toString( )，一个对象通过调用该方法可以获得该对象的字符串表示。（  T  ）6.父类Person中定义了一个private void show()的方法，那么子类要重写这个方法时，方法的访问修饰符可以是默认的，protected或public。（ T  ）7.运算符“==”用于比较引用时，如果两个引用指向内存同一个对象，则返回true。（  X  ）

三、简答题
1.方法重载和方法重写（覆盖）的区别。

A、首先是含义不同1）方法重载是在同一个类中，声明多个同名方法，通过参数列表来区分不同的方法，与参数列表的数量、类型和顺     序有关，与修饰符和返回值类型以及抛出异常类型无关2）方法重写的前提是发生在具有继承关系的两个类之间，方法重写有以下规则：a.参数列表必须保持一致b.返回值类型必须保持一致c.方法名必须保持一致d.重写方法的访问权限范围必须大于等于父类方法e.重写方法的抛出异常类型范围不能大于父类方法
B、方法的重载和重写的作用不同重载：在一个类中为一种行为提供多种实现方式并提高可读性重写：父类方法无法满足子类的要求，子类通过方法重写满足需求实例：重载：构造方法的重载、println()方法重载重写：Object类的toString()、equals()、hashCode()等都可以被子类重写

2.继承条件下子类构造方法的执行过程

情况1：如果子类的构造方法中没有通过super显式调用父类的有参构造方法，也没有通过this显式调用自身的其他构   造方法，则系统会默认先调用父类的无参构造方法。在这种情况下，写不写“super();”语句，效果是一样的。
情况2：如果子类的构造方法中通过super显式调用父类的有参构造方法，那将执行父类相应构造方法，而不执行父类无参构造方法。
情况3：如果子类的构造方法中通过this显式调用自身的其他构造方法，在相应构造方法中应用以上两条规则。

3.super关键字的作用和使用

java中的super关键字是一个引用变量，用于引用父类对象。关键字“super”以继承的概念出现在类中。主要用于以下   情况：
1.使用super与变量:super.变量
2.使用super方法：super.方法（）
3.使用超级构造函数:super（参数1，参数2）；super（）；

4.==和equals()的联系和区别

四、编码题

1.编写应用程序，创建类的对象，分别设置圆的半径、圆柱体的高，计算并分别显示圆半径、圆面积、圆周长，圆柱体的体积。（7分）
提示:（1）编写一个圆类Circle，该类拥有：1)一个成员变量，radius（私有，浮点型）;//存放圆的半径；2)两个构造方法Circle（）              //将半径设为0Circle（double  r ）    //创建Circle对象时将半径初始化为r3)三个成员方法double getArea（）      //获取圆的面积double getPerimeter（）  //获取圆的周长void show（）           //将圆的关径、周长、面积输出到屏幕（2） 编写一个圆柱体类Cylinder，它继承于上面的Circle类。还拥有：1)一个成员变量，double hight  （私有，浮点型）;  //圆柱体的高；2)构造方法//创建Cylinder对象时将半径初始化为r,高度初始化为hCylinder（double r,double h）     3)成员方法double getVolume（）            //获取圆柱体的体积void showVolume（）             //将圆柱体的体积输出到屏幕**

public class Cylinder extends Circle {private double hight;/** 构造时设置圆的高，并调用父类的构造设置半径 */public Cylinder(double r,double h){super(r);this.hight = h;}/** 获得体积 */public double getVolume(){double area = super.getArea();return area * hight;}/**打印半径，周长，面积，体积*/public void showVolume(){super.show();System.out.println("圆的体积是："+this.getVolume());}
}
public class Test {public static void main(String[] args) {Cylinder c = new Cylinder(10,10);c.showVolume();}
}

2.请使用面向对象的思想，设计自定义类，描述出租车和家用轿车的信息。

设定
1)出租车类:属性包括：车型，车牌，所属出租公司；方法包括：启动，停止
2)家用轿车类：属性包括：车型，车牌，车主姓名；方法包括：启动，停止要求1)分析出租车和家用轿车的公共成员，提取出父类—汽车类2)利用继承机制，实现出租车类和家用轿车类3)编写测试类，分别测试汽车类，出租车类和家用轿车类对象的相关方法4)定义名为car的包存放汽车类，出租车类，家用轿车类和测试类
运行效果

public class Car {private String type;private String carNo;public String getType() {return type;}public void setType(String type) {this.type = type;}public String getCarNo() {return carNo;}public void setCarNo(String carNo) {this.carNo = carNo;}public void start(){System.out.println("我是车，我启动");}public void stop() {System.out.println("我是车，我停止");}
}public class FamilyCar extends Car {private String owner;public FamilyCar(String owner) {this.owner = owner;}
public void start() {System.out.println("我是"+owner+"，我的汽车我做主");}public void stop() {System.out.println("目的地到了，我们去玩吧");}
}public class TaxiCar extends Car {private String company;public TaxiCar(String company) {this.company = company;}public void start() {System.out.println("乘客您好\n我是"+this.company+
"的，我的车牌号是"+this.getCarNo()+"，你要去那里？");}public void stop() {System.out.println("目的地已经到了，请您下车付款，欢迎再次乘坐");}
}public class Test {public static void main(String[] args) {Car c = new Car();c.start();c.stop();System.out.println("===========================");FamilyCar fc = new FamilyCar("武大郞");fc.start();fc.stop();System.out.println("============================");TaxiCar tc = new TaxiCar("景顺出租公司");tc.setCarNo("京B123");tc.start();tc.stop();}
}

3.某公司要开发新游戏，请用面向对象的思想，设计游戏中的蛇怪和蜈蚣精

设定
1)蛇怪类:属性包括：怪物名字，生命值，攻击力方法包括：攻击，移动（曲线移动），补血（当生命值<10时，可以补加20生命值）
2)蜈蚣精类：属性包括：怪物名字，生命值，攻击力方法包括：攻击，移动（飞行移动）要求1)分析蛇怪和蜈蚣精的公共成员，提取出父类—怪物类2)利用继承机制，实现蛇怪类和蜈蚣精类3)攻击方法，描述攻击状态。内容包括怪物名字，生命值，攻击力4)编写测试类，分别测试蛇怪和蜈蚣精的对象及相关方法5)定义名为mon的包存怪物类，蛇怪类，蜈蚣精类和测试类
运行效果

//妖怪类
public class Monster {private String name;//怪物名private int hp;//血量private int aggressivity;//攻击力public String getName() {return name;}public void setName(String name) {this.name = name;}public int getHp() {return hp;}public void setHp(int hp) {this.hp = hp;}public int getAggressivity() {return aggressivity;}public void setAggressivity(int aggressivity) {this.aggressivity = aggressivity;}/** 攻击 */public void attack() {System.out.println("怪物"+this.getName()+"展开攻击");System.out.println("当前生命值："+this.getHp());System.out.println("攻击力是："+this.getAggressivity());}/** 移动 */public void move() {}
}/** 怪蛇类 */
public class Snake extends Monster {/** 加血 */public void addHp(){this.setHp(this.getHp()+20);System.out.println("实施大蛇补血术......，当前的生命值是"+this.getHp());}/** 重写父类的移动方法*/public void move() {System.out.println("我是蛇，我走S线路");}
}/** 蜈蚣类 */
public class Centipede extends Monster {/** 重写父类的移动方法*/public void move() {System.out.println("我是蜈蚣精，我御风飞行");}
}public class Test {public static void main(String[] args) {Snake sn = new Snake();//生产一个蛇精sn.setName("怪蛇甲");sn.setHp(5);sn.setAggressivity(20);sn.attack();//调用攻击方法if(sn.getHp()<10){//当生命少于10时，加20血sn.addHp();}sn.move();//蛇移动System.out.println("======================");Centipede ct = new Centipede();//new一个蜈蚣ct.setName("蜈蚣精乙");ct.setHp(60);ct.setAggressivity(15);ct.attack();//蜈蚣攻击ct.move();}
}

4.请用面向对象的思想，设计自定义类描述演员和运动员的信息

设定
1)演员类:属性包括：姓名，年龄，性别，毕业院校，代表作方法包括：自我介绍
2)运动员类：属性包括：姓名，年龄，性别，运动项目，历史最好成绩方法包括：自我介始
要求3)分析演员和运动员的公共成员，提取出父类—人类4)利用继承机制，实现演员类和运动员类5)编写测试类，分别测试人类，演员类和运动员类对象及相关方法6)定义名为act的包存人类，演员类，运动员类和测试类
运行效果

public class Person {//姓名，年龄，性别String name;int age;String sex;public Person(){}public Person(String name, int age, String sex) {this.name = name;this.age = age;this.sex = sex;}//介绍public void introduction(){System.out.println("大家好，我是一个老百姓");}
}public class Sportsman extends Person{//运动员类private String item;private String bestResult;public Sportsman(){}public Sportsman(String name,int age,String sex,String item,String best) {super(name,age,sex);this.item = item;this.bestResult = best;}public void introduction() {System.out.println("大家好，我是"+this.name);System.out.println("今年"+this.age);System.out.println("我擅长的项目是："+this.item);System.out.println("历史最好成绩是："+this.bestResult);}
}public class Performer extends Person {//演员类private String school;//学校private String production;//作品public Performer(){}public Performer(String name,int age,String sex,String school,String pro) {super(name,age,sex);this.school = school;this.production = pro;}public void introduction() {System.out.println("大家好，我是"+this.name);System.out.println("今年"+this.age);System.out.println("我毕业于："+this.school);System.out.println("代表作有："+this.production);}
}public class Test {public static void main(String[] args) {Person p = new Person();p.introduction();System.out.println("==============");Sportsman sm = new Sportsman("刘小翔",23,"男",
"200米短跑","22秒30");sm.introduction();System.out.println("==============");Performer pf = new Performer("章依",27,"女","北京电影学院",
"《寄往天国的家书》");pf.introduction();}
}

多态作业

一、选择题

1.   关于Java中的多态，以下说法不正确的为（ B   ）。（选择一项）A  多态不仅可以减少代码量，还可以提高代码的可扩展性和可维护性
B.  把子类转换为父类，称为向下转型，自动进行类型转换
C.  多态是指同一个实现接口，使用不同的实例而执行不同的操作
D.  继承是多态的基础，没有继承就没有多态2. 编译运行如下Java代码，输出结果是（  D ）。（选择一项）
class Base {
public void method(){System.out.print ("Base method");
}
}
class Child extends Base{
public void methodB(){System.out.print ("Child methodB");
}
}
class Sample {
public static void main(String[] args) {Base base= new Child();base.methodB();
}
}A  Base method
B.  Child methodB
C.  Base methodChild methodB
D.  编译错误3.  在Java中，关于引用数据类型的类型转换说法正确的是（   AB  ）。（选择二项）A  引用数据类型的类型转换有向上转型和向下转型
B.  向下转型，必须转换成其真实子类型，而不能随意转换
C.  向下转型是自动进行的，也称隐式转换
D.  向上转型可以使用instanceof操作符来判断转型的合法性4.    给定如下Java程序，Test类中的四个输出语句输出结果依次是（  C ）。（选择一项）
class Person {
String name="person";
public void shout(){System.out.println(name);
}
}
class Student extends Person{
String name="student";
String school="school";
}
public class Test {
public static void main(String[ ] args) {Person p=new Student();System.out.println(p instanceof Student);System.out.println(p instanceof Person);System.out.println(p instanceof Object);System.out.println(p instanceof System);
}
}A  true,false,true,false
B.  false,true,false,false
C.  true,true,true,编译错误
D.  编译错误

二、判断题

1.将子类对象赋给父类引用变量，称为向下转型，将无法访问子类特有的方法。( X  )2.继承是多态的基础，没有继承就没有多态。( T  )

三、简答题

1.多态的含义和作用

含义：在面向对象语言中，接口的多种不同的实现方式即为多态，一个类在不同的时候有不同的形态
多态的作用：
1. 应用程序不必为每一个派生类编写功能调用，只需要对抽象基类进行处理即可。大大提高程序的可复用性。//继承
2. 派生类的功能可以被基类的方法或引用变量所调用，这叫向后兼容，可以提高可扩充性和可维护性。 //多态的真正作用，以前需要用switch实现

2.向上转型和向下转型

1.向上转型1）.好处：隐藏了子类型，提高了代码的扩展性。2）.坏处：只能使用父类的功能，不能使用子类特有功能，功能被限定。3）.使用场景：不需要面对子类型，通过提高扩展性，或者使用父类的功能即可完成操作，就是使用向上转型。
2.向下转型1）.好处:可以使用子类型的特有功能2）.坏处:面对具体的子类型，向下转型具有风险。即容易发生ClassCastException，只要转换类型和对象不匹配就会发生。解决方法：使用关键字instanceof。

四、编码题

1.编写程序实现比萨制作。需求说明编写程序，接收用户输入的信息，选择需要制作的比萨。可供选择的比萨有：培根比萨和海鲜比萨。

实现思路及关键代码1)分析培根比萨和海鲜比萨2)定义比萨类3)属性：名称、价格、大小4)方法：展示5)定义培根比萨和海鲜比萨继承自比萨类6)定义比萨工厂类，根据输入信息产生具体的比萨对象
程序运行结果如图所示

/*** 定义抽象类
*/
public abstract class Pizza {private String name;private int price;private int size;public Pizza() {super();}public Pizza(String name, int price, int size) {super();this.name = name;this.price = price;this.size = size;}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getPrice() {return price;}public void setPrice(int price) {this.price = price;}public int getSize() {return size;}public void setSize(int size) {this.size = size;}public abstract void  show();}
/*** 培根比萨
*/
public class BaconPizza extends Pizza{private int gram;//克数     public BaconPizza() {super();}public BaconPizza(String name, int price, int size, int gram) {super(name, price, size);this.gram = gram;}public int getGram() {return gram;}public void setGram(int gram) {this.gram = gram;}public void show() {System.out.println("名称："+super.getName());System.out.println("价格："+super.getPrice()+"元");System.out.println("大小："+super.getSize()+"寸");System.out.println("培根克数："+this.gram);       }
}
/*** 海鲜比萨
*/
public class SeaFoodPizza extends Pizza{private String mixture;//配料 public SeaFoodPizza() {super();}public SeaFoodPizza(String name, int price, int size, String mixture) {super(name, price, size);this.mixture = mixture;}public String getMixture() {return mixture;}public void setMixture(String mixture) {this.mixture = mixture;}@Overridepublic void show() {        System.out.println("名称："+super.getName());System.out.println("价格："+super.getPrice()+"元");System.out.println("大小："+super.getSize()+"寸");System.out.println("配料："+this.mixture);    }
}
/*** 比萨制作
*/
public class PizzaFactory {public static Pizza makePizza(){System.out.println("请选择想要制作的比萨(1.培根比萨 2.海鲜比萨)：");Scanner scanner = new Scanner(System.in);int i = scanner.nextInt();Pizza pizza = null;      if(i==1){//制作培根比萨System.out.println("请输入培根克数：");int gram = scanner.nextInt();           System.out.println("请输比萨大小：");int size =  scanner.nextInt();          System.out.println("请输入比萨价格：");int price =  scanner.nextInt();                    pizza = new BaconPizza("培根比萨", price, size, gram);           }else if(i==2){//制作海鲜比萨System.out.println("请输入配料信息：");String mixture  =  scanner.next();System.out.println("请输比萨大小：");int size =  scanner.nextInt();System.out.println("请输入比萨价格：");int price =  scanner.nextInt();pizza = new SeaFoodPizza("海鲜比萨", price, size, mixture);}return pizza;} public static void main(String[] args) {Pizza p = makePizza();pshow();}
}

2.编写程序实现软料购买：编写程序，接收用户输入的信息，选择购买的饮料。

可供选择的饮料有：咖啡、矿泉水和可乐。其中，购买咖啡时可以选择：加糖、加奶还是什么都不加。购买可乐时可 以选择：买可口可乐还是百事可乐。
程序运行效果如图所示。

package drink;public class Water extends Drink {@Overridepublic void show() {System.out.println("名称"+getName());System.out.println("容量"+getCapacity());}
}package drink;public class Test {public static void main(String[] args) {Store s=new Store();s.showdrink();}}package drink;import java.util.Scanner;public class Store {private Drink drink;public Drink getDrink() {return drink;}public void setDrink(Drink drink) {this.drink = drink;}public void showdrink(){System.out.println("请选择饮料（1.咖啡 2.矿泉水 3.可乐）");Scanner scanner=new Scanner(System.in);int i=scanner.nextInt();switch (i){case 1:drink=new Coffee();this.setDrink(drink);System.out.println("请输入购买容量");int capacity=scanner.nextInt();System.out.println("请问是否要配料（1.加糖 2.加奶 3.什么都不加");int j=scanner.nextInt();switch (j){case 1:((Coffee)drink).setMixture("加糖");break;case 2:((Coffee)drink).setMixture("加奶");break;case 3:((Coffee)drink).setMixture("什么都不加");break;}drink.setName("咖啡");drink.setCapacity(capacity);break;case 2:drink=new Water();this.setDrink(drink);System.out.println("请输入购买容量");int capacity2=scanner.nextInt();drink.setName("矿泉水");drink.setCapacity(capacity2);break;case 3:drink=new Cola();drink.setName("可乐");System.out.println("请输入购买容量");int capacity3=scanner.nextInt();drink.setCapacity(capacity3);System.out.println("请选择类型1.可口可乐 2.百事可乐");int k=scanner.nextInt();switch(k){case 1:((Cola)drink).setType("可口可乐");break;case 2:((Cola)drink).setType("百事可乐");break;}}drink.show();}
}package drink;public class Drink {private String name;private int capacity;public int getCapacity() {return capacity;}public void setCapacity(int capacity) {this.capacity = capacity;}public String getName() {return name;}public void setName(String name) {this.name = name;}public void show(){System.out.println("显示饮料信息");}}package drink;public class Cola extends Drink {private String type;public String getType() {return type;}public void setType(String type) {this.type = type;}@Overridepublic void show() {System.out.println("名称"+getName());System.out.println("类型"+getType());System.out.println("容量"+getCapacity());}
}package drink;public class Coffee extends Drink {private String mixture;public String getMixture() {return mixture;}public void setMixture(String mixture) {this.mixture = mixture;}@Overridepublic void show() {System.out.println("名称："+getName());System.out.println("添加配料:"+getMixture());System.out.println("容量"+getCapacity());}
}

java入门基础学习（一）
java入门基础学习（二）
java入门基础学习（三）
java入门基础学习（四）
java入门基础学习（五）
java入门基础学习（六）
java入门基础学习（七）
java入门基础学习（八）
java入门基础学习（九）
java入门基础学习（十）
java进阶之常见对象（一）
java进阶之常见对象（二）
java进阶之冒泡排序
java进阶之选择排序
java进阶之面向对象（封装）
java进阶之面向对象（代码块、继承）
java进阶之面向对象（多态、抽象、接口）
java进阶之匿名内部类、访问修饰符、包