一套网络传输API，本质上，流可以用于网络

黑马程序员全套Java教程_Java基础入门教程，零基础小白自学Java必备教程_哔哩哔哩_bilibili

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-RePAowQP-1647592964116)(java.assets/image-20210716133150883.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Em2fG9DX-1647592964116)(java.assets/image-20210716133321039.png)]

继承就是提取出多个类中共有的属性和方法，然后提取，作为父类。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-eGfyHXBb-1647592964117)(java.assets/image-20210716133402701.png)]

面向对象三大特征：封装、继承、多态。

面向对象的三大基本特征，五大基本原则 - 风之之 - 博客园 (cnblogs.com)

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JjSUkAia-1647592964117)(java.assets/image-20210716133437512.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Hj98dE5E-1647592964117)(java.assets/image-20210716133644804.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Cr1krdB6-1647592964118)(java.assets/image-20210716133635231.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ghtThCgh-1647592964118)(java.assets/image-20210716133728936.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dE5uCvYD-1647592964118)(java.assets/image-20210804003259641.png)]

重写父类方法，需要加override

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wPcyZmSV-1647592964118)(java.assets/image-20210804003412604.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-RzUbjCmI-1647592964119)(java.assets/image-20210804003423094.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-UvDIvjaG-1647592964119)(java.assets/image-20210716133743670.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0BtQuqJm-1647592964119)(java.assets/image-20210716133945350.png)]

【继承的好处】：

• 使子类具有父类的属性和方法，还可以在子类中重新定义，追加方法和属性。

• 子类在访问成员方法和变量的时候，都是一样的顺序，先找子类，再找父类

• 子类重写父类方法的时候，需要加@Override

• 子类根本不可能重写父类的私有方法。

• 子类不可以多继承，但是可以多层继承。

• 比如儿子继承父亲，父亲继承爷爷，即儿子拥有爷爷属性

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OoZgcKkK-1647592964119)(java.assets/image-20210716134318759.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-06EUKikH-1647592964120)(java.assets/image-20210716134418973.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0T3VuGaS-1647592964120)(java.assets/image-20210716134513863.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-l239gMoA-1647592964120)(java.assets/image-20210716134555464.png)]

换个写法：

package demo;

class FU{
    //年龄
    public int age=40;
}
class ZI extends FU{
    public int height = 175;
    public int age=20;
    public void show(){
        int age=30;
        System.out.println(age);
        System.out.println(height);
    }
}

public class DEMO {
    public static void main(String[] args) {
        ZI Z=new ZI();
        Z.show();
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-n9xbftE6-1647592964120)(java.assets/image-20210804103130421.png)]

this代表的本类的成员变量的访问

super可以访问父类中的成员变量

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-UEb1Rz8X-1647592964121)(java.assets/image-20210716135036570.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-uAc4KOzG-1647592964121)(java.assets/image-20210804103900423.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Bg8tgcZK-1647592964121)(java.assets/image-20210804103910976.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-aezjgjtH-1647592964121)(java.assets/image-20210716135302619.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-IFRC1ay1-1647592964122)(java.assets/image-20210716140125577.png)]

父类:

package com.itheima_04;

public class Fu {

    /*
    public Fu() {
        System.out.println("Fu中无参构造方法被调用");
    }
    */

    public Fu() {}

    public Fu(int age) {
        System.out.println("Fu中带参构造方法被调用");
    }

}

子类：

package com.itheima_04;

public class Zi extends Fu {

    public Zi() {
//        super();  这个是默认会有的
//        super(20);
        System.out.println("Zi中无参构造方法被调用");
    }

    public Zi(int age) {
//        super();
//        super(20);
        System.out.println("Zi中带参构造方法被调用");
    }

}

测试类

package com.itheima_04;
/*
    测试类
*/
public class Demo {
    public static void main(String[] args) {
        //创建对象
        Zi z = new Zi();
        Zi z2 = new Zi(20);
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-21uFTJ0Q-1647592964122)(java.assets/image-20210716140536275.png)]

父类：

package com.itheima_05;

public class Fu {

    public void show() {
        System.out.println("Fu中show()方法被调用");
    }

}

子类：

package com.itheima_05;

public class Zi extends Fu {

    public void method() {
        System.out.println("Zi中method()方法被调用");
    }

    public void show() {
        super.show();
        System.out.println("Zi中show()方法被调用");
    }
}

测试类：

package com.itheima_05;

