继承（补充）- 抽象类 - 接口类

最新推荐文章于 2024-03-12 17:10:30 发布

归去来兮★

最新推荐文章于 2024-03-12 17:10:30 发布

阅读量162

点赞数

分类专栏： java

本文链接：https://blog.csdn.net/zhouhe_/article/details/117137665

版权

java 专栏收录该内容

108 篇文章 1 订阅

订阅专栏

继承（注意）

子类实例化父类

子类一定会先实例化父类构造

1 . 子类默认实例化父类空参构造方法

2 . 若父类无空参构造方法，子类要通过super（）指定
子类继承父类，会继承父类所有

注意：

对于非私有的操作属于显式继承

对于所有的私有操作属于隐式继承
重载与重写区别

比较	重载overload	重写override
方法名	相同	相同
参数	类型,顺序,个数不同	必须相同
返回值类型	可改变	大于等于父类
权限	无要求	小于等于父类

final 关键字
- 定义类：此类为太监类，不能被继承
- 定义方法：此方法不能被重写
- 定义变量：此变量不能被改变
- 定义常量 ：public static finall 数据类型变量名；
面向对象的多态性
- 实例化对象：不要看类名，而要看右边的实例化对象类
- 对象的向上转型：可调用父类方法或子类重写的方法
- 对象的向下转型：可调用子类独有的方法(可以调用父类和子类所有的方法)

对象的向上转型与向下转型

先有向上转型，才能有向下转型

// 安全转型操作
Person p = new SuperMan();
if (p instanceof SuperMan){
	SuperMan sm = (SuperMan) p;
}

三种字符串加载的比较(候补)

// 形式一
//        String s1 = "helloWorld";
//        String s2 = "hello"+"World";
//        System.out.println(s1 == s2); // true

// 形式二
//        String s3 = "World";
//        String s1 = "helloWorld";
//        String s2 = "hello"+s3;
//        System.out.println(s1 == s2); // false

// 形式三
//        String s1 = "helloWorld";
//        String s2 = "hello"+s3;
//        System.out.println(s1 == s2); // true

