java面向对之象类的继承与多态

目录

1.类的继承

图解

案例:创建一个动物类和一个猫类

1.代码

1)动物类

2)猫类

3.测试类

2.效果

2.父类方法的重写

案例:如何重写父类的方法

1.代码

1）Animal类

2）Dog类

3）测试类

2.效果

3.super关键字

案例:如何在子类中调用父类的方法,或属性

1.代码

1）Animal类

2)bird类

3）测试类

2.效果

4.final关键字

5.抽象类

案例:定义一个抽象类

1.代码

2.效果

6.接口

案例:定义一个接口

1)代码

1.接口

2.接口实现类

3.测试类

2)效果

7.多态

案例:游戏接口实现类

1.代码

1）Game接口

2）Ball

3）Div类

4）测试类

2.效果

8.对象类型的转换

案例:子类转换成父类

1.代码

2.效果

案例:父类转化成子类

注:

1.代码

2.效果

9.instanceof关键字

案例:使用instanceof判断类

1.代码

2.效果

10.Object类

案例:测试一个类是否含toString和hashCode

1.代码

2.效果

11.成员内部类

案例:内部外部类相互访问

1.代码

2.效果

注:外部类创建内部类

12.局部内部类

案例:局部内部类

1.代码

2.效果

13.静态内部类

案例：静态内部类

1.代码

2.效果

14.匿名内部类

案例:匿名内部类

注:本质

1.代码

2.效果

15.try..catch和finally

案例：处理0/1异常

1.代码

2.效果

16.throws关键字

案例:1/0异常抛出

1.代码

2.效果

17.自定义异常类

案例:自定义1/0异常处理

1.代码

2.效果

1.类的继承

定义：类的继承是指一个类（子类）可以继承另一个类（父类）的属性和方法。
语法：class SubClass extends SuperClass { ... }
特点：
- 子类可以重写或添加新的方法和字段。
- 继承是单继承，即一个子类只能有一个直接父类。
- Java中的所有类都默认继承自Object类。

图解

案例:创建一个动物类和一个猫类

1.代码

1)动物类

package org.xiji.myextends;

/**
 * 这是一个动物类
 */
public class Animal {
    private String name;
    private int age;

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

    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;
    }
}

2)猫类

/**
 * 动物类
 */
public class Cat extends Animal{

}

3.测试类

package org.xiji.myextends;



public class MyExtendsTest {


    public static void main(String[] args) {
        Cat cat = new Cat();

        System.out.println("猫吃-----------");
        cat.eat();
        System.out.println("猫叫-----------");
        cat.call();
    }

}

2.效果

可以看到Cat类中并没有写任何的方法，但是继承了Animal类，便拥有了父类中所有的方法和属性

2.父类方法的重写

定义：当子类需要提供特定实现时，可以重写从父类继承的方法。
语法：在子类中使用相同的方法签名，并加上@Override注解（可选但推荐）。
特点：
- 方法签名必须与父类中被重写的方法一致。
- 访问权限不能比父类更严格。
- 使用super.methodName()可以在子类中调用父类的方法。

案例:如何重写父类的方法

注:类还是使用上面的那个类

1.代码

1）Animal类

package org.xiji.myextends;

/**
 * 这是一个动物类
 */
public class Animal {
    private String name;
    private int age;

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

    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;
    }
}

2）Dog类

package org.xiji.myextends;

public class Dog extends Animal{

    /**
     * 这只动物是条狗，我们对叫声不满意，需要改为汪汪汪
     * 
     * ctrl+o 键  ======》  在新的界面中选中call()方法进行重写
     */

    @Override
    public void call() {
        System.out.println("汪汪汪");
    }
}

3）测试类

package org.xiji.myextends;

public class MyOverride {
    public static void main(String[] args) {
        Dog dog = new Dog();

        System.out.println("狗狗叫");
        dog.call();
    }
}

2.效果

3.super关键字

用途：引用当前对象的直接父类对象。
常见用法：
- 调用父类的构造方法：super(); 或 super(param1, param2);
- 调用父类的方法：super.methodName();
- 访问父类的变量：super.variable;

案例:如何在子类中调用父类的方法,或属性

1.代码

1）Animal类

package org.xiji.myextends;

/**
 * 这是一个动物类
 */
public class Animal {
    private String name;
    private int age;
    

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

    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;
    }
}

2)bird类

package org.xiji.myextends;

/**
 * 这是鸟类
 */
public class Bird extends Animal
{
    /**
     * supper  调用父类的方法  或属性
     */