/*
    测试类
 */
public class Demo {
    public static void main(String[] args) {
        //创建对象，调用方法
        Zi z = new Zi();
        z.method();
        z.show();
        //报错
//        z.test();
    }
}

链接：内存过程讲解

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-PTTXYO96-1647592964122)(java.assets/image-20210716140800699.png)]

package com.itheima_06;

/*
    手机类
 */

public class Phone {
    public void call(String name) {
        System.out.println("给" + name + "打电话");
    }
}

重写父类方法的时候，很容易把方法写错，为了帮助大家检验这个东西，添加@Override，这个说明，下面的内容是重写的父类，这个注解，可以帮助我们了解方法声明的准确性

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-KM8Uayts-1647592964122)(java.assets/image-20210716141916000.png)]

package com.itheima_06;

/*
    新手机
 */
public class NewPhone extends Phone {

    /*
    public void call(String name) {
        System.out.println("开启视频功能");
//        System.out.println("给" + name + "打电话");
        super.call(name);
    }
    */

    @Override
    public void call(String name) {
        System.out.println("开启视频功能");
//        System.out.println("给" + name + "打电话");
        super.call(name);
    }

}



package com.itheima_06;
/*
    测试类
 */
public class PhoneDemo {
    public static void main(String[] args) {
        //创建对象，调用方法
        Phone p = new Phone();
        p.call("林青霞");
        System.out.println("--------");

        NewPhone np = new NewPhone();
        np.call("林青霞");
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OJZQEOzs-1647592964123)(java.assets/image-20210716142019150.png)]

子类根本不可能重写父类的私有方法。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-S2FCdQuD-1647592964123)(java.assets/image-20210716142649184.png)]

也就是说，如果父类是“默认”，那么子类就得用public

package com.itheima_07;

public class Fu {

    private void show() {
        System.out.println("Fu中show()方法被调用");
    }

    /*
    public void method() {
        System.out.println("Fu中method()方法被调用");
    }
    */

    void method() {
        System.out.println("Fu中method()方法被调用");
    }
}


package com.itheima_07;

public class Zi extends Fu {

    /*
    @Override
    private void show() {
        System.out.println("Zi中show()方法被调用");
    }
    */

    /*
    @Override
    public void method() {
        System.out.println("Zi中method()方法被调用");
    }
    */

    @Override
    public void method() {
        System.out.println("Zi中method()方法被调用");
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-BO8rxAov-1647592964123)(java.assets/image-20210716142738544.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-iIE3pGuA-1647592964124)(java.assets/image-20210716142812340.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-l8f8mjc7-1647592964124)(java.assets/image-20210716142925606.png)]

但是可以多层继承。

比如儿子继承父亲，父亲继承爷爷，即儿子拥有爷爷属性

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rv8m9JU5-1647592964124)(java.assets/image-20210716143059711.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9KlT1ZGN-1647592964124)(java.assets/image-20210716143133359.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wtGBCo4z-1647592964125)(java.assets/image-20210716143141981.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-fSgK7tNe-1647592964125)(java.assets/image-20210716143156744.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hgLIgX2g-1647592964125)(java.assets/image-20210716143213776.png)]

extend继承，创建一个类的子类

implement是实现，可以实现多个接口

extends与implements的不同

extends是继承父类，只要那个类不是声明为final或者那个类定义为abstract的就能继承，也可以调用父类初始化 this.parent()。而且会覆盖父类定义的变量或者函数。这样的好处是：架构师定义好接口（这里的接口是指父类的成员函数和变量），让工程师实现就可以了。整个项目开发效率和开发成本大大降低。

JAVA中不支持多重继承，但是可以用接口来实现，这样就要用到implements，继承只能继承一个类，但implements可以实现多个接口，用逗号分开就行了。实现父类，子类不可以覆盖父类的方法或者变量。即使子类定义与父类相同的变量或者函数，也会被父类取代掉。

格式：

class A extends B implements C,D,E

一个类通过关键字implements声明自己使用一个或者多个接口。

在类的声明中，通过关键字extends来创建一个类的子类。

class 子类名 extends 父类名 implenments 接口名

{…

}

若同时用到 extends 和 implements 的时候，extends 必须放在 implements 关键字之前。

说的很好：

Java 继承 | 菜鸟教程 (runoob.com)

java只能单继承，不能多继承

1、为什么使用继承

从已有的类派生出新的类，称为继承。

