Java大报告

一、 Java概述

Java的特点有简单性、面向对象、分布式、健壮性、安全性、体系结构中立、可移植性、解释型、高性能、多线程、动态性。其中最重要的特点就是面向对象、可移植性和多线程。

面向对象：面向对象的程序是由对象组成的，每个对象包含对用户公开的特定功能部分和隐藏的实现部分。程序中的很多对象来自标准库，还有一些是自定义的。每个对象都保存着描述当前特征的信息。这就是对象的状态。对象的状态可能会随着时间而发生改变，但这种改变不会是自发的。对象状态的改变必须通过调用方法实现。

可移植性：除了与用户界面有关的部分外，所有其他Java库都能很好地支持平台独立性。可以非常方便地将自己写的代码转移到其他的操作平台中。可以处理文件、正则表达式、XML、日期和时间、数据库、网络连接、线程等，而不用操心底层操作系统。不仅程序是可移植的，Java API往往也比原生API质量更高。

多线程：在Java中支持一个程序多个线程同时进行工作，程序的执行顺序是并发的。

二、 对象与类

2.1 类

类是构造对象的模板或蓝图。在标准的Java库提供了几千个类，可以用于用户界面设计、日期、日历和网络程序设计。尽管如此，还是需要在Java程序中创建一些自己的类，以便描述应用程序所对应的问题域中的对象。

封装是与对象有关的一个重要概念。从形式上看，封装不够是将数据和行为组合在一个包中，并对对象的使用者隐藏了数据的实现方式。对象中的数据称为实例域，操纵数据的过程称为方法。对于每个特定的类实例都有一组特定的实例域值。这些值的集合就是这个对象的当前状态。无论何时只要向对象发送一个消息，它的状态就有可能发送改变。实现封装的关键在于绝对不能让类中的方法直接地访问其他类的实例域。程序仅通过对象的方法与对象数据进行交互。

简单的实验代码见附录1.1

实验分析：如图2.1所示，建立了一个简单的类Main类，我建立了几个属性，分别是姓名，年龄，性别。然后构建一个方法进行实例化，但是在使用的时候，必须创建一个对象才行，包里面的东西只是属性，而创建一个对象就是为了使用包里面的属性，这个就是Java使用的最大的一个特点。我创建了一个per对象，通过调用包，输出了对象相应的属性。

实验结果：

图2.1

2.2 对象

Java是一个面向对象的语言，这是我刚学Java的时候听到的最多的一句话。对于初学者的我而言，确实很难理解这句话真正代表什么。首先理解对象的三个主要特征：

l 对象的行为：可以对对象施加哪些操作，或可以对对象施加哪些方法？

l 对象的状态：当施加哪些方法时，对象如何响应？

l 对象的标识：如何辨识具有相同行为与状态的不同对象？

通过这三个特征，我们可以发现的是，对于同一个类的所有对象实例，由于支持相同的行为而具有家族式的相似性。对象的行为是用可调用的方法定义的。对象的状态改变，必须调用方法实现。但是，必须要清楚地是对象的状态并不能完全描述一个对象。每一个对象都有唯一的身份。在这里也可以理解成在创建对象的时候，分配的地址是唯一的。

简单实验代码见附录1.2

实验结果如图2.2所示

实验分析：我们可以发现的是，对于对象而要，我们使用了两种方法来定义它的属性，这就是Java里面常用的无参构造和有参构造。什么是无参构造？顾名思义就是没有参数的构造方法。可能有人会疑惑，没有参数怎么可以构造对象的属性呢？当然可以，虽然方法里面没有参数，但是我们可以直接调用包里面已经定义好的属性，从而实现对于对象的定义。

那么相同的是什么是有参构造？对于有参构造而言，在调用方法时需要有参数才可以。有参构造理解简单点就是相当于把包里的属性在方法里里面调用了一遍，所以在使用的过程需要把参数输入进去。

图2.2

三、 继承与多态

3.1继承

