一、多态(polymorphic)
1.理解
编译看类型运行找对象
多态:多种形态,模糊策略,以不变应万变
2.前提
继承 重写 父类的引用=子类对象
public class Car { void run() { System.out.println("跑起来。。。。。"); } public static void main(String[] args) { //多态 //父类 车 子类 Bmw //子类是父类 Car car=new Bmw();//bmw是车 Car car2=new BC();//bc是车 //子类是子类 错误 //Bmw bmw=new BC(); car2.run(); //新增的方法不可用 //car2.read(); //类型转换 BC bc=(BC)car2; bc.read(); } class Bmw extends Car{ void test() { System.out.println("测试起来。。。。"); } } class BC extends Car{ void run() { System.out.println("hhhhhh"); } void read() { System.out.println("准备好。。。"); } }
3.新增
发生多态时,对新增方法不可见
4.类型转换
1)引用指向对象的类型 可转,转换完成后可以使用新增方法
2)转换常出现错误:ClassCastException 类型转换错误
5.instanceof
1)避免ClassCastException 这个异常
2)引用指向的对象类型是 本类型或父类型 子类类型,在一条链上,否则不能使用instanceof。
System.out.println(car instanceof Bmw);
二、抽象类(abstract)
1.理解
具体+规范|模子
之前所有的类都是具体类 (方法有方法体,都编写过) 可以直接使用,现在部分方法不写,定义模子(抽象方法)。
2.子类
抽象类一定有子类,没有子类的抽象类没有意义
3.abstract(抽象类)
1)模拟现实,如果一个不想直接实例化,定义为成abstract类。
2)待子类具体实例化:
不能直接new(),待子类实例化
可能包含抽象方法
public abstract class Shape02 { void area() { System.out.println("算面积。。。"); } //抽象方法 public abstract void move(); } class Rectangle2 extends Shape02{ void area() { System.out.println("长方形面积。。。"); } @Override public void move() { // TODO Auto-generated method stub } } abstract class Square2 extends Shape02{ public void area() { System.out.println("正方形...."); } }Test:测试
package com.shsxt.abstr; public class STest { public static void main(String[] args) { // TODO Auto-generated method stub //Shape shape=new Shape();//不能实例化 viewShape02(new Rectangle2()); } private static void viewShape02(Shape02 s2) { // TODO Auto-generated method stub //张方形的面积 s2.area(); } }
三、接口( interface)
1.标准、规范
按标准按规范制作产品(实现类)即可,特殊的抽象类,全是抽象的(除了静态、私有方法),完全规范。
2.格式
1)全局变量
2)抽象方法
public abstract 返回类型|void 方法名(形参列表); //abstract可以省略 public void read();3)私有方法
private 返回类型|void 方法名(形参列表){} //定义 private void read(int a,int b){ System.out.println("私有方法"); }4)静态方法
public static 返回类型|void 方法名(形参列表){} //定义 public static void testUsb() { System.out.println("静态方法"); }5)默认方法
public default返回类型|void 方法名(形参列表){} //定义 public default void test() { System.out.println("默认方法"); }
3.实现implements
1)子类-->实现类 重写---->实现
public class Disk implements Usb,Connect { @Override public void read() { Usb.testUsb(); System.out.println("数据读取中"+Usb.MAX_SIZE); } @Override public void write() { System.out.println("数据写出中"); } @Override public void connect() { System.out.println("设备连接"); } } 2)单继承:类与类之间
多实现:类与接口之间
多继承:接口与接口
public interface A { } interface B{} interface C extends A,B{ }
4.空接口
Cloneable 具备可以复制的能力; Serializable: 具备可序列化|持久化的能力。
5.简单工厂
public class CarFactory { /** * 简单工厂:创建对象 * @param type * @return */ public static Car product(String type) { if(type.equals("qq")) { return new Qq(); }else if(type.equals("infinity")) { return new Infinity(); }else if(type.equals("bmw")) { return new Bmw(); } return null; } }
6.简单代理
public interface House { void angency(); } //代理角色 class A implements House{ private House house; public A(House house) { this.house=house; } @Override public void angency() { // TODO Auto-generated method stub ready(); house.angency(); compat(); } private void ready() { System.out.println("准备中。。。"); } private void compat() { System.out.println("收合同。。。"); } } //真实角色 class B implements House{ @Override public void angency() { // TODO Auto-generated method stub System.out.println("签合同。。"); } // public void pen() { // System.out.println("签合同。。"); // } }
四、final
1.理解
final 属性 ---->常量
final 方法 ----->不能重写
final 属性 -------->不能继承 最终的
2.格式
public final class 类名{}//没有子类
/** * 最终的类 * @author TW * */ public final class F { } class P{ public final void test() { System.out.println("p test"); } } class Child extends P{ /* //不能重写 public void test() { System.out.println("p test"); }*/ }
五、内部类
1.类中类
public class Inner { //静态属性 //成员属性 //静态内部类 public static class MyInner{} //成员内部类 public class MyInner2{} public static void main(String[] args) { //静态内部类 Inner.MyInner myInner = new Inner.MyInner(); //成员内部类 Inner inner =new Inner(); Inner.MyInner2 myInner2 = inner.new MyInner2(); myInner2 = new Inner().new MyInner2(); } }
2.方法中的类
/** * 方法中的类 跟局部变量类型 * @author TW * */ public class MyInner { public static void main(String[] args) { int a =0; //局部内部类 class In{} new In(); } }
3.匿名内部类对象
new 父类|接口{ } public static void main(String[] args) { //匿名内部类 -->重点 Cal cal =new Cal(){ public void add() { System.out.println("使用一次"); } }; cal.add(); //连写..... new Cal(){ public void add() { System.out.println("使用一次"); } }.add(); //任何一个非final类 |接口都可以编写匿名内部类 Object obj =new Object() { public String toString() { return "内部类"; } }; System.out.println(obj); }
六、Lambda表达式
1.函数式接口
1)Lambda 表达式,简化匿名内部类的使用的。 重点代码的实现 ,不需要关注类名不需要关注方法名,关注的是形参与方法体
2)一个抽象方法,不计算在内私有、静态、default
/** * 包含一个抽象方法的接口 函数式接口 * @author TW * */ @FunctionalInterface public interface Cal { //抽象方法 public void add(int a,int b); private void test() {} public static void print() {} }
2.lambda
1)关注: 形参+返回
2)lambda的写法:1.形参 () 2.-> 3.{} 方法体
public interface Tabs { void read(); } public class TabsTest { public static void main(String[] args) { // TODO Auto-generated method stub Tabs ta=()-> {System.out.println("hellword");}; ta.read(); } }
3.方法引用 ::
方法引用 ,简化了Lambda,Lambda是简化了匿名内部类。 需要注意: 方法的形参与返回类型 与 函数式接口的抽象方法能够匹配 即可使用。
1)、构造器引用: 类::new
2)、静态方法 : 类:: 方法名
3)、成员方法: 对象类::方法名
public class Fruit { public Fruit() { } public Fruit(String type) { } } public class FruitTest { //静态方法 public static Fruit product(String type) { return new Fruit(); } //成员方法 public Fruit productFruit(String type) { return null; } public static void main(String[] args) { // TODO Auto-generated method stub Product p2 = type-> new Fruit(); //lambda都是对匿名方法的简写 Product p=new Product() { @Override public Fruit product(String type) { // TODO Auto-generated method stub return null; } }; //简化 类型 p=(type)->{return new Fruit();}; p=type->new Fruit(type); //lambda 简化 :: 方法引用 //构造器引用:构造器::new p=Fruit::new; //静态方法引用:类::方法名 p=FruitTest::product; //成员方法引用:new类::方法名 p=new FruitTest()::productFruit; } }