多态，抽象，接口，JAVA设计模式_java多态如何访问子类特有的抽象方法,为何没有了public-优快云博客

本文链接：https://blog.youkuaiyun.com/Purple_night_/article/details/128643590

public class Aniaml {
    public Aniaml a(){
        return  null;
    }
}
public class dog extends Aniaml{
    public void bone(){
        System.out.println("狗吃骨头！");
    }
    @Override
    public dog a() {
        return null;
    }
}
public class Cat extends Aniaml {
    public void fish(){
        System.out.println("猫吃🐟！");
    }
}
public class ch01 {
    public void feed(Aniaml aniaml){
        System.out.println("喂养动物");
        //instanceof 用来判断某一个对象是否是某个类的实例。
        if(aniaml instanceof dog) {
            dog dog = (dog) aniaml;//强制转换
            dog.bone();
        }
        if(aniaml instanceof Cat){
            Cat cat=(Cat)aniaml;
            cat.fish();
        }
    }
    public void show(Object o){

    }
    public static void main(String[] args) {
        //多态:一种事物的多种形态！
        Aniaml dog=new dog();
        Aniaml cat=new Cat();
        ch01 ch01=new ch01();
        ch01.feed(dog);
        ch01.feed(cat);
    }
}

关键字instanceof：用来判断某一个对象是否是某一个类的实例。

向上转型：父类父类对象=new 子类；

向上转型有可能丢失子类独有的特性。

向下转型：子类子类对象=（子类）父类对象

向下转型有可能会出现ClassCastException，需要谨慎

我们往往在进行向下转型时，前提是向上转型。

抽象：abstract关键字

类:抽象类中是不是一定要有抽象方法

抽象类结构和普通类中的结构一模一样。

抽象类不能创建对象，不能实例化

方法：需要abstract修饰，没有方法体

抽象方法必须存在于抽象类中。

抽象方法存在的意义：就是被子类实现。

如果一个类继承了一个抽象类，必须重写这个抽象类中的所有抽象方法。或者这个类本身是一个抽象类（很少）

抽象类本身就是被继承的。

抽象类存在的意义就是定规矩。【约定】

匿名实现类

public abstract class ch03 {
    public static void main(String[] args) {
        ch03 ch03=new ch03(){
            @Override
            public void show(String msg) {
                System.out.println("匿名实现类实现的show方法："+msg);
            }
            //匿名实现类

        };
        ch03.show("匿名实现类");
    }
    public abstract  void show(String msg);
}

接口：

抽象方法:可以省略public abstract

常量：可以省略public static final

静态方法:可以省略public

默认方法:可以省略public//除了接口类里，其他类里都放不了

私有方法（JDK9以后）

接口中的所有对外结构必须是public。

静态方法和默认方法 JDK8以后才支持的。

接口的实现是可以多实现的，一个类如果实现了多个接口，必须重写所有接口的抽象方法。

接口和接口之间是多继承

类与类之间是单继承

类与接口之间是多实现

一个类是既可以继承父类，也可以实现接口

面试题：接口与抽象类的区别？

组成。

继承实现。

接口和抽象类均不能进行实例化。

接口和抽象类必须重写所有的抽象方法。

外部类：

这两个类是定义在同一个.java中。就是把两个类写在同一个文件上。开发中不推荐使用。

如果一个类被声明为public class ，就必须单独定义在一个.java文件中，文件名还必须和public class的类名相同

内部类：

为什么要有内部类？

private static class Inner{}

为了健壮性。封装性

在当前类可能有某几个方法或某些属性是需要经常性的调用，考虑使用内部类

面向对象：

封装，继承，多态，抽象

属性，方法，构造器，内部类，代码块

方法，重载，访问权限修饰符

关键字。final static instanceof

Object类是所有“类”的最顶级父类，基本数据类型不是类。数组实际上确实是一个class。数组是可以调用Object类的方法的。

设计模式

单例模式：可以保证系统中，该类的对象有且仅有一个。

具体思路：

别人不能new实例。构造器私有化！！

在该类内部生产一个唯一的对象，并且也封装成private

定义一个静态方法，返回这个唯一的对象。

public class Ch03 {
    private static  Ch03 ch03=new Ch03();
    private Ch03(){

    }
    public static Ch03 getInstance(){
        return ch03;
    }
    public static void main(String[] args) {
        Ch03 ch03=new Ch03();
    }
}

饿汉式

懒汉式

public class Ch03_1 {
    public static Ch03_1 ch031;
    private Ch03_1(){

    }
    public static Ch03_1 getInstance(){
        ch031=new Ch03_1();
        return ch031;
    }
}

JDK8新增的功能箭头函数（Lambda表达式）语法糖

函数式接口：如果一个接口只有一个抽象方法，用一个注解来标识@FunctionalInterface

@FunctionalInterface
public interface Function {
    int plus(int i,int j);
}
public class Client {
    public static void test(Function function){
        System.out.println(function.plus(1,2));
    }

    public static void main(String[] args) {
        test((i, j) -> i+j);
        //小括号包裹形参，数据类型也不要。
        test((i,j)->i*j);
    }
}

小括号包裹形参，数据类型也不要。

第二部分，->指向方法的重写处

如果方法体只有一行代码，大括号可以省略。如果这一行代码是返回值，return省略。

面试题：值传递和引用传递

本质上Java只有值传递，所有的传递都是一次值的拷贝

引用类型引用的是地址，基本数据类型拷贝的是值。不会传入实例对象本身。

所谓的引用传递：实际上就是传递的引用数据类型的地址的值。