在不同的类中也可能会有共同的特征和动作，可以把这些共同的特征和动作放在一个类中，让其它类共享。

因此可以定义一个通用类，然后将其扩展为其它多个特定类，这些特定类继承通用类中的特征和动作。

继承是 Java 中实现软件重用的重要手段，避免重复，易于维护，易于理解。

super 关键字

super 表示使用它的类的父类。super 可用于：

• 调用父类的构造方法；
• 调用父类的方法（子类覆盖了父类的方法时）；
• 访问父类的数据域（可以这样用但没有必要这样用）。

调用父类的构造方法语法：

super();  

或   

super(参数列表);

注意：super 语句必须是子类构造方法的第一条语句。不能在子类中使用父类构造方法名来调用父类构造方法。 父类的构造方法不被子类继承。调用父类的构造方法的唯一途径是使用 super 关键字，如果子类中没显式调用，则编译器自动将 super(); 作为子类构造方法的第一条语句。这会形成一个构造方法链。

静态方法中不能使用 super 关键字。

调用父类的方法语法：

super.方法名(参数列表);

如果是继承的方法，是没有必要使用 super 来调用，直接即可调用。但如果子类覆盖或重写了父类的方法，则只有使用 super 才能在子类中调用父类中的被重写的方法。

使用 implements 关键字可以变相的使java具有多继承的特性，使用范围为类继承接口的情况，可以同时继承多个接口（接口跟接口之间采用逗号分隔）。

this 和super的区别

this 代表本类对应的引用

Super 代表父亲存储空间的标识(可以理解为父亲引用)可以操作父亲 的成员

使用方法：

A:调用成员变量

·this.成员变量 调用本类的成员变量

·super.成员变量 调用父类的成员变量

B:调用构造方法

·this(…) 调用本类的成员变量

·Super(…)调用父类的成员变量

C:调用成员方法

·this.成员方法 调用本类的成员方法

·super.成员方法 调用父类的成员方法

继承:

public class zi extends fu{

//重写父类方法

}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-iWkzDyWs-1647592964125)(java.assets/image-20210722130822704.png)]

package com.itheima_01;

public class Animal {

    public void eat() {
        System.out.println("动物吃东西");
    }
}


package com.itheima_01;

public class Cat extends Animal {
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}


package com.itheima_01;
/*
    多态：
        同一个对象，在不同时刻表现出来的不同形态

    举例：猫
        我们可以说猫是猫：猫 cat = new 猫();
        我们也可以说猫是动物：动物 animal = new 猫();
        这里猫在不同的时刻表现出来了不同的形态，（猫既是猫，也是动物）这就是多态

    多态的前提和体现
        有继承/实现关系
        有方法重写
        有父类引用指向子类对象
 */
public class AnimalDemo {
    public static void main(String[] args) {
        //有父类引用指向子类对象
        Animal a = new Cat();	//这就体现出多态了
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-QKra4Zrj-1647592964126)(java.assets/image-20210804111331187.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7FJS8QQV-1647592964126)(java.assets/image-20210804111342875.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-eIp7fr5Q-1647592964126)(java.assets/image-20210722131945402.png)]

package com.itheima_02;

public class Animal {

    public int age = 40;

    public void eat() {
        System.out.println("动物吃东西");
    }

}



package com.itheima_02;

public class Cat extends Animal {

    public int age = 20;
    public int weight = 10;

    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }

    public void playGame() {
        System.out.println("猫捉迷藏");
    }

}



package com.itheima_02;

/*
    测试类
 */
public class AnimalDemo {
    public static void main(String[] args) {
        //有父类引用指向子类对象
        Animal a = new Cat();

        System.out.println(a.age);
//        System.out.println(a.weight);

        a.eat();
//        a.playGame();	这个不能调用，会报错

    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LMkVlpVG-1647592964126)(java.assets/image-20210804112209386.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-yDnglFQz-1647592964127)(java.assets/image-20210804112241153.png)]

这就引出了，接下来的多态的好处和弊端了

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jNTB6dHV-1647592964127)(java.assets/image-20210722132828917.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JCF1zH0A-1647592964127)(java.assets/image-20210722135404586.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-gGAReyyT-1647592964127)(java.assets/image-20210722135515202.png)]

其实也是多继承

package com.itheima_03;

public class Animal {

    public void eat() {
        System.out.println("动物吃东西");
    }

}



package com.itheima_03;

/*
    测试类
 */
