学习笔记-Java8接口、异常与集合
文章目录
- 一、多态
- 1.多态入门
- 2.多态示例
- 3.父转子（instanceof）
- 二、接口
- 1.接口入门
- 2.面向接口编程
- 3.Java8接口升级-1
- 4.接口中的变量
- 三、集合
- 1.集合
- 2.Collection与Iterable接口
- 3.Set与List接口
- 4.Map接口
- 四、异常
- 1.异常
- 2.手动抛出异常
- 3.log4j写日志
一、多态
1.多态入门
- OCP ：open close program
对功能扩展是open的，对代码修改是close的 - 定义时是父类的引用，传入的是子类的实例。
- 关键技术：继承、重写
- 面向接口编程使用的核心技术是多态。
形参使用接口，实参使用实现了该接口的不同类。不同的类实例，执行相同的行为，产生不同的结果，所以被称为多态。
2.多态示例
- Printer类
package com.icss.print.biz;
public abstract class Printer {
private String pno;
public String getPno() {
return pno;
}
public Printer(String pno) {
this.pno=pno;
}
public abstract void print(String input);
}
- BlackPrinter类
package com.icss.print.biz;
public class BlackPrinter extends Printer{
public BlackPrinter(String pno) {
super(pno);
// TODO Auto-generated constructor stub
}
@Override
public void print(String input) {
// TODO Auto-generated method stub
System.out.println(this.getPno()+"is print black info--"+input);
}
}
- ColorPrinter类
package com.icss.print.biz;
public class ColorPrinter extends Printer {
public ColorPrinter(String pno) {
super(pno);
// TODO Auto-generated constructor stub
}
@Override
public void print(String input) {
// TODO Auto-generated method stub
System.out.println(this.getPno()+"is print color info--"+input);
}
}
- Test类
package com.icss.print.ui;
import com.icss.print.biz.BlackPrinter;
import com.icss.print.biz.ColorPrinter;
import com.icss.print.biz.Printer;
public class Test {
public static void print(Printer printer,String input) {
if(printer!=null) {
printer.print(input);
}
}
public static void main(String[] args) {
//BlackPrinter aa=new BlackPrinter("001");
//Printer black=(Printer) aa; //子转父，是安全的
Printer aa=new BlackPrinter("001");
ColorPrinter bb=new ColorPrinter("002");
Test.print(aa, "中国");
Test.print(bb, "中华");
}
}
3.父转子（instanceof）
- 明确子类是哪一个的转换
Pet p1=new Dog("憨憨"); //子转父是安全的
Dog dog=(Dog)p1; //父转子可能正确，也可能出错
- 不明确子类是哪一个的转换
public static void play(Pet pet) {
if(pet instanceof Dog) {//父转子，转换后可以调用子类的特有方法，为了安全，转换前需要用instanceof判断是否安全
Dog dog=(Dog)pet;
dog.playBall();
}else if(pet instanceof Penguin) {
Penguin pen=(Penguin)pet;
pen.diveWater();
}else {
pet.play();
}
}
二、接口
1.接口入门
-
接口的特点：
1.接口里面没有属性，接口里面可以放常量。
2.接口里面默认都是抽象方法，可以不写abstract关键字。
3.所有方法都是public，不允许使用private和protected。使用默认关键字，编译时会自动加上public修饰。
4.一个接口中可以包含多个相关的方法。
5.类使用implements去实现接口。类实现接口后，必须要重写接口里面的所有方法（除非这个实现类是抽象的）。
6.一个接口可以继承（extends）另一个接口。
7.一个类可以实现多个接口（解决多重继承问题）。 -
接口的好处：（接口是能力的体现）
1.Java语言不允许多重继承，使用接口可以替代多重继承。
2.面向接口编程 -
接口与抽象类对比：
- 共同点：
接口和抽象类都可以有抽象方法。 - 不同点：
1.接口里面都是抽象方法，抽象类里可以有抽象方法，也可以有非抽象方法。
2.抽象类可以有属性，接口里不能有属性，只能有常量。
- 共同点：
2.面向接口编程
public interface IPlay {
public void swim();
}
public class Game {
/**
* 面向接口编程
* @param player
*/
public void swimGame(IPlay player) {
if(player != null) {
player.swim();
}
}
}
public class Dog extends Pet implements IPlay{
public Dog(String name) {
super(name);
// TODO Auto-generated constructor stub
}
@Override
public void swim() {
// TODO Auto-generated method stub
System.out.println(this.name+"is swimming");
}
}
3.Java8接口升级-1
public interface IPlay {
public void swim();
public default void run() { //升级新加的内容
System.out.println("IPlay--->run");
}
}
java.sql —Interface PreparedStatement
void setDate(int parameterIndex , java.sql.Date x)
throws SQLException
使用运行应用程序的虚拟机的默认时区将指定的java.sql.Date设置为给定的java.sql.Date值。 当驱动程序将其发送到数据库时，将其转换为SQL DATE值。
- 在Java8中日期类型升级了(java.sql—Class Date -->>java.time.LocalDate)，但JDBC并没有升级，还是使用传统的java.sql.Date。
为什么不使用interface中的default方法进行JDBC升级？
JDBC是一套开放性的接口，它是sun来定义的，但实现类是各个数据库的厂商。oracle、MySQL、sql-server都有JDBC实现且各不相同。
最终结果：说明采用接口中的default方法，是无法解决JDBC升级问题的，只能在某些情况下解决JDK升级问题。好处是原有项目的新业务拓展。
4.接口中的变量
public interface ITest {
public double PI=3.1415926; //编译期常量
public String aa="aa"; //运行期常量
public Dog doh=new Dog(); //dog是变量，但不能重新赋值，只能赋dog里面的属性值
public void getUname(); //抽象方法
public default void getPwd() { //默认方法，可以默认实现
System.out.println("pwd");
}
public static void getAge() { //静态方法
System.out.println("age");
}
}
三、集合
1.集合
-
Collection（不唯一、无序）：
1.集合的接口—集合中的内容可能有序可能无序。
2.集合内不能存放基本数据类型，只能存放对象的引用。 -
List（不唯一、有序插入）：
1.有序集合，他继承了Collection接口。
2.集合内可以运行重复对象。
ArrayList—底层数据结构是静态数组，当数据相对确定、读较多时使用简单方便。
LinkedList—底层数据结构是链表，当需要频繁使用插队添加、移除等操作时使用性能好。 -
Set（唯一、无序）：
1.无序集合。
2.不允许存放重复对象
HashSet—底层数据结构是哈希散列
public class RentCompany {
private String name;
private static List<Moto> motos; //租赁公司有多少车
public static List<Moto> getMotos() {
return motos;
}
/**
* 给公司新增用于出租的车
* @param moto
*/
public static void addMotos(Moto moto) {
if(motos !=null) {
motos.add(moto);
}
readAllMotos();
}
/**
* 从列表中移除
* @param moto
*/
public static void removeMotos(Moto moto) {
if(motos!=null) {
motos.remove(moto);
System.out.println("已删除"+moto.getMno()+moto.getMototype());
}
readAllMotos();
}
static {
Bus b1=new Bus("B001",11,Mototype.GOLD_CUP,800);
Bus b2=new Bus("B002",17,Mototype.GOLD_CUP,1500);
Bus b3=new Bus("B003",50,Mototype.GOLD_LONG,1500);
Bus b4=new Bus("B004",34,Mototype.GOLD_LONG,1500);
Car c1=new Car("C001",Mototype.BK_GL8,600);
Car c2=new Car("C002",Mototype.BK_LYDD,300);
Car c3=new Car("C003",Mototype.BM_550,500);
Car c4=new Car("C004",Mototype.BK_LYDD,300);
Car c5=new Car("C005",Mototype.BM_550,500);
Trunk t1=new Trunk("T001",Mototype.YELLOW_RIVER,30);
motos=new ArrayList<Moto>(30); //集合的初始化
motos.add(b1);
motos.add(b2);
motos.add(b3);
motos.add(b4);
motos.add(c1);
motos.add(c2);
motos.add(c3);
motos.add(c4);
motos.add(c5);
motos.add(t1);
readAllMotos();
}
private static void readAllMotos() {
if(motos !=null) {
System.out.println("一共有车"+motos.size());
for(int i=0;i<motos.size();i++) {
Moto moto=motos.get(i);
System.out.println(moto.getMototype()+"--"+moto.getMno());
}
System.out.println("+++++++++++++++++++++++++++++");
}
}
public String getName() {
return name;
}
public RentCompany(String name) {
this.name=name;
}
/**
* 出租某辆车的租金
* @param moto 出租车辆
* @param days 出租时间
* @return
*/
public double rentMoto(Moto moto,int days) {
double allmoney=0;
if(moto!=null) {
allmoney=moto.calRent(days);
}
return allmoney;
}
/**
*
* @param motos 要一次出租多辆车的信息
* @param days 出租的天数
* @return 总租金
*/
public double rentMoto(List<Moto> motos,int days) {
double allmoney=0;
for(int i=0;i<motos.size();i++) {
Moto moto=motos.get(i);
allmoney=allmoney+moto.calRent(days);
}
return allmoney;
}
}
public class MotoTest {
public static void main(String[] args) {
RentCompany comp=new RentCompany("金剑出租");
Moto moto=comp.getMotos().get(8);
double allmoney=comp.rentMoto(moto, 2);
System.out.println(moto.getMototype()+"--日租金"+moto.getDaymoney()+"--总租金"+allmoney);
Bus b5=new Bus("B006",40,Mototype.GOLD_LONG,1500);
comp.addMotos(b5);
comp.removeMotos(comp.getMotos().get(5));
List<Moto> motos=new ArrayList<Moto>();
motos.add(comp.getMotos().get(6));
motos.add(comp.getMotos().get(8));
motos.add(comp.getMotos().get(4));
motos.add(comp.getMotos().get(3));
motos.add(comp.getMotos().get(8));
allmoney=comp.rentMoto(motos, 3);
System.out.println("出租多辆车的总租金是"+allmoney);
}
}
2.Collection与Iterable接口
- Iterable接口-------------------iterator()
Iterator接口--------------------hasNext()、next() - Collection接口（父接口： Iterable）----------------boolean add(E e)、boolean remove(Object o)、int size()
//遍历集合中的所有元素
Iterator it=motos.iterator();
while(it.hasNext()) { //判断里面是否有内容，如果有元素，it.hasNext()返回true
Object obj=it.next();
Moto moto=(Moto) obj;
System.out.println(moto.getMototype()+"--"+moto.getMno());
}
for(Moto moto:motos) {
System.out.println(moto.getMototype()+"--"+moto.getMno());
}
3.Set与List接口
- List接口（父接口：Collection）---------------------E get(int index)、E remove(int index)
- set接口（父接口：Collection）
4.Map接口
- Map
V put(K key,V value)
V get(Object key)
Set< K> keySet() 找出map中所有的key
int Size()
public class RentCompany {
private String name;
private static List<Moto> motos; //租赁公司有多少车
private static Map<String,Moto> motoMap;
public static List<Moto> getMotos() {
return motos;
}
public static Map<String ,Moto> getMotoMap(){
return motoMap;
}
/**
* 给公司新增用于出租的车
* @param moto
*/
public static void addMotos(Moto moto) {
if(motoMap!=null) {
motoMap.put(moto.getMno(), moto);
readAllMotoMap();
}
readAllMotos();
}
/**
* 从列表中移除
* @param moto
*/
public static void removeMotos(Moto moto) {
if(motoMap!=null) {
motoMap.remove(moto);
System.out.println("已删除"+moto.getMno()+moto.getMototype());
readAllMotos();
}
}
static {
Bus b1=new Bus("B001",11,Mototype.GOLD_CUP,800);
Bus b2=new Bus("B002",17,Mototype.GOLD_CUP,1500);
Bus b3=new Bus("B003",50,Mototype.GOLD_LONG,1500);
Bus b4=new Bus("B004",34,Mototype.GOLD_LONG,1500);
Car c1=new Car("C001",Mototype.BK_GL8,600);
Car c2=new Car("C002",Mototype.BK_LYDD,300);
Car c3=new Car("C003",Mototype.BM_550,500);
Car c4=new Car("C004",Mototype.BK_LYDD,300);
Car c5=new Car("C005",Mototype.BM_550,500);
Trunk t1=new Trunk("T001",Mototype.YELLOW_RIVER,30);
motoMap=new HashMap<String,Moto>(); //map的初始化
motoMap.put(b1.getMno(), b1);
motoMap.put(b2.getMno(), b2);
motoMap.put(b3.getMno(), b3);
motoMap.put(b4.getMno(), b4);
motoMap.put(c1.getMno(), c1);
motoMap.put(c2.getMno(), c2);
motoMap.put(c3.getMno(), c3);
motoMap.put(c4.getMno(), c4);
motoMap.put(c5.getMno(), c5);
motoMap.put(t1.getMno(), t1);
readAllMotoMap();
}
/**
* Map的遍历方式
*/
private static void readAllMotoMap() {
if(motoMap!=null) {
Set<String> keys=motoMap.keySet();
for(String key:keys) {
Moto moto=motoMap.get(key);
System.out.println(moto.getMototype()+"--"+moto.getMno());
}
System.out.println("+++++++++++++++++++++++++++++");
}
}
/**
* 集合的遍历方式
*/
private static void readAllMotos() {
if(motos !=null) {
System.out.println("一共有车"+motos.size());
// for(int i=0;i
// Moto moto=motos.get(i);
// System.out.println(moto.getMototype()+"--"+moto.getMno());
// }
//遍历集合中的所有元素
Iterator it=motos.iterator();
while(it.hasNext()) { //判断里面是否有内容，如果有元素，it.hasNext()返回true
Object obj=it.next();
Moto moto=(Moto) obj;
System.out.println(moto.getMototype()+"--"+moto.getMno());
}
// for(Moto moto:motos) {
// System.out.println(moto.getMototype()+"--"+moto.getMno());
// }
System.out.println("+++++++++++++++++++++++++++++");
}
}
public String getName() {
return name;
}
public RentCompany(String name) {
this.name=name;
}
/**
* 出租某辆车的租金
* @param moto 出租车辆
* @param days 出租时间
* @return
*/
public double rentMoto(Moto moto,int days) {
double allmoney=0;
if(moto!=null) {
allmoney=moto.calRent(days);
}
return allmoney;
}
/**
* 根据汽车编号，出租一批车
* @param motos
* @param days
* @return
*/
public double rentMoto(Set<String> motos,int days) {
double allmoney=0;
System.out.println("一共出租了"+motos.size()+"台车");
for(String mno:motos) {
Moto moto=motoMap.get(mno); //通过汽车编号找汽车
System.out.println(moto.getMototype()+"--"+moto.getMno());
if(moto!=null) {
allmoney=allmoney+moto.calRent(days);
}
}
return allmoney;
}
}
public class MotoTest {
public static void main(String[] args) {
RentCompany comp=new RentCompany("金剑出租");
Set<String> motoSet=new HashSet<String>();
motoSet.add("B001");
motoSet.add("C001");
motoSet.add("T001");
comp.rentMoto(motoSet, 3);
}
}
四、异常
1.异常
- 异常：当程序出现异常时，会向程序调用者抛出异常，从发送异常的地方起，后面的代码不再执行。
异常一定不要抛给最终用户，应该由业务系统处理。处理好给用户一个有好的提示。 - 异常捕获机制：
try {
//此处放可能发生异常的代码
} catch (Exception e) {
//处理异常
}finally {
//释放异常
//不管程序是否异常，此处都会被执行
}
public static void test() {
try {
Scanner in=new Scanner(System.in);
System.out.println("请输入被除数：");
int num1=in.nextInt();
System.out.println("请输入除数：");
int num2=in.nextInt();
System.out.println(String.format("%d/%d=%d", num1,num2,num1/num2));
} catch (java.lang.ArithmeticException e) {
//记录日志
//e.printStackTrace(); //屏幕输出异常，用于调试
System.out.println("------输入错误，除数不能为0------");
}catch (java.util.InputMismatchException e){
System.out.println("------除数只能为整数------");
}catch(Exception e){
System.out.println("------出现未知错误------");
}finally {
System.out.println("感谢使用！");
}
}
2.手动抛出异常
public void setSex(String sex) throws Exception{
if(sex!=null) {
if(sex.equals("MALE")||sex.equals("FEMALE")) {
this.sex = sex; //性别有效值
}else {
throw new Exception("性别有效值只能是male或female");
}
}
}
public static void main(String[] args) {
Dog dog=new Dog("欢欢");
try {
dog.setSex("MALEe");
}catch(Exception e) {
String msg=e.getMessage();
System.out.println(msg);
}
System.out.println(dog.getName()+"性别是"+dog.getSex());
}
3.log4j写日志
- 日志级别：
Error（错误、异常）—>warning—>info（提示信息）—>debug（调试） - 原则：只要有catch的地方，一定要记日志
Log.getLogger().info(uname+"--开始登录系统");
Log.getLogger().debug("uname="+uname+"--pwd"+pwd); //调试信息
Log.getLogger().error(e.getMessage());
public class Log {
public static Logger getLogger() {
return Logger.getLogger(Log.class.getName()); //通过反射机制，动态获得日志的记录位置
}
}