定义：继承就是继承已经存在的类构造一个新类。而继承已存在的类就是复用这些类的方法和域。在此基础上，还可以添加一些新的方法和域，以满足新的需求。这是学习Java而言必须掌握的一门核心技术。

一般将类分为父类和子类，而子类用关键字extends继承父类。

继承的基本实现，实验代码见附录1.3

实验结果如图3.1：

图3.1

实验分析：由实验代码，可以发现的Student子类完全的Person父类的两个属性方法，并且在此基础上还扩充了一个学校的属性，在建立对象的时候，调用Student类时，可以使用他的全部的属性，就像结果图一样。

3.2覆写

3.2.1方法的覆写

当子类定义了和父类的方法名称、返回值类型、参数类型及个数完全相同的方法时，就成为方法的覆写。

被子类覆写的方法不能拥有比父类更严格的访问控制权限

private无法覆写

覆写的使用，见附录1.4

实验结果见图3.2.1：

图3.2.1

实验分析：由代码可以发现，在父类中定义的方法，被子类继承后进行了覆写，对象调用的时候，输出的是子类重新覆写的方法。

3.2.2属性的覆盖

如果子类定义了和父类完全相同的属性名称时，就称为属性的覆盖。

3.3 final关键字

在 java 中 final 称为终结器，在 java 里面可以使用 final 定义类、方法和属性。

在使用final定义的类不能再有子类。

使用final定义的方法不能被子类所覆盖。（public final void fun()）

3.4 多态性

方法的多态性

重载：同一个方法名称，根据不同的参数类型及个数可以完成不同的功能；

覆写：同一个方法，根据实例化的子类对象不同，所完成的功能也不同；

对象的多态性

向上转型：子类对象变为父类对象

向下转型：父类对象变为子类对象

作用

在实际开发中，对象向上转型的主要意义在于参数的统一，也是最为主要的用法，而对象的向下转型指的是调用子类的个性化操作方法。

首先对行为进行抽象，然后每种行为可以创建出具体的子类，而每个子类的具体操作都应该由行为类发出命令。

如果真的要使用类继承，那么就使用抽象类。

一个字类只能继承一个抽象类。

3.5接口

所谓的接口严格来讲就属于一个特殊的类，而且这个类里面只有抽象方法与全局常量。

使用规则：

l 接口必须要有子类，但是此时一个子类可以使用 implement 关键字实现多个接口，避免单继承局限。

l 接口的子类，必须要覆写接口中的全部抽象方法；

l 接口的对象可以利用子类对象的向上转型进行实例化操作

接口实例见附录1.5

实验结果如图3.5.1所示：

图3.5.1

实验分析：可以发现的是接口里面只有全局变量和抽象方法，子类在继承接口后，重新覆写了接口的方法。

如果一个子类既要继承抽象类又要实现接口，那么应该先继承后实现接口

一个抽象类可以继续一个抽象类或者实现若干个接口，但是反过来，一个接口不能继承抽象类。但是一个接口却可以使用extends关键字同时继承多个父接口。

在接口定义方法时，一定要写上public 。

3.5.2 接口的应用——工厂模式

在客户端操作上取消关键字new的使用，而使用Factory.getInstance（）方法根据指定子类的标记取得接口对象实例化对象。

代理设计模式（Proxy）

一个代理主题来操作真实主题，真实主题执行具体的业务操作，而代理主题负责其他相关的业务处理。

接口实例见附录1.6

实验结果如图3.5.2所示：

图3.5.2

案例分析：可以发现的是在Factory模式下，可以实习多个程序员一起工作的效果，比如将一个商店的水果每一种水果进行一个信息管理，这个时候就可以用到Factory模式，每个程序员写一种水果，最后在将他们进行统一。

3.6综合项目实战–百草园奶茶

项目介绍：在现在互联网时代，很多奶茶店里都会有一个下单的简单系统。本项目实现了用户的注册，登录，下单三大功能。在奶茶店里有产品珍珠奶茶、可乐、矿泉水，下面就详细的实现过程。

实验代码见附录2：

3.6.1实现父类Milktea 类

