学习Java第十天

一、租车系统

step01 需求

step02 新建一个操作类 Player

package com.qk.test07; public class Player { //定义一个数组 Vehicle [] vehicles= new Vehicle[8]; //有车方法 public void init(){ //将轿车保存到数组中 vehicles[0]=new Car("宝马","粤A11111",800,"X6"); vehicles[1]=new Car("宝马","粤A33333",600,"550i"); vehicles[2]=new Car("别克","粤A66666",300,"GL8"); vehicles[3]=new Car("别克","粤A88888",800,"林荫大道"); //将客车保存到数组中 vehicles[4]=new Bus("金龙","京88888",800,16); vehicles[5]=new Bus("金龙","京66666",1500,34); vehicles[6]=new Bus("金杯","京44444",800,16); vehicles[7]=new Bus("金杯","京10086",1500,34); } //找车方法 public Vehicle findCar(String brand,String type,int seatCount){ //遍历数组，非空验证 if(vehicles!=null&&vehicles.length>0){ for(int i=0;i<vehicles.length;i++){ //因为需要子类的资源，所以需要向下 //判断是否可以还原成功 Vehicle v= vehicles[i]; if(v instanceof Car){ Car c= (Car) v; if(c.getBrand().equals(brand) &&c.getType().equals(type)){ return c; } }else if(v instanceof Bus){ Bus b= (Bus) v; if (b.getBrand().equals(brand)&&b.getSeatCount()==seatCount){ return b; } } } } return null; } }

step03定义-测试类

package com.qk.test07; import java.util.Scanner; public class Test { public static void main(String[] args) { //实例化Scanner Scanner input= new Scanner(System.in); System.out.println("*********欢迎来到国庆租车系统*********"); System.out.println("1.轿车\t2.客车"); System.out.println("请选择你需要租车的类型："); int id= input.nextInt(); //定义变量来记录输入的值 String brand=""; String type=""; int seatCount=0; if(id==1){ //选择的是轿车 System.out.println("请选择租车的品牌：1.宝马\t2.别克"); int brandId=input.nextInt(); if(brandId==1){ brand="宝马"; System.out.println("请选择您需要租车的型号：1.X6\t2.550i"); int typeId=input.nextInt(); if(typeId==1){ type="X6"; } } }else{ //选择的是客车 System.out.println("请选择租车的品牌：1.金龙\t2.金杯"); int brandId=input.nextInt(); if(brandId==1){ brand="金龙"; System.out.println("请选择您需要租车的座位数：1.16\t2.34"); int seatCountId=input.nextInt(); if(seatCountId==1){ seatCount=16; }else{ seatCount=34; } } } //实例化的对象 Player p=new Player(); //初始化车 p.init(); //找车 Vehicle v= p.findCar(brand,type,seatCount); System.out.println("请输入您需要租车的天数："); int days=input.nextInt(); System.out.println("您租的车牌号是："+v.getNoId()); double price=v.play(days)*v.getRent(); System.out.println("总金额是："+price); } }

二、抽象方法

1、概念：只有方法的声明 没有方法实现 使用abstract来修饰的方法 就是抽象方法

2、语法：

访问修饰符 abstract 返回值类型 方法名称 （参数列表）；

例如： public abstract void showInfo(int age);

3、作用：简化方法编写

4、注意点：抽象方法必须在抽象类中

5、使用场景 ：抽象方法一般定义在父类中 用于给子类来进行重写

三、抽象类

1、概念：使用abstract 来进行修饰类就是抽象类

2、语法：

访问修饰符 abstract class 类名{}

例子：public abstract class Fu{}

3、成员：

A.成员变量

B.构造方法

C.方法：成员方法 抽象方法 静态方法

4、说明：

A.抽象类是不能实例化对象

B.抽象类中构造方法一般用于给子类进行调用

C.抽象方法一定是在抽象类中但是抽象类中不一定都是抽象方法 可以其他方法

D.如果父类为抽象类 子类必须实现父类中所有的抽象方法 除非子类也是抽象类 就可以不实现

5、抽象方法与抽象类关系

A.抽象方法必须在抽象类中

B.抽象类可以有其他的成员方法 不止是抽象方法

6、使用场景：

抽象类一般用于作为父类

四、案例

step01

step02

step03 代码-员工类

package com.gkd.test01; public abstract class Emp { private String name; private int noId; private double salary; public Emp() { } public Emp(String name, int noId, double salary) { this.name = name; this.noId = noId; this.salary = salary; } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getNoId() { return noId; } public void setNoId(int noId) { this.noId = noId; } public double getSalary() { return salary; } public void setSalary(double salary) { this.salary = salary; } public abstract void work(); }

step04-程序员类

package com.gkd.test01; public class Coder extends Emp{ private double money; public Coder() { } public Coder(String name, int noId, double salary, double money) { super(name, noId, salary); this.money = money; } public double getMoney() { return money; } public void setMoney(double money) { this.money = money; } @Override public void work() { System.out.println("撸代码..........."); } }

step05-代码-项目经理类

package com.gkd.test01; public class Programmer extends Emp{ private double money; public Programmer() { } public Programmer(String name, int noId, double salary, double money) { super(name, noId, salary); this.money = money; } public double getMoney() { return money; } public void setMoney(double money) { this.money = money; } @Override public void work() { System.out.println("控制项目进度..........."); } }

测试员类

package com.gkd.test01; public class Tester extends Emp{ public Tester() { } public Tester(String name, int noId, double salary) { super(name, noId, salary); } @Override public void work() { System.out.println("测试项目....."); } }

测试类：

package com.gkd.test01; public class Test { public static void main(String[] args) { //实例化程序员对象 Emp coder=new Coder("老王",1001,19000,2000); System.out.println(coder.getName() +"\t"+ coder.getNoId() +"\t"+ coder.getSalary()); coder.work(); //实例化项目经理对象 Emp pgm=new Programmer("阿廖",1002,20000,3000); System.out.println(pgm.getName() +"\t"+ pgm.getNoId() +"\t"+ pgm.getSalary()); pgm.work(); //实例化测试员对象 Emp te=new Tester("凤舞",1003,18000); System.out.println(te.getName() +"\t"+ te.getNoId()+"\t" + te.getSalary()); te.work(); } }

五、接口

5.1接口定义

1、生活中的接口 usb接口 Type-c接口 电源接口……

2、开发中接口类似生活中的接口 就是定义一个规范和约束条件

3、规范：就是定义一些抽象方法

4、关键字：interface

5、接口演绎之后也是一个class文件 class对象

6、语法：

访问修饰符 interface 接口名称{

}

例如：

public interface Inner { }

7、成员：

A.接口中变量都是静态的常量 默认使用public static final 来修饰符

B.接口中的方法：

接口中默认的方法使用 public abstract 来进行修饰符

a.在jdk1.8之前 接口中只能有抽象的方法

b.在jdk1.8之后 接口中可以抽象方法 静态的方法 默认的方法 在jdk1.9之后可以私有的方法

C.接口中没有构造方法

8、注意点：

A.接口没有构造方法 接口不能实例化对象

B.接口一般用于来约束实现类 用于提供给实现类来是实现接口（实现规范）

5.2实现类

1、概念：实现接口的类就是实现类

2、分类：

单实现：只实现一个接口

多实现：同时实现多个接口

3、单实现

语法：访问修饰符 class 类名 implment 接口名称{}

例子：public class Implments Inner{}

原则：实现类必须实现接口中所有的抽象方法（）

六、案例

step01需求

step02分析

step03代码-接口

package com.gkd.test02; public interface USBInterface { void open(); void close(); }

step04代码-鼠标类

package com.gkd.test02; public class Mouse implements USBInterface{ @Override public void open() { System.out.println("鼠标开启………………………………"); } @Override public void close() { System.out.println("鼠标关闭………………………………"); } }

step05代码-键盘类

package com.gkd.test02; public class KeyBoard implements USBInterface{ @Override public void open() { System.out.println("键盘开启…………………………"); } @Override public void close() { System.out.println("键盘关闭…………………………"); } }

step06代码-笔记本类

package com.gkd.test02; public class NoteBook { public void open(){ System.out.println("笔记本开机……………………………………"); } public void use(USBInterface usb){ usb.open(); usb.close(); } public void close(){ System.out.println("笔记本关机…………………………………………"); } }

step07-代码测试类

package com.gkd.test02; public class Test { public static void main(String[] args) { //定义笔记本类 NoteBook note=new NoteBook(); note.open(); //定义鼠标类 USBInterface us1=new Mouse(); note.use(us1); //定义键盘类 USBInterface us2=new KeyBoard(); note.use(us2); note.close(); } }

七、类与接口 类与类之间的关系

1、类与类：只能单继承 多层继承 不能多继承

2、类与接口：单实现 多实现

3、接口与接口：单继承 多继承 多层继承

八、案例

step01需求-分析

step02代码-纸张类接口

package com.gkd.test03; public interface Pager { String getPager(); }

step03代码-A3纸张类

package com.gkd.test03; public class A3Pager implements Pager{ @Override public String getPager() { return "A3纸张"; } }

step04代码-A4纸张类

package com.gkd.test03; public class A4Pager implements Pager{ @Override public String getPager() { return "A4纸张"; } }

step05代码-墨盒类接口

package com.gkd.test03; public interface Link { String getLink(); }

step06代码-白色墨盒类

package com.gkd.test03; public class WhiteLink implements Link{ @Override public String getLink() { return "白色墨盒"; } }

step07代码-彩色墨盒类

package com.gkd.test03; public class ColorLink implements Link{ @Override public String getLink() { return "彩色墨盒"; } }

step08代码-打印机类

package com.gkd.test03; public class Printer { private Pager pager; private Link link; public Printer() { } public Printer(Pager pager, Link link) { this.pager = pager; this.link = link; } public Pager getPager() { return pager; } public void setPager(Pager pager) { this.pager = pager; } public Link getLink() { return link; } public void setLink(Link link) { this.link = link; } public void print(){ System.out.println(pager.getPager()+"\t"+link.getLink()); } }

step09代码-测试类

package com.gkd.test03; public class Test { public static void main(String[] args) { //实例化一个Pager纸张类 Pager pg1=new A3Pager(); Pager pg2=new A4Pager(); //实例化一个Link墨盒类 Link l1=new ColorLink(); Link l2=new WhiteLink(); //实例化一个打印机类 //使用构造方法赋值 Printer p=new Printer(pg1,l1); //调用方法 p.print(); //实例化一个打印机类 Printer p1=new Printer(); //使用get-set方法赋值 p1.setPager(pg2); p1.setLink(l2); //调用方法 p1.print(); } }

九、代码块

1、概念：编写在大括号中的代码 就是代码块（代码）

2、分类：局部代码块 构造代码块 静态代码块

3、局部代码块

位置：定义在方法中

语法：{代码}

作用：用于来限制变量的生命周期

说明：在局部代码块外定义的变量 在局部代码块中给变量赋值 在代码块外获取的是改变后的值

4、构造代码块

位置：定义在类中 方法外

语法：{代码}

作用：用于给成员变量赋值

说明：

A.构造代码块是由jvm执行的

B.构造代码块优先于构造方法执行

C.每次实例化对象 都会执行构造代码块

5、静态代码块

位置：定义在类中 方法外

语法：static{代码}

作用：用于来加载配置文件 配置文件只需要加载一次 例如：lo4j配置文件

说明：

A.静态代码块可以用来给静态变量赋值

B.静态代码块优于构造方法先执行

C.静态代码块只执行一次 类加载的时候执行一次

step01-局部代码块

package com.gkd.test04; public class Test { public static void main(String[] args) { int num1=20; { int num=30; System.out.println(num); num1 = 100; } System.out.println(num1); } }

step02-构造代码块

package com.gkd.test04; public class Student { String name; { name="张三"; System.out.println(name+"执行了构造代码块"); } public Student(){ System.out.println(name+"执行了构造方法"); } }

step03-构造代码块-测试类

package com.gkd.test04; public class Test01 { public static void main(String[] args) { //实例化Student对象 Student stu=new Student(); Student stu1= new Student(); } }

step04-静态代码块

package com.gkd.test04; public class Person { static int num=10; int num1=200; static { // num=300; System.out.println("静态代码块执行了…………………………"); } public Person(){ System.out.println("执行了构造方法"); } }

step05-静态代码块测试类

package com.gkd.test04; public class Test02 { public static void main(String[] args) { Person ps=new Person(); System.out.println(ps.num1); // ps.num Person ps1=new Person(); Person ps2=new Person(); } }