投稿
  1. 极客之音首页
  2. 技术随笔

Java 08 多态 接口 抽象类

seven_ • • 技术随笔 • 阅读 85

导读：本篇文章讲解 Java 08 多态 接口 抽象类，希望对大家有帮助，欢迎收藏，转发！站点地址：www.bmabk.com

一、多态(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;
    }
}

版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 举报，一经查实，本站将立刻删除。

文章由极客之音整理，本文链接：https://www.bmabk.com/index.php/post/121493.html

赞 (0)
seven_的头像seven_bm
0 0

相关推荐

发表回复

登录后才能评论
极客之音——专业性很强的中文编程技术网站，欢迎收藏到浏览器，订阅我们！