1. 多态、抽象类、接口、内部类、Lambda
编译看类型运行找对象
多态: 多种形态，在运行的过程中，根据使用子类对象不同调用了不同子类对象的方法，发生不同的行为。 模糊策略,以不变应万变。
1.1 前提
继承 重写 父类的引用=子类对象
class Fruit{}
class Pear extends Fruit{}
Fruit f = new Fruit(); //水果是水果
Pear p = new Pear();//梨是梨
Fruit f2 = new Pear(); //梨是水果
1.2 新增
发生多态时，对新增方法不可见
1.3 类型转换
前提: 引用指向对象的类型 可转。 转换完成后，可以调用新增方法
1.4 instanceof
避免 ClassCastException 这个异常。引用指向的对象类型是 本类型或父类型 子类类型 ，在一条链上 ，否则instanceof不能使用
2. 抽象类
2.1 子类
抽象类一定有子类，没有子类的抽象类没有意义
2.2 abstract
public abstract class Xxx{
}
不能直接实例化，不能new
2.3 抽象方法
抽象方法一定存在于抽象类中（规范子类编写代码必须填），抽象类中可以没有抽象方法（避免直接实例化）
具体子类，必须实现抽象方法
可以不实现抽象方法，但是这样就没意义了
3. 接口 interface
3.1 格式
public interface 接口名{
//全局常量
public static final常量类型 常量名 = 值;
//公开的抽象方法
public abstract 返回类型|void 方法名(形参列表);
//私有方法
private返回类型|void 方法名(形参列表){}
//静态方法
public static返回类型|void 方法名(形参列表){}
//默认方法
public default返回类型|void 方法名(形参列表){}
}
3.2 实现 implements
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("设备连接");
}
}
3.2.1 单继承，类与类之间
3.2.2 多实现，类与接口之间
3.2.3 多继承，接口与接口
public interface A {
}
interface B{}
interface C extends A,B{
}
3.2.4 空接口
Cloneable 具备可以复制的能力； Serializable: 具备可序列化|持久化的能力
3.2.5 简单工厂
package shsxt.test0110;
/**
* 一个成员方法
* 三个实现接口
* @author zhuch
*
*/
public interface Car {
public void run();
}
package shsxt.test0110;
public class CarBmw implements Car{
@Override
public void run() {
// TODO Auto-generated method stub
System.out.println("宝马");
}
}
package shsxt.test0110;
public class CarByd implements Car{
@Override
public void run() {
// TODO Auto-generated method stub
System.out.println("比亚迪");
}
}
package shsxt.test0110;
public class CarLbjn implements Car{
@Override
public void run() {
// TODO Auto-generated method stub
System.out.println("兰博基尼");
}
}
package shsxt.test0110;
public class CarFactory {
public static Car factory(String str) {
if(str.equals("宝马")) {
return new CarBmw();
}else if(str.equals("比亚迪")) {
return new CarByd();
}else if(str.equals("兰博基尼")) {
return new CarLbjn();
}
return null;
}
}
package shsxt.test0110;
import shsxt.util.MyUtil;
public class CarApp {
public static void main(String[] args) {
String brand=MyUtil.getStrFromConsole("请输入车的品牌");
Car car=CarFactory.factory(brand);
car.run();
}
}
3.2.6 静态代理
package shsxt.test0110;
/**
* 静态代理
* @author zhuch
*
*/
public interface Married {
void married();
}
class agency implements Married{
private Married m;
public agency(Married m) {
this.m=m;
}
private void zb() {
System.out.println("准备工作");
}
@Override
public void married() {
// TODO Auto-generated method stub
zb();
m.married();
sw();
}
private void sw() {
System.out.println("收尾工作");
}
}
class my implements Married{
@Override
public void married() {
// TODO Auto-generated method stub
System.out.println("自己");
}
}
4. final
final 属性 常量
final 方法 不能重写
final 类 不能继承 最终的
格式
public final class 类名{} //没有子类
5. 内部类
5.1 类中类
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GmqzUb1e-1579585868020)(C:\Users\zhuch\AppData\Roaming\Typora\typora-user-images\1578730310044.png)]
5.2 方法中的类
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-kMXx9GwQ-1579585868021)(C:\Users\zhuch\AppData\Roaming\Typora\typora-user-images\1578730336307.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cNtyA6ok-1579585868021)(C:\Users\zhuch\AppData\Roaming\Typora\typora-user-images\1578730343872.png)]
5.3 匿名内部类
package shsxt.test0110.test;
/**
* 匿名内部类
* @author zhuch
*
*/
public class Anonymous {
public static void main(String[] args) {
new Fruits1() {
public void printTest() {
// TODO Auto-generated method stub
System.out.println("第一次使用");
}
}.printTest();
}
}
interface Fruits1{
public void printTest();
}
5.4 java8
Lambda 表达式，简化匿名内部类的使用的。 重点代码的实现 ，不需要关注类名不需要关注方法名，关注的是形参与方法体
5.4.1 函数式接口
当一个接口抽象方法只有一个，私有、静态、default不计算在内
public interface Cal {
//抽象方法
public void add(int a,int b);
private void test() {}
public static void print() {}
}
5.4.2 Lambda
关注: 形参 返回
public interface Cal {
//抽象方法
public int add(int a,int b);
}
演变
public class Xxx implements Cal{
public int add(int a,int b){
return a+b;
}
}
new Cal(){
public int add(int a,int b){
return a+b;
}
};
Lambda的写法 ，三部分
1、形参 2、-> 3、方法体
(int a,int b)->{return a+b;}
(a,b)->a+b;
5.4.3 ::
方法引用 ，简化了Lambda,Lambda是简化了匿名内部类。 需要注意:
方法的形参与返回类型 与 函数式接口的抽象方法能够匹配 即可使用。
1)、构造器引用: 类::new
2)、静态方法 ： 类:: 方法名
s Xxx implements Cal{
public int add(int a,int b){
return a+b;
}
}
new Cal(){
public int add(int a,int b){
return a+b;
}
};
Lambda的写法 ，三部分
1、形参 2、-> 3、方法体
(int a,int b)->{return a+b;}
(a,b)->a+b;
#### 5.4.3 ::
方法引用 ，简化了Lambda,Lambda是简化了匿名内部类。 需要注意:
方法的形参与返回类型 与 函数式接口的抽象方法能够匹配 即可使用。
1)、构造器引用: 类::new
2)、静态方法 ： 类:: 方法名
3)、成员方法： 对象::方法名