    public void birdCall(){
        //调用父类的call方法
        super.call();
        //调用父类的属性，因为这里是父类私有的我们无法访问
        System.out.println("我是鸟，我的名字叫"+super.getName()+"叽叽喳喳");


    }

    public void birdName(String name){
        //调用父类的setName方法  设置动物名字
        super.setName(name);
    }
}

3）测试类

package org.xiji.myextends;

public class MyBridTest {
    public static void main(String[] args)
    {
        Bird bird = new Bird();
        bird.birdName("小黄");

        System.out.println("鸟叫");
        bird.birdCall();
    }
}

2.效果

4.final关键字

用途：
- 声明常量（不可变的变量）：final int MAX = 100;
- 防止类被继承：final class MyClass { ... }
- 防止方法被重写：final void myMethod() { ... }
- 防止局部变量被修改：final int x = 10;

5.抽象类

定义：抽象类是不能实例化的类，通常包含一个或多个抽象方法。
语法：abstract class MyAbstractClass { ... }
特点：
- 可以有抽象方法（没有方法体的方法）。
- 可以有具体的方法实现。
- 子类必须实现所有的抽象方法才能被实例化，除非子类也是抽象类。

案例:定义一个抽象类

1.代码

package org.xiji.myextends;

public abstract class Food {


    /**
     * 菜名
     */
    private String name;

    /**
     * 使用abstract关键字修饰可以不在本类中实现
     * 默认为抽象方法
     * 食物的类型
     */
    public abstract void foodEatStyle();

    /**
     * 菜的吃法  也是可以实现的
     */
    public  void foodEat(){
        System.out.println("正在吃食物："+ this.name + "...");
    };
}

2.效果

6.接口

定义：接口是一种完全抽象的类，它只包含方法签名，不包含方法体。
语法：interface MyInterface { ... }
特点：
- 所有方法默认是public和abstract。
- 从Java 8开始，可以有默认方法和静态方法。
- 一个类可以实现多个接口：class MyClass implements Interface1, Interface2 { ... }

案例:定义一个接口

1)代码

1.接口

package org.xiji.myextends;

public interface MyInterface {
    /**
     * 定义抽象方法eat()
     */
    public void eat();

    /**
     * 定义抽象方法call()
     */
    public void call();

    /**
     * 接口通过  implements 关键字实现
     */
}

当我们需要实现接口是需要使用implements关键字,否则会报错，如下图

2.接口实现类

package org.xiji.myextends;

public class MyInterfaceImpl implements MyInterface{
    @Override
    public void eat() {
        System.out.println("我是鸟，吃虫子");
    }

    @Override
    public void call() {

        System.out.println("我是鸟，叽叽喳喳");
    }
}

3.测试类

package org.xiji.myextends;

public class MyIntefaceTest {
    public static void main(String[] args) {
        MyInterfaceImpl myInterface = new MyInterfaceImpl();

        myInterface.call();

        myInterface.eat();
    }
}

2)效果

7.多态

定义：多态性允许你使用统一的接口来表示不同的类型。
形式：
- 编译时多态（方法重载）
- 运行时多态（方法重写）
特点：
- 提供了代码的灵活性和扩展性。
- 通过向上转型（将子类转换为父类类型）来实现。

案例:游戏接口实现类

1.代码

1）Game接口

package org.xiji.myextends.game;

/**
 * 定义游戏接口
 */
public interface Game {

    /**
     * 游戏启动
     */
    void start();


}

2）Ball

package org.xiji.myextends.game;

public class Ball implements Game{
    @Override
    public void start() {
        System.out.println("球类游戏启动");
    }
}

3）Div类

package org.xiji.myextends.game;

public class Div implements Game{
    @Override
    public void start() {
        System.out.println("自定义游戏启动");
    }
}

4）测试类

package org.xiji.myextends.game;

public class GameTest {
    public static void main(String[] args) {
        Ball ball = new Ball();

        Div div = new Div();

        div.start();

        ball.start();
    }
}

2.效果

8.对象类型的转换

向上转型：自动进行，例如Parent p = new Child();
向下转型：需要显式转换，例如Child c = (Child) p;
安全检查：使用instanceof关键字确保转换安全。

案例:子类转换成父类

注:

1.父类类型  名称 = new 子类类型()|| 父类类型  名称 = 子类实例

2.子类转化为父类之后，调用的方法是重写之后的方法

1.代码

package org.xiji.myextends;