public class AnimalDemo {
    public static void main(String[] args) {
        //创建动物操作类的对象，调用方法
        AnimalOperator ao = new AnimalOperator();
        Cat c = new Cat();
        ao.useAnimal(c);


        Dog d = new Dog();
        ao.useAnimal(d);


        Pig p = new Pig();
        ao.useAnimal(p);

    }
}



package com.itheima_03;

/*
    动物操作类
 */
public class AnimalOperator {

    /*
    public void useAnimal(Cat c) { //Cat c = new Cat();
        c.eat();
    }

    public void useAnimal(Dog d) { //Dog d = new Dog();
        d.eat();
    }
    */

    public void useAnimal(Animal a) {
        //Animal a = new Cat();
        //Animal a = new Dog();

        a.eat();
//        a.lookDoor();
    }


}



package com.itheima_03;

public class Cat extends Animal {

    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }

}



package com.itheima_03;

public class Dog extends Animal {

    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }

    public void lookDoor() {
        System.out.println("狗看门");
    }

}



package com.itheima_03;

public class Pig extends Animal {

    @Override
    public void eat() {
        System.out.println("猪吃白菜");
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tONNzJpo-1647592964128)(java.assets/image-20210722141145777.png)]

这个可以帮助我们实现使用子类的特有功能

多态中访问成员方法，编译看左边，访问看右边

package com.itheima_04;

public class Animal {

    public void eat() {
        System.out.println("动物吃东西");
    }

}



package com.itheima_04;

/*
    向上转型
        从子到父
        父类引用指向子类对象

    向下转型
        从父到子
        父类引用转为子类对象
 */
public class AnimalDemo {
    public static void main(String[] args) {
        //多态
        Animal a = new Cat(); //向上转型
        a.eat();
//        a.playGame();

        /*
        //创建Cat类的对象
        Cat c = new Cat();
        c.eat();
        c.playGame();
        */

        //向下转型
        Cat c = (Cat)a;
        c.eat();
        c.playGame();
    }
}



package com.itheima_04;

public class Cat extends Animal {

    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }

    public void playGame() {
        System.out.println("猫捉迷藏");
    }

}

多态转型内存图解（对于这种堆和栈，建议看视频）

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-clFLLpxX-1647592964128)(java.assets/image-20210722141946509.png)]

package com.itheima_06;

public class Animal {
    private String name;
    private int age;

    public Animal() {
    }

    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public void eat() {
        System.out.println("动物吃东西");
    }
}




package com.itheima_06;

/*
    测试类
 */
public class AnimalDemo {
    public static void main(String[] args) {
        //创建猫类对象进行测试
        Animal a = new Cat();
        a.setName("加菲");
        a.setAge(5);
        System.out.println(a.getName() + "," + a.getAge());
        a.eat();

        a = new Cat("加菲", 5);
        System.out.println(a.getName() + "," + a.getAge());
        a.eat();

    }
}



package com.itheima_06;

public class Cat extends Animal {

    public Cat() {
    }

    public Cat(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}



package com.itheima_06;

public class Dog extends Animal {

    public Dog() {
    }

    public Dog(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6WqxaY1T-1647592964128)(java.assets/image-20210724110410955.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tUv5EthB-1647592964129)(java.assets/image-20210727154032011.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tzO28Hqr-1647592964129)(java.assets/image-20210727154707886.png)]

package com.itheima_01;

public abstract class Animal {

    /*
    public void eat() {
        System.out.println("吃东西");
    }
    */

    public abstract void eat();
//没有方法体
}



package com.itheima_01;

/*
    测试类
 */
public class AnimalDemo {

    public static void main(String[] args) {
        /*
        Animal a = new Animal();	//抽象类不能创建对象
        a.eat();
        */
    }
    

}

抽象类参照多态的形式创建对象，既然是多态，那么就要有继承，

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-11BqCGXA-1647592964129)(java.assets/image-20210727155345431.png)]

package com.itheima_02;
/*
    抽象类
 */
public abstract class Animal {
    //抽象方法
    public abstract void eat();

    public void sleep() {
        System.out.println("睡觉");
    }

}



package com.itheima_02;

public class Cat extends Animal {

    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}



package com.itheima_02;

public abstract class Dog extends Animal {

}



package com.itheima_02;

/*
    测试类
 */