首先实现的是父类Milktea 类，将基本属性进行封装，将奶茶的名字、价格、类型进行封装。

详细代码见附录2.1

3.6.2实现子类Zhenzhunaicha类

子类Zhenzhunaicha类在继承父类的基础上，还添加了属性配料、温度、糖分三个属性。并且将他们进行封装打包。

详细代码见附录2.2

3.6.3实现子类Cola类

子类Cola类在继承父类的基础上，还添加了品牌属性。并且将他们进行封装打包。

详细代码见附录2.3

3.6.4实现子类Water类

子类Cola类在继承父类的基础。并且将他们进行封装打包。

详细代码见附录2.4

3.6.5实现工厂模式，定义MilkteaFactory类

在Factory模式下，可以实习多个程序员一起工作的效果。使用switch函数，可以完美的调用不用的三个子类。

详细代码见附录2.5

3.6.6实现用户界面，定义User类

在User类中定义了用户的基本属性，分别是用户名、密码、电话、邮箱。并且对这些属性进行封装。

详细代码见附录2.6

3.6.7实现用户主界面系统，定义Yonghuxitong类

在Yonghuxitong类中，调用了前面定义类的属性，并且在本类中使用了很多的方法，去完成这个界面。

实现代码见附录2.7

为了方便观察，在这里定义了四个用户，保存在了代码中，如图3.6.1所示

图3.6.1

定义主界面mainMenu()方法，使用switch（）方法，通过用户选择不同的选项，实现了不同的界面。使用的还是System方法进行输出。

实现效果如图3.6.2所示

图3.6.2

定义register（）方法，注册用户信息。在实现这个方法之前需要考虑的问题有以下几个方面：

l 如果用户名重复了，则再次输入用户名，直到不重复为止。

l 如果确认密码时，密码不一致则再次重新设置密码

l 如果验证码不一致，则重新发送验证码。

l 输入自己的手机号码

l 输入自己的邮箱

实现方法采用if和equals（）方法进行比较。

实现结果如图3.6.3所示—用户名重复

图3.6.3

图3.6.4所示—密码不一致重新输入

图3.6.4

图3.6.5所示—注册成功

图3.6.5

定义login()方法，设置用户登录方法。登录是需要输入用户名、密码加验证码，三个输错一个就不能成功登录。

实验结果如图3.6.6所示—登录失败展示

图3.6.6

如图3.6.7所示—登录成功

图3.6.7

定义drink()进行饮料下单，在下单之前必须要进行身份核实，这样才可以知道那个用户下的单，然后在进行选择想喝的饮料，对于饮料必须分类进行讨论，在实验的过程中使用的是switch（）方法进行分类讨论，然后在采用if else语句进行给相应的属性赋值。

如图3.6.7所示，就是珍珠奶茶关于配料的设计，同样的方法也设置其他的属性。

图3.6.7

最后在设置完成后就可以进行下单了，如图3.6.8所示对珍珠奶茶进行下单，首先选择珍珠奶茶，然后选择配料，再选择温度、再选择糖分、在选择类型，选择完后付钱就可以，最后用户就可以看到打印的订单。

图3.6.8

如图3.6.9所示对可乐进行下单。选择百事可乐，大杯。

图3.6.9

如图3.6.10所示对矿泉水进行下单.选择中杯(等于小瓶)矿泉水

图3.6.10

以上就是关于奶茶系统的全部介绍。

四、 实验总结

在本次实验中，完成了我对Java基础的一个小总结，也把自己学的这么多知识点相互结合在了一次。其实在学习的过程中，我发现了Java本身这门语言可以说是站在巨人的肩膀上完成的，借鉴了c语言借鉴了C++等等。我觉得学习Java最要弄清楚地就是什么是面向对象，其实现在我也不能完全的把它说清楚。但是学习了这么多的案例后，对于我的理解就是，面向对象就是Java的所有类所有方法都是为了对象而存在的。就比如我写的奶茶系统，我一开始定义了很多的类，但是这些类的真正作用还是为对象而服务，定义了对象里面的属性，从而使得对象里有了东西。这就是对于面向对象的理解。