public class MyTestOne {
    public static void main(String[] args) {
        //子转父类
        Cat1 cat1 = new Cat1();

        cat1.call();

        System.out.println("父类类型  名称 = new 子类类型()|| 父类类型  名称 = 子类实例");
        System.out.println("子类转换成父类");
        Animal1 animal1 = cat1;
        animal1.call();
        System.out.println("子类转化为父类之后，调用的方法是重写之后的方法");
    }

}
class  Animal1{
    public void call(){
        System.out.println("Animal call");
    }
}

class Cat1 extends Animal1{
    public void call(){
        System.out.println("猫:喵喵喵。。。。。。。");
    }
}

2.效果

案例:父类转化成子类

注:

1)父类转换成子类的实质就是父类类型在内存中指向的子类实例对象，虽然是父类对象，但是对象引用是子类实例化对象

2) 如果是父类对象实例，则无法向下实例化

1.代码

package org.xiji.myextends;

public class MyTestTwo {
    public static void main(String[] args)
    {
        System.out.println("父类转化成子类");
        System.out.println("父类类型 名称 = 子类实例  ====> 子类类型  名称2  =  (子类类型) 父类对象");
        Animal2 animal2 = new Dog3();
        animal2.call();
        Dog3 dog3 = (Dog3) animal2;
        dog3.call();
        System.out.println("====================================================");
        System.out.println("父类转换成子类的实质就是  父类类型在内存中指向的子类实例对象，虽然是父类对象，但是对象引用是子类实例化对象");
        System.out.println("如果是父类对象实例，则无法向下实例化");
        Animal2 animal21 = new Animal2();
        Dog3  dog5 = (Dog3) animal21;
        dog5.call();
    }

}

class Animal2{
    public void call()
    {
        System.out.println("Animal call");
    }
}

class Dog3 extends Animal2{
    public void call()
    {
        System.out.println("狗的叫声:汪汪汪汪...........");
    }
}

2.效果

9.instanceof关键字

用途：检查对象是否是某个类或其子类的实例。
语法：if (obj instanceof ClassName) { ... }
对象实例化 instanceof 类(接口)

案例:使用instanceof判断类

1.代码

package org.xiji.myextends;

public class MyTestThree {
    public static void main(String[] args) {
        System.out.println("多态性");
        Ball ball = new Ball();
        ball.start();

        Cats cats = new Cats();
        cats.call();
        //使用instanceof关键字判断是否为同一类型

        if (cats instanceof Cats) {
            System.out.println("是猫");
        } else {
            System.out.println("不是猫");
        }
        if (ball instanceof Ball) {
            System.out.println("是球类游戏");
        }



    }
}


interface Game {
    void start();
}

class Ball implements Game {

    @Override
    public void start() {
        System.out.println("球类游戏开始");
    }
}

/**
 * 动物类
 */
abstract class Animals {
    public abstract void call();
}

class Cats extends Animals {

    @Override
    public void call() {
        System.out.println("猫:喵喵喵喵喵..........");
    }
}

2.效果

10.Object类

定义：所有类的根类，每个类都隐式地继承自Object类。
常用方法：
- toString()
- equals(Object obj)
- hashCode()
- getClass()
- clone()
- finalize()

案例:测试一个类是否含toString和hashCode

1.代码

package org.xiji.myextends;

public class ObjectTest {
    public static void main(String[] args) {
        Cat cat = new Cat();
        System.out.println(cat.toString());
        /**
         * 判断是否属于 Object
         */
        System.out.println("判断是否属于 Object");
        System.out.println(cat instanceof Object);

        System.out.println("Object的hashCode");
        System.out.println(cat.hashCode());
        System.out.println("Object的toString");
        System.out.println(cat.toString());


    }
}

2.效果

11.成员内部类

定义：定义在另一个类内部的类，可以访问外部类的所有成员。
语法：public class OuterClass { public class InnerClass { ... } }
特点：
- 拥有外部类的引用。
- 可以访问外部类的私有成员。

案例:内部外部类相互访问

1.代码

package org.xiji.myextends;

public class MyOutAnInner {
    public static void main(String[] args) {
        Outer outer = new Outer();
        //外部类调用内部类的方法
        outer.showOutUseInner();
        //创建内部类实例 调用外部方法
        System.out.println("==================");
        Outer.Inner inner  =  outer.new Inner();

        inner.showIn();
    }
}
class Outer {
    private int m = 10;

    public void showOut()
    {
        System.out.println("外部类方法被调用");
    }

    class Inner {
        private int a = 20;

        public void showIn()
        {
            System.out.println("内部类方法被调用");
            System.out.println("内部类变量a = " + a);
            System.out.println("外部类变量a = " + m);
            showOut();
        }
    }

