java门基础学习(五)

（一）、继承

继承:代码的复用性 和维护性

何时使用继承呢?
	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=b
	w = 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 A
	static B
	I'm A class
	HelloA
	I'm B class
	HelloB	
C.	static A
	I'm A class
	HelloA
	static B
	I'm B class
	HelloB
B.	static A
	static B
	I'm A class
	I'm B class
	HelloA
	HelloB	
D	static A
	static B
	HelloA
	HelloB 
	I'm A class
	I'm B class

5.	下列选项中关于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（）              //将半径设为0
					Circle（double  r ）    //创建Circle对象时将半径初始化为r
			3)三个成员方法
					double getArea（）      //获取圆的面积
					double getPerimeter（）  //获取圆的周长
					void show（）           //将圆的关径、周长、面积输出到屏幕
	（2） 编写一个圆柱体类Cylinder，它继承于上面的Circle类。还拥有：
			1)一个成员变量，double hight  （私有，浮点型）;  //圆柱体的高；
			2)构造方法
				//创建Cylinder对象时将半径初始化为r,高度初始化为h
					Cylinder（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 method
	Child 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;
	}
	@Override
	public 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 {
    
    
    @Override
    public 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;
    }

    @Override
    public 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;
    }

    @Override
    public 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进阶之匿名内部类、访问修饰符、包