我这次写的东西还是比较基础的，基本上没有用到很复杂的算法，用的最多的就是比较方法和输入输出流。相比较与Java的输入流，我其实更喜欢c语言的输入流，直接一个scaf函数就可以了，但是对于Java必须不同的类型对象要调用不同的输入流方法，还是没那么的方便地感觉。

也通过这次的报告，将我对于Java方面面向对象和继承两大方面做了一个比较好的总结。当然Java还有另一个优势就是多线程，这是一个并发结构的语言，可以同时运行好几个线程，关于这个我希望以后我能够更加深入的理解这个问题。

五、 附录1

1.1

package com.company;
public class Main {
String name;
int age;
String sex;
public void introduce()
{
System.out.println(“姓名：”+name+“\t年龄：”+age+“\t性别：”+sex);
}
public static void main(String[] args) {
Main per=new Main();
per.name=“朱小东”;
per.age=23;
per.sex=“男”;
per.introduce();
}
}

1.2

package com.company;
public class Main {
String name;
int age;
String sex;
public void introduce()
{
System.out.println(“姓名：”+name+“\t年龄：”+age+“\t性别：”+sex);
}
public Main(){}
public Main(String name,int age,String sex)
{
this.name=name;
this.age=age;
this.sex=sex;
}
public static void main(String[] args) {
Main per=new Main();
per.name=“朱小东”;
per.age=23;
per.sex=“男”;
Main per2=new Main(“刘大炮”,22,“男”);
per.introduce();
per2.introduce();
}
}

1.3

package com.company;

public class Person {

private String name;//姓名

private int age;//年龄

public void setName(String name){

​ this.name=name;

}

public void setAge(int age){

​ this.age=age;

}

public String getName(){

​ return this.name;

}

public int getAge() {

​ return this.age;

}

}

package com.company;

class Student extends Person{

//继承定义方法

//扩充方法

private String school;

public void setSchool(String school){

​ this.school=school;

}

public String getSchool(){

​ return this.school;

}

}

public class TestDemo{

public static void main(String args[]){

​ Student stu=new Student();

​ stu.setAge(20);

​ stu.setName(“朱小东”);

​ stu.setSchool(“清华大学”);

​ System.out.println(“姓名：”+stu.getName()+“,年龄：”+stu.getAge()+“,学校：”+stu.getSchool());

}

}

1.4

package com.company;

class A{

public void fun(){

​ this.print();

}

public void print(){

​ System.out.println(“人生无悔”);

}

}

class B extends A{

public void print(){

​ System.out.println(“疯子三旬”);

}

}

public class TestDemo {

public static void main(String args[]){

​ B b=new B();

​ b.fun();

}

}

1.5

package com.company;

interface A {

public static final String MAG=“YOOTK”;

public abstract void print();

}

interface B{

public abstract void get();

}

class X implements A,B{

public void print(){

​ System.out.println(“A接口的抽象方法！”);

}

public void get(){

​ System.out.println(“B接口的抽象方法！”);

}

}

public class TestDemo {

public static void main(String args[]){

​ X x=new X();

​ A a=x;

​ B b=x;

​ a.print();

​ b.get();

​ System.out.println(A.MAG);

}

}

1.6

package com.company;

interface Fruit{

public void eat();

}

class Apple implements Fruit{

public void eat(){

​ System.out.println(“**吃苹果”);

}

}

class Orange implements Fruit{

public void eat(){

​ System.out.println(“**吃橘子”);

}

}

class Factory{

public static Fruit getInstance(String className){

​ if (“apple”.equals(className)){

​ return new Apple();

​ }else if (“orange”.equals(className)){

​ return new Orange();

​ }else {

​ return null;

​ }

}

}

public class TestDemo {

public static void main(String[] args) {

​ // write your code here

​ Fruit f=Factory.getInstance(“orange”) ;

​ f.eat();

}

}

六、 附录2

2.1