    public void showOutUseInner(){
        System.out.println("外部类调用内部类方法");
        Inner inner = new Inner();
        inner.showIn();
    }
}

2.效果

注:外部类创建内部类

外部类名.内部类名名字 = new 外部类类型().new 内部类类名();

12.局部内部类

局部内部类

定义：定义在方法、构造器或初始化块内的类。
语法：void someMethod() { class LocalInnerClass { ... } }
特点：
- 只能在定义它的方法或块内使用。
- 可以访问最终局部变量。

案例:局部内部类

1.代码

package org.xiji.myextends;

public class MyOutFunctionClass {
    public static void main(String[] args) {
        MyOutClass myOutClass = new MyOutClass();
        myOutClass.out();
        System.out.println("局部内部类也成为方法内部类，只能在方法中使用");
    }

}
class MyOutClass {

    public void out()
    {
        //定义方法内部类
        class MyInnerClass {

            public void inner()
            {
                System.out.println("这是内部类");
            }
        }

        MyInnerClass myInnerClass = new MyInnerClass();
        //调用方法
        myInnerClass.inner();
    }
}

2.效果

13.静态内部类

定义：使用static修饰符的内部类，不依赖于外部类的实例。
语法：public class OuterClass { public static class StaticNestedClass { ... } }
特点：
- 可以直接通过外部类名访问。
- 不能访问外部类的非静态成员。
- 静态内部类访问外部静态成员可以是方法或属性

案例：静态内部类

1.代码

package org.xiji.myextends;

public class MyInnerStaticClass {
    public static void main(String[] args) {
        MyOuter.MyInner inner = new MyOuter.MyInner();
        inner.print();
    }
}
class MyOuter{
    static String name = "Outer";

    //静态内部类
    static class MyInner{
        /**
         * 通过内部静态类访问外部静态属性
         */
        public void print(){
            System.out.println("MyOuter.name = " + name);
        }
    }
}

2.效果

14.匿名内部类

定义：没有名字的内部类，通常用于创建一次性使用的类实例。
语法：new SomeInterface() { ... }
特点：
- 只能继承一个父类或实现一个接口。
- 不能有构造方法。

案例:匿名内部类

注:本质

方法中传递的参数是接口类型，必要要实现接口，才能完成调用

1.代码

package org.xiji.myextends;

public class MyUnNameClass {
    public static void main(String[] args) {
        test(new Catss() {
            @Override
            public void call() {
                System.out.println("我是匿名内部类");
                System.out.println("喵喵喵");
            }
        });
    }

    public static void test(Catss catss) {

        catss.call();
    }
}

interface Catss{
    void call();
}

2.效果

15.try..catch和finally

用途：处理程序运行过程中可能出现的异常。

语法：

try {
    // 可能抛出异常的代码
} catch (ExceptionType1 e1) {
    // 处理ExceptionType1
} catch (ExceptionType2 e2) {
    // 处理ExceptionType2
} finally {
    // 无论是否发生异常都会执行的代码
}

案例：处理0/1异常

1.代码

package org.xiji.myextends;

public class MyZero {
    public static void main(String[] args) {

        try {
            System.out.println(1/0);
            System.out.println("我被执行了");
        } catch (Exception e) {
            System.out.println("catch被执行了");
            System.out.println(e);
        }
        finally {
            System.out.println("finally被执行了");
        }
    }
}

2.效果

16.throws关键字

用途：声明方法可能抛出的异常。
语法：public void someMethod() throws ExceptionType { ... }

public static void test () throws Exception

案例:1/0异常抛出

1.代码

package org.xiji.myextends;

public class MyZeroByThrow {
    public static void main (String[] args) throws Exception {
        test();

    }
    public static void test () throws Exception
    {
        System.out.println(1/0);
    }
}

2.效果

17.自定义异常类

定义：继承自Exception或其子类，用于创建特定业务逻辑的异常。

语法：

public class MyCustomException extends Exception {
    public MyCustomException(String message) {
        super(message);
    }
}

特点：
- 可以携带额外的信息。
- 可以有特定的处理逻辑。

注:通过throw关键子抛出自定义异常

案例:自定义1/0异常处理

1.代码

package org.xiji.myextends.ex;

public class Test {
    public static void main(String[] args) throws MyZeroEx {

        try {
            System.out.println(1 / 0);
        } catch (Exception e) {
            throw new MyZeroEx("这是我的自定义的异常");
        }
        finally {
            System.out.println("finally被执行了");
        }

    }
}

2.效果

在途中可以看到自定义的异常被执行了