public class AnimalDemo {
    public static void main(String[] args) {
//        Animal a = new Animal();
        Animal a = new Cat();
        a.eat();
        a.sleep();
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-c0QsVyE8-1647592964130)(java.assets/image-20210727160853553.png)]

package com.itheima_03;

/*
    抽象类
 */
public abstract class Animal {

    private int age = 20;
    private final String city = "北京";

    public Animal() {}

    public Animal(int age) {
        this.age = age;
    }


    public void show() {
        age = 40;
        System.out.println(age);
//        city = "上海";
        System.out.println(city);
    }

    public abstract void eat();

}



package com.itheima_03;

public class Cat extends Animal {

    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}



package com.itheima_03;

/*
    测试类
 */
public class AnimalDemo {
    public static void main(String[] args) {
        Animal a = new Cat();
        a.eat();
        a.show();
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hs166prS-1647592964130)(java.assets/image-20210727161251567.png)]

package com.itheima_04;

public abstract class Animal {
    private String name;
    private int age;

    public Animal() {
    }

    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public abstract void eat();
}



package com.itheima_04;
/*
    测试类
 */
public class AnimalDemo {
    public static void main(String[] args) {
        //创建对象，按照多态的方式
        Animal a = new Cat();
        a.setName("加菲");
        a.setAge(5);
        System.out.println(a.getName()+","+a.getAge());
        a.eat();
        System.out.println("--------");

        a = new Cat("加菲",5);
        System.out.println(a.getName()+","+a.getAge());
        a.eat();4
    }
}



package com.itheima_04;

public class Cat extends Animal {

    public Cat() {
    }

    public Cat(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}


package com.itheima_04;

public class Dog extends Animal {

    public Dog() {
    }

    public Dog(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-BAigApLf-1647592964130)(java.assets/image-20210720092156512.png)]

接口是一种公共的规范，只要符合该规范，都可以使用

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-PdDxsU7K-1647592964130)(java.assets/image-20210720092357218.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-eONtRdOa-1647592964131)(java.assets/image-20210720092411056.png)]

类实现接口，而不是继承接口，所以用implement，而不是extend

接口的实例化，采用多态的形式

抽象类可以不重写

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1kd4D53A-1647592964131)(java.assets/image-20210720094131488.png)]

接口是一个抽象的内容，主要是对行为进行抽象

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-yVmBEzbN-1647592964131)(java.assets/image-20210720095431375.png)]

定义一个接口

package com.itheima_01;
/*
    定义了一个接口
 */
public interface Jumpping {

    //定义了一个抽象方法
    public abstract void jump();

}

实现接口

package com.itheima_01;
//类实现接口
public class Cat implements Jumpping {

    @Override
    public void jump() {
        System.out.println("猫可以跳高了");
    }
}

这个是不想重写jupping中的方法，那么就要继续用abstract关键字，然后这个类就变成了抽象类，抽闲类在实现接口的时候，可以不重写方法，但是其子类在继承的时候，还是要重写接口中的方法

package com.itheima_01;

public abstract class Dog implements Jumpping {
        //如果实现类不想重写jupping中的方法，那么就使用abstract关键字，那么这个类就变成了抽象类，抽象类在实现接口的时候，可以不重写方法，但是其子类在继承的时候，还是要重写接口中的方法
}

测试类，就是用多态的方式，进行实例化，然后

package com.itheima_01;

/*
    测试类
 */
public class JumppingDemo {
    public static void main(String[] args) {
//        Jumpping j = new Jumpping();  //接口不能这样被实例化

        Jumpping j = new Cat(); //采用多态的方式进行实例化，使用他的实现类对象，进行实例化
        j.jump();

    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MaUxGL7i-1647592964131)(java.assets/image-20210727164858726.png)]

接口里面没有成员变量，默认是常量，因为成员变量被final修饰，所以只有常量

接口中的变量是常量

//接口里面不能有构造方法，因为接口主要是对行为进行抽象

所有的类都直接或者间接继承Object类，如果说一个类没有父类，那么object类就是其父类

如果说一个类有父类，那么 这个类就间接的继承Object类

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1K7C2hZP-1647592964132)(java.assets/image-20210727164430458.png)]

因为Object就只有这一个构造方法，所以说，所有的构造方法，默认访问父类的都是无参构造，

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-E7QKvzHJ-1647592964132)(java.assets/image-20210727164659177.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Tql1djM4-1647592964132)(java.assets/image-20210727165120664.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-yAufEwyG-1647592964133)(java.assets/image-20210728001429795.png)]

