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()方法进行重写*/@Overridepublic 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{@Overridepublic void eat() {System.out.println("我是鸟，吃虫子");}@Overridepublic 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{@Overridepublic void start() {System.out.println("球类游戏启动");}
}

3）Div类

package org.xiji.myextends.game;public class Div implements Game{@Overridepublic 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 {@Overridepublic void start() {System.out.println("球类游戏开始");}
}/*** 动物类*/
abstract class Animals {public abstract void call();
}class Cats extends Animals {@Overridepublic 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() {@Overridepublic 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.效果

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