package com.naicha;
public class Milktea {
private String name; //名字
private double price; //价钱
private String type; //大杯还是中杯
//对属性进行有参构造
public String getName(){
return name;
}
public void setName(String name){
this.name=name;
}
public double getPrice(){
return price;
}
public void setPrice(double price){
this.price=price;
}
public String getType(){
return type;
}
public void setType(String type){
this.type=type;
}
//构造方法
public Milktea(String name,double price,String type){
super();
this.name=name;
this.price=price;
this.type=type;
}
public Milktea(){
super();
}
public void orderInfo(){
System.out.println(“名称：”+this.name);
System.out.println(“价格：”+this.price+“元”);
System.out.println(“类型：”+this.type);
}
}

2.2

package com.naicha;
public class Zhenzhunaicha extends Milktea{
private String peiliao; //配料
private String wendu;//温度
private String tangfen;//糖分
public String getPeiliao(){
return peiliao;
}
public void setPeiliao(){
this.peiliao=peiliao;
}
public String getWendu(){
return wendu;
}
public void setWendu(){
this.wendu=wendu;
}
public String getTangfen(){
return tangfen;
}
public void setTangfen(){
this.tangfen=tangfen;
}
public Zhenzhunaicha(String name,double price,String type,String peiliao,String wendu,String tangfen){
super(name,price,type);
this.peiliao=peiliao;
this.wendu=wendu;
this.tangfen=tangfen;
}
public Zhenzhunaicha(){
super();
}
@Override
public void orderInfo(){
super.orderInfo();
System.out.println(“配料：”+this.peiliao);
System.out.println(“温度：”+this.wendu);
System.out.println(“糖分：”+this.tangfen);
}
}

2.3

package com.naicha;

public class Cola extends Milktea{
private String brand; //品牌
public String getBrand(){
return brand;
}
public void setBrand(String brand){
this.brand=brand;
}
public Cola(String name,double price,String type,String brand){
super(name,price,type);
this.brand=brand;
}
public Cola(){
super();
}
//重写父类的方法
@Override
public void orderInfo(){
super.orderInfo();
System.out.println(“品牌：”+this.brand);
}
}

2.4

package com.naicha;
public class Water extends Milktea{
public Water(){
super();
}
public Water(String name,double price,String type){
super(name,price,type);
}
}

2.5

package com.naicha;

public abstract class MilkteaFactory {
public static Milktea newInstance(int choice,String name,double price,String type,String peiliao
,String wendu,String tangfen,String brand){
Milktea d=null;
switch (choice){
case 1:
d=new Zhenzhunaicha(name,price,type,peiliao,tangfen,wendu);
break;
case 2:
d=new Cola(name,price,type,brand);
break;
default:
d=new Water(name,price,type);
break;
}
return d;
}
}

2.6

package com.naicha;
//建立用户类
public class User {
private String userName; //用户名
private String password; //密码
private String phone; //电话
private String email; //邮箱
public String getUserName(){
return userName;
}
public void setUserName(String userName){
this.userName=userName;
}
public String getPassword(){
return password;
}
public void setPassword(){
this.password=password;
}
public String getPhone(){
return phone;
}
public void setPhone(){
this.phone=phone;
}
public String getEmail(){
return email;
}
public void setEmail(){
this.email=email;
}
//构造方法
public User(){
super();
}
public User(String userName,String password,String phone,String email) {
super();
this.userName=userName;
this.password=password;
this.phone=phone;
this.email=email;
}
public User(String userName,String password){
super();
this.userName=userName;
this.password=password;
}
}

2.7