黑马程序员全套Java教程_Java基础入门教程，零基础小白自学Java必备教程_哔哩哔哩_bilibili

抽象类和接口的区别_dd_Mr的博客-CSDN博客

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-KXMPAEhF-1647592964133)(java.assets/image-20210728221955650.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-azUpKBLL-1647592964133)(java.assets/image-20210728222058063.png)]

当添加报警器后，但不是所有门都有报警器

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rc9NU9qK-1647592964133)(java.assets/image-20210728222151212.png)]

所以说，将接口和抽象类结合起来

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-5SEasdif-1647592964134)(java.assets/image-20210728223539120.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-RJbc22BU-1647592964134)(java.assets/image-20210728231211680.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-RlyDYvwD-1647592964134)(java.assets/image-20210728231430878.png)]

这个案例用了9个文件

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VBf7C1qu-1647592964134)(java.assets/image-20210729004138643.png)]

基本数据类型作为形参和返回值就不讨论了，

主要讨论的是引用类型作为形参和返回值，类，抽象类，接口

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-I3GQUhXj-1647592964135)(java.assets/image-20210729005910150.png)]

1、类名作为方法的形参

方法的形参是类名，其实需要的是该类的对象

实际传递的是该对象的【地址值】

2、类名作为方法的返回值

方法的返回值是类名，其实返回的是该类的对象

实际传递的，也是该对象的【地址值】

package itheima;

class Cat{
    public void eat(){
        System.out.println("猫吃鱼");
    }
}
class CatOperator{
    public void useCat(Cat c){   //Cat c = new Cat()?
        c.eat();
    }
    public Cat getCat(){
        Cat c=new Cat();
        return c;
    }
}

public class CatDemo {
    public static void main(String[] args) {
        //创建操作类对象，并调用方法
        CatOperator co=new CatOperator();
        Cat c=new Cat();
        co.useCat(c);
        Cat c2= co.getCat();    //new Cat()
        c2.eat();
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-fWy4TWd9-1647592964135)(java.assets/image-20210729145729480.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4xWg1qvO-1647592964135)(java.assets/image-20210729010022093.png)]

package itheima2;
//抽象动物类，并创建吃的方法
abstract class Animal{
    public abstract void eat();
}

class Cat extends Animal{
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}

class AnimalOperator{
    public void useAnimal(Animal a){
        //Animal a = new Cat()? 抽象类名作为参数时，需要的是子类作为实参数
        a.eat();
    }

    public Animal getAnimal(){
        Animal a=new Cat();
        return a;
    }
}

public class AnimalDemo {
    public static void main(String[] args) {
        AnimalOperator ao=new AnimalOperator();
        Animal a=new Cat();     //编译看左边，执行看右边
        ao.useAnimal(a);

        Animal a2 = ao.getAnimal(); //new Cat();    这个返回的是个猫对象，如果想要调用吃，那么就得调用猫
        a2.eat();
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-s1J7xbZY-1647592964136)(java.assets/image-20210729151711939.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-IQZoNndT-1647592964136)(java.assets/image-20210729162313148.png)]

package itheima3;

//接口中的成员方法，只能是抽样方法
//public interface Jumpping{
interface Jumpping{
//    public abstract void jump();  //默认修饰符
    void jump();
}

class JumppingOperator{
    public void useJumpping(Jumpping j){
        //形参是个接口，然后这个接口的j可以调用方法jump()，说明这个j是个对象，而接口是不能直接实例化的
        //所以这是按照多态的形式创建的对象，要的是该接口的实现类对象 ，从而有了下面的cat类，用来实现这个接口
        j.jump();
    }
    public Jumpping getJumpping(){
        Jumpping j=new Cat();       //多态的形式创建对象
        return j;   //接口不能实例化，所以，返回的是实现类的 对象
    }
}

class Cat implements Jumpping{
    @Override
    public void jump() {
        System.out.println("猫可以跳高");
    }
}

//接口作为形参和返回值
public class JumppingDemo {
    public static void main(String[] args) {
        //创建操作类对象，并调用方法
        JumppingOperator jo=new JumppingOperator();
        Jumpping j=new Cat();       //多态的形式创建对象
        jo.useJumpping(j);
        Jumpping j2=jo.getJumpping();   //new Cat()
        j2.jump();
    }
}

生活中案例：比如笔记本和cpu，笔记本看作是外部类，cpu看作是内部类

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-sniyx4Dp-1647592964136)(java.assets/image-20210730111627708.png)]