/**
对于形式一：
	由于字符串常量池的存在首先会被加载到内存，所以true
对于形式二：
	对于运算的操作是在 运行时产生的 ，所以fasle
对于形式三：	
	s3： 是public static final 修饰的常量
	因为s3 这种修饰的原因，所以就形式一相同了

/

native 本地的

java源代码中看到native 就看不到后续代码了

后续会调用其他的编程语言C++ | C 执行内存操作帮我们操作内存如hashCode()方法

abstract 抽象类–（很不具体，没有具体的执行只是一个概念）

可以修饰什么

修饰方法：用abstract修饰符修饰的方法，只有方法的结构没有方法的执行体

注意：用native 修饰的方法也没有执行体，但不是抽象方法，只是执行过程是其他语言看不到

修饰类：用 abstract 修饰的类就做抽象类
修饰后的特点

抽象类中不是必须要有抽象方法

抽象方法必须在抽象类中
抽象类
- 类里面的成员
  
  a) 属性：与普通类成员属性相同
  
  b) 方法：与普通类成员方法相同
  
  注意：抽象类中允许含有抽象方法（只有方法结构，没有执行体）
  
  c) 块：与普通类成员块相同
  
  d) 构造方法 : 与普通类成员构造方法相同
如何使用创建对象

抽象类含有构造方法但是我们不能通过构造方法直接创建对象

抽象类只能通过子类单继承来做事
类和类的关系

抽象类— 直接单继承 —>抽象类可以

抽象类— 直接单继承 —>具体类可以

具体类— 直接单继承 —>抽象类不可以

模版模式：先混个眼熟，看懂即可

package demo5_21;
// 模版模式：用于解决同一类功能的不同类别，把同一类功能抽象出来作为模版，
// 例如：
//  roboter：补充能量（eat） 工作（work）
//  person ： 吃（eat）     工作（work） (睡觉)sleep
//  pig：     吃（eat）     工作（work）

public abstract class Action {
    public static final int EAT = 1;
    public static final int WORK = 2;
    public static final int SLEEP = 3;
    public void func(int code){
        switch (code){
            case EAT:
                this.eat();
                break;
            case SLEEP:
                this.sleep();
                break;
            case WORK:
                this.work();
                break;
            case EAT+SLEEP+WORK:
                this.eat();
                this.sleep();
                this.work();
                break;
        }
    }
    public abstract void eat();
    public abstract void sleep();
    public abstract void work();
}

// ----------------------------------------------------------------------
package demo5_21;

public class Person extends Action{
    @Override
    public void eat() {
        System.out.println("温文尔雅的吃法");
    }

    @Override
    public void sleep() {
        System.out.println("随性而休");
    }

    @Override
    public void work() {
        System.out.println("自由的工作");
    }
}
// ----------------------------------------------------------------------
package demo5_21;

public class Pig extends Action{
    @Override
    public void eat() {
        System.out.println("🐷的吃法");
    }

    @Override
    public void sleep() {}

    @Override
    public void work() {
        System.out.println("🐷的工作");
    }
}

// ----------------------------------------------------------------------
package demo5_21;

public class roboter extends Action{
    @Override
    public void eat() {
        System.out.println("我要充电了");
    }

    @Override
    public void sleep() {}

    @Override
    public void work() {
        System.out.println("死板的工作");
    }
}

// ----------------------------------------------------------------------
public static void main(String[] args) {
  Action person = new Person();
  Action pig = new Pig();
  Action roboter = new roboter();
  System.out.println("人的功能------------");
  person.func(6);
  System.out.println("猪的的功能------------");
  pig.func(1);
  pig.func(2);
  System.out.println("roboter的功能------------");
  roboter.func(1);
  roboter.func(2);
}

接口

小问题：

抽象类能不能没有抽象方法，全部是具体成员？可以

抽象类能不能没有具体方法，全部是抽象方法？可以 -->抽象类抽象到极致质的变化 – > 接口
接口也是一个类结构 只不过用interface 来修饰替换原来的class
- 成员
  
  i. 属性：不能含有一般属性，只能含有公有的静态常量 public static final
  
  ii. 方法：不能含有一般方法，只能含公有的抽象方法（1.8 版本后，用default修饰具体方法）
  
  iii. 块：没有（静态）块，因为程序块是一个具体的概念
  
  iv. 构造方法：没有构造方法
- 如何使用创建对象
  
  不能创建对象
  
  只能通过子类多实现（implements）来做事
  
  Public class A implements B,C,D{
  
  }
- 与别类的结构关系
  
  接口不能继承别的类最抽象
  
  抽象类 <— 直接多实现—接口类可以
  
  具体类 <— 直接多实现—接口类可以
  
  接口 — 多继承 —接口

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-PJYa8oyv-1621615335219)(file:private/var/folders/tt/db9m7n1d2rs227rwjvr2t7j00000gn/T/com.kingsoft.wpsoffice.mac/wps-macos/ksohtml/wpssVWC09.jpg)]

工厂模式

// 工厂模式： 简单来说就是造同一个标准的对象（通过了类名造对象，而不需要关心如何造出来的）
// 例如： 我需要 面包 ， 火腿，这都属于 食物 标准, 就需要一个食物加工场 不断的造，简单错报的理解

// 统一食物标准
public interface IFood {
    public abstract void get();
}
// 负责生产面包
public class Bread implements IFood{
    @Override
    public void get() {
        System.out.println("给你一个面包");
    }
}
// 负责生产火腿
public class Sausage implements IFood{
    @Override
    public void get() {
        System.out.println("给你一个火腿");
    }
}
// 食品加工场
public class Factor {
    public static IFood getInstance(String className){
        if(className.equals("Bread")){
            return new Bread();
        } else if (className.equals("Sausage")){
            return new Sausage();
        }else {
            return null;
        }
    }
}
public static void main(String[] args){
   IFood bread = Factor.getInstance("Bread");
        IFood sausage = Factor.getInstance("Sausage");
        bread.get();
        sausage.get();
}

代理模式

package demo5_21;
// 代理模式：
// 例子，我想吃饭，但谁来做，我告诉代理人，接下来代理人来准备一切，我只负责吃
// 抽象主题角色：Person
// 具体主题角色：Me
// 代理主题角色：Agent

// 抽象主题角色
public interface Person{
  public abstract void eat();
}
// 具体主题角色
package demo5_21;

public class Me implements Person{
    @Override
    public void eat() {
        System.out.println("我要开始胡吃海喝了");
    }
}

// 代理主题角色
package demo5_21;

public class Agent implements Person{
    Person p;
    public Agent(Person p) {
        this.p = p;
    }

    @Override
    public void eat() {
        this.prepare();
        this.p.eat();
        this.clear();
    }
    public void prepare(){
        System.out.println("准备了一桌子山珍海味");
    }
    public void clear(){
        System.out.println("收拾碗筷");
    }
}
public static void main(String[] args){
  Person me = new Me();
        Person agent = new Agent(me);
        agent.eat();
}