package com.naicha;
import java.util.Scanner;
import java.util.SplittableRandom;
public class Yonghuxitong {
private static User[] users=new User[100];
private Scanner input=new Scanner(System.in);
private boolean isLogin;
//建立用户信息
static {
users[0]=new User(“秋水”,“666666”,“18815538393”,“424232@qq.com”);
users[1]=new User(“川水”,“666666”,“15815538393”,“12345@qq.com”);
users[2]=new User(“陌上花开”,“666666”,“15825538393”,“33444232@qq.com”);
users[3]=new User(“菜花从中过”,“666666”,“18815526693”,“9274832@qq.com”);
}
public void mainMenu(){
while (true){
System.out.println(“---------你好!茶小度很高兴为您服务。----------------”);
System.out.println(“\t1.注册\t2.登录\t3.查看饮品\t0.退出”);
System.out.println(“-----------------------------------------------”);
int choice=input.nextInt();
switch (choice){
case 1:
register(); //注册
continue;
case 2:
login(); //登录
continue;
case 3:
drink(); //饮品资料
continue;
case 0:
System.out.println(“欢迎下次光临！！！”);
break;
default:
System.out.println(“您的选择有误，请重新选择！”);
continue;
}
break;
}
}
//检测用户名是否重复
private boolean checkName(String userName){
for (int i=0;i< users.length;i++){
if (users[i]!=null&&users[i].getUserName().equals(userName)){
return false;
}
}
return true;
}
//添加用户序号
private void addUser(User u){
for (int i=0;i< users.length;i++){
//判断是否为空
if (users[i]null){
users[i]=u;//将注册用户添加到数组中
break;
}
}
}
//注册
private void register(){
System.out.println(“---------你好!茶小度很高兴为您服务。----------------”);
System.out.println(“---->用户注册”);
System.out.println(“请输入用户名”);
String userName=input.next();
boolean isRegister=checkName(userName);
if (!isRegister){
System.out.println(“对不起，用户名不能重复！\n”);
return;
}
System.out.println(“请输入密码”);
String password=input.next();
System.out.println(“请确认密码”);
String comPwd=input.next();
while (!comPwd.equals(password)){
System.out.println(“两次密码不一致，请重新输入！\n”);
System.out.println(“请输入密码:”);
password=input.next();
System.out.println(“请确认密码:”);
comPwd=input.next();
}
int random=(int)(Math.random()*9000)+1000;
System.out.println(“验证码：”+random);
int checkCode=input.nextInt();
while (checkCode!=random){
System.out.println(“验证码错误，请重新输入”);
random=(int)(Math.random()*9000)+1000;
System.out.println(“验证码：”+random);
checkCode=input.nextInt();
}
System.out.println(“请输入手机号码：”);
String phone=input.next();
System.out.println(“请输入邮箱：”);
String email=input.next();
//封装用户对象
User u=new User(userName,password,phone,email);
addUser(u);
System.out.println(“恭喜”+userName+“注册成为奶茶的用户！”);
}
//确认登录是否正确
private User checkBynameAndPwd(User u){
for (int i=0;i<users.length;i++){
if (users[i]!=null&&users[i].getUserName().equals(u.getUserName())&&users[i].getPassword().equals(u.getPassword())){
return users[i];
}
}
return null;
}
//登录
private void login(){
System.out.println(“---------你好!茶小度很高兴为您服务。----------------”);
System.out.println(“—>用户登录”);
System.out.println(“用户名：” );
String uesrname=input.next();
System.out.println(“请输入你的密码：”);
String pwd=input.next();
int random=(int)(Math.random()*9000)+1000;
System.out.println(“验证码：”+random);
int checkCode=input.nextInt();
while (checkCode!=random){
System.out.println(“验证码错误，请重新输入”);
random=(int)(Math.random()*9000)+1000;
System.out.println(“验证码：”+random);
checkCode=input.nextInt();
}
//封装用户对象
User u=new User(uesrname,pwd);
User loginUser=checkBynameAndPwd(u);
if (loginUser!=null){
System.out.println(“登录成功！”);
isLogin=true;
}else {
System.out.println(“对不起，用户名或者密码不正确！！！”);
isLogin=false;
}
}
//饮品资料
private void drink(){
String peiliao=null; //配料
String wendu=null;//温度
String tangfen=null;//糖分
String brand=null; //品牌
String type=null; //类型
String name=null;
double price=0; //价格
System.out.println(“---------你好!茶小度很高兴为您服务。----------------”);
System.out.println(“—>饮品列表\n”);
System.out.println(“1.珍珠奶茶 2.可乐 3.矿泉水”);
//客户选择饮品
int choice=input.nextInt();
if (!isLogin){
System.out.println(“请先登录再下单！！！”);
return;
}
switch (choice){
case 1:
name=“珍珠奶茶”;
System.out.println(“请选择配料：1.花生碎 2.杏仁 3.葡萄干 4.什么都不要” );
int subChoice=input.nextInt();
if (subChoice1){
peiliao=“花生碎”;
}else if (subChoice2){
peiliao=“杏仁”;
}else if (subChoice3){
peiliao=“葡萄干”;
}else if (subChoice4){
peiliao=“什么都不要”;
}
System.out.println(“请选择温度：1.多冰 2.少冰 3.常温” );
int sub=input.nextInt();
if (sub1){
wendu=“多冰”;
}else if (sub2){
wendu=“少冰”;
}else if (sub3){
wendu=“常温”;
}
System.out.println(“请选择糖分：1.多糖 2.7分糖 3.5分糖” );
int subb=input.nextInt();
if (sub1){
tangfen=“多糖”;
}else if (sub2){
tangfen=“7分糖”;
}else if (sub3){
tangfen=“5分糖”;
}
price=20;
break;
case 2:
name=“可乐”;
System.out.println(“请选择可乐品牌：1.百事可乐 2.可口可乐”);
int brandChoice=input.nextInt();
brand=brandChoice1?“百事可乐：”:“可口可乐”;
price=8;
break;
default:
name=“矿泉水”;
price=5;
break;
}
System.out.println(“请输入饮料的类型（1.大杯、2.中杯）”);
int typ=input.nextInt();

​ if (typ==1){
​ type=“大杯”;
​ price=price*1.4;
​ }else{
​ type=“中杯”;
​ price=price;
​ }
​ Milktea drink=MilkteaFactory.newInstance(choice,name,price,type,peiliao,wendu,tangfen,brand);
​ drink.orderInfo();
​ System.out.println(“提交订单吗？（y/n）”);
​ String answer=input.next();
​ if (“y”.equals(answer)){
​ System.out.println(“付款金额：”);
​ double money=input.nextDouble();
​ while (money<price){
​ System.out.println(“实付金额不足！请重新支付！”);
​ money=input.nextDouble();
​ }
​ System.out.println(“付款成功！找零：￥”+(money-price)+“元，欢迎下次光临！”);
​ }else {
​ System.out.println(“残忍决绝。。。。。”);
​ }
}
}