/*
    内部类访问特点： 内部类可以直接访问外部类的成员，包括私有
    外部类要访问内部类的成员，必须创建对象
*/
public class Outer {
    private int num=10;
    //内部类
    public class Inner{
        public void show(){
            System.out.println(num);    //内部类可以直接访问外部类的成员，包括私有
            System.out.println("内部类的函数");
        }
    }
    public void method(){
        Inner i=new Inner();
        i.show();           // 外部类要访问内部类的成员，必须创建对象
    }


package itheima4;
/*
    内部类访问特点： 内部类可以直接访问外部类的成员，包括私有
    外部类要访问内部类的成员，必须创建对象
*/
public class Outer {
    private int num=10;
    //内部类
    public class Inner{
        public void show(){
            System.out.println(num);    //内部类可以直接访问外部类的成员，包括私有
            System.out.println("内部类的函数");
        }
    }
    public void method(){
        Inner i=new Inner();
        i.show();           // 外部类要访问内部类的成员，必须创建对象
    }
    public static void main(String[] args) {
        Outer o =new Outer();
        o.method(); //通过外部类调用内部类的函数
                     //可不可以直接通过内部类调用内部类的函数呢，可以
        Outer myOuter = new Outer();
        Outer.Inner myInner = myOuter.new Inner();
        System.out.println("-------");
        myInner.show();
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-yqg6fFWm-1647592964136)(java.assets/image-20210730111513881.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-iZFx72oW-1647592964137)(java.assets/image-20210730221003757.png)]

成员内部类：是类的成员

局部内部类：就是指在类的方法里面的类

class Outer{
    private int num=10;
    public class Inner{            //成员内部类
        public void show(){
            System.out.println(num);
        }
    }
}

public class InnerDemo {
    public static void main(String[] args) {
        Outer.Inner inner=new Outer().new Inner();
        inner.show();
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2rbEbnQd-1647592964137)(java.assets/image-20210730220013800.png)]

上面的例子，一般来说，是不常见的，因为定义内部类的目的就是为了不让外面轻而易举的看到，所以一般用private修饰内部类，而不用public

一般采用，创建一个外部类方法，然后该方法会创建一个内部类对象，然后用这个方法来调用内部类对象

package itheima6;

class Outer{
    int a=10;
    private class Inner{
        public void show(){
            System.out.println(a);
        }
    }
    public void method(){
        Inner inner=new Inner();
        inner.show();
    }
}
public class InnerDemo {
    public static void main(String[] args) {
        Outer outer=new Outer();
        outer.method();
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3saLiUCZ-1647592964137)(java.assets/image-20210730221259810.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-gRWOveUA-1647592964138)(java.assets/image-20210730222115391.png)]

package itheima6;

class Outer{
    private int num = 20;
    public void method(){
        int num2=20;
        class Inner{
            public void show(){
                System.out.println(num);
                System.out.println(num2);
            }
        }
        Inner i=new Inner();
        i.show();
    }
}

public class OuterDemo {
    public static void main(String[] args) {
        Outer outer=new Outer();
        outer.method();
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MrqkssJt-1647592964139)(java.assets/image-20210730222341956.png)]

我们的类是class开头，但是匿名内部类是new开头的

这个匿名内部类可以是一个类或者是一个接口

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Hi2m9ccm-1647592964139)(java.assets/image-20210731094434707.png)]

匿名内部类，本质是匿名的对象，这个类是抽象类居多

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OKdG4gwL-1647592964139)(java.assets/image-20210731090324824.png)]

示例1

package itheima9;

interface Inter{
    void show();
}

class Outer {
    public void method(){
        //这就是一个匿名内部类
        new Inter(){
            @Override
            public void show() {
                System.out.println("匿名内部类");
            }
        };
    }
}
public class OuterDemo{
    public static void main(String[] args) {
        Outer o=new Outer();
        o.method();
    }
}

不会调用show方法

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-XrDeomNU-1647592964139)(java.assets/image-20210731095734229.png)]

package itheima9;

interface Inter{
    void show();
}

