目录
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.效果
在途中可以看到自定义的异常被执行了
.
标签：对之象,java,void,多态,System,class,println,public,out From： https://blog.csdn.net/2301_76862031/article/details/142768967