2.8

package com.naicha;
public class TestMilktea {
public static void main(String [] args){
Yonghuxitong nihao=new Yonghuxitong();
nihao.mainMenu();
}
ice==1?“百事可乐：”:“可口可乐”;
price=8;
break;
default:
name=“矿泉水”;
price=5;
break;
}
System.out.println(“请输入饮料的类型（1.大杯、2.中杯）”);
int typ=input.nextInt();

​ if (typ==1){
​ type=“大杯”;
​ price=price*1.4;
​ }else{
​ type=“中杯”;
​ price=price;
​ }
​ Milktea drink=MilkteaFactory.newInstance(choice,name,price,type,peiliao,wendu,tangfen,brand);
​ drink.orderInfo();
​ System.out.println(“提交订单吗？（y/n）”);
​ String answer=input.next();
​ if (“y”.equals(answer)){
​ System.out.println(“付款金额：”);
​ double money=input.nextDouble();
​ while (money<price){
​ System.out.println(“实付金额不足！请重新支付！”);
​ money=input.nextDouble();
​ }
​ System.out.println(“付款成功！找零：￥”+(money-price)+“元，欢迎下次光临！”);
​ }else {
​ System.out.println(“残忍决绝。。。。。”);
​ }
}
}

2.8

package com.naicha;
public class TestMilktea {
public static void main(String [] args){
Yonghuxitong nihao=new Yonghuxitong();
nihao.mainMenu();
}
}