class Outer {
    public void method(){
        //这就是一个匿名内部类
        //这样写仅仅是一个对象
//        new Inter(){
//            @Override
//            public void show() {
//                System.out.println("匿名内部类");
//            }
//        };
//  这样写就是对象调用了方法
      /*  new Inter(){
            @Override
            public void show() {
                System.out.println("匿名内部类");
            }
        }.show();
        //调用两次，就再复制一份
		new Inter(){
            @Override
            public void show() {
                System.out.println("匿名内部类");
            }
        }.show();
      */
    //多次调用的方式    
         Inter i= new Inter(){       //按照多态的形式,这个对象Inter一定是接口的实现类对象或者或者是类的子类对象
            @Override
           public void show() {
                System.out.println("匿名内部类");
            }
        };
        i.show();   //编译看左边，执行看右边
        i.show();   //多次调用
        
    }
}
public class OuterDemo{
    public static void main(String[] args) {
        Outer o=new Outer();
        o.method();
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-oZEJ2a6X-1647592964140)(java.assets/image-20210731100137352.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qUWJKBgT-1647592964140)(java.assets/image-20210731101139957.png)]

如果一个方法的参数是接口名，那么他实际要的是接口的实现类对象，

可以省去一些不需要的对象

package itheima8;
/**
 * 跳高接口
 */
interface Jumpping{
    void jump();
}

/**
 * 实现接口
 */
class Cat implements Jumpping{
    @Override
    public void jump() {
        System.out.println("猫可以跳高");
    }
}

class Dog implements Jumpping{
    @Override
    public void jump() {
        System.out.println("狗可以跳高");
    }
}

/**
 * 接口操作类，里面有一个方法，方法的参数是接口名
 */
class JumppingOperator{
    public void method(Jumpping j){
        j.jump();
    }
}

public class JumppingDemo {
    public static void main(String[] args) {
        //需求：创建接口操作类对象，调用method方法
        JumppingOperator jo=new JumppingOperator();
        Jumpping j=new Cat();
        jo.method(j);

        Jumpping j2=new Dog();
        jo.method(j2);
        //。。。
        //如果有很多动物，那么就很冗余，匿名内部类可以很好的解决
        
        System.out.println("---------");

        //匿名内部类，可以简化操作
        jo.method(  //这个方法要的是一个接口，其实是接口的实现类对象，
                    //而匿名内部类的格式他的本质就是实现类对象，并且是实现了该接口的对象，

          new Jumpping() {      //这个就和猫完全没有关系，把猫删了也可，
              //所以，采用后面这两种形式，不需要多写两个类出来，

            @Override
            public void jump() {
                System.out.println("猫可以跳高");
            }
        }
        );
        jo.method(new Jumpping() {
            @Override
            public void jump() {
                System.out.println("狗可以跳高");
            }
        });
    }
}


package InnerClassDemo;

/**
 * 匿名内部类的本质，就是对接口或者类的实现或者继承
 * 1,定义一个接口,【对于接口来说，如果要实现接口，那么就要实现接口中的所有方法，这样对吗？】
 * 2,实现接口，创建小狗，小猫，实现接口中的方法
 * 3,接口操作类，创建，里面的参数是接口名
 */
interface Jumpping{
    public void jump();
}
class Dog implements Jumpping{
    @Override
    public void jump(){
        System.out.println("小狗跳");
    }
}
class Cat implements Jumpping{
    @Override
    public void jump() {
        System.out.println("小猫跳");
    }
}
class JumppingOperator{
    public void Operator(Jumpping j){
            j.jump();
    }
}
public class AnonymousInnerClass {
    public static void main(String[] args) {
        JumppingOperator jo = new JumppingOperator();
        //如果想要调用接口操作类的方法，就需要一个接口Jumpping的实现类，所以需要传递一个对象
        //但是这个对象可以用匿名内部类来实现，这样就不用频繁创建，狗，猫等对象
        Jumpping j=new Cat();
        Jumpping j1=new Dog();

        jo.Operator(j);
        jo.Operator(j1);

        /**
         * 匿名内部类本质上是对接口或者类的实现或者继承
         */

        jo.Operator(new Jumpping() {
            @Override
            public void jump() {
                System.out.println("匿名内部类之实现狗蹦");
            }
        });

        jo.Operator(new Jumpping() {
            @Override
            public void jump() {
                System.out.println("匿名内部类之实现猫跳");
            }
        });
    }
}

/**
 * 匿名内部类的好处：不用频繁创建类和对象，对于一些需要传值的东西，直接写即可。
 */

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1QnsFJbZ-1647592964140)(java.assets/image-20210917180205982.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-J8aSKNyM-1647592964141)(java.assets/image-20210626222755435.png)]