extends用于表示两个类之间的继承关系,继承是OOP的四大特性之一,他允许一个类(称之为子类或派送类) 继承另一个类(称之为父类或基类)的变量和方法,子类可以复用父类的方法和变量,也可以添加和覆盖父类的方法和变量
extends 关键字来声明子类继承父类class ParentClass()
{
//父类属性和方法
}
class ChildrenClass extends ParentClass()
{
//子类的属性与方法
}
super关键字来实现class ParentClass
{
public ParentClass()
{
System.out.println("这是父类的无参构造方法");
}
public ParentClass(String str)
{
System.out.println("这是父类的一个带参构造器");
}
}
class ChildrenClass extends ParentClass{
public ChildrenClass()
{
System.out.println("这是子类的无参构造方法");
}
public ChildrenClass(String str){
System.out.println("这是一个子类的带参构造器");
}
public static void main(String[] args) {
ChildrenClass childrendclass = new ChildrenClass();
ChildrenClass childrenclass new ChildrenClass("11");
}
}
ChildrenClass继承了ParentClass 接着再main函数创建ChildrenClass 的无参实例对象时,会先调用父类的无参构造器打印这是父类的无参构造方法,接着再调用子类的无参构造器这是子类的无参构造方法当实例化子类带参构造器时,也会先调用父类的带参构造器这是父类的无参构造方法,接着调用子类的带参构造器这是一个子类的带参构造器
调用了无参构造器构造器,则父类的有参构造器不会被调用, 即每次只会调用一种构造器
super关键字是java中重要的一个引用变量,他主要用于引用当前对象的父类对象,super()实际是调用父类的构造器
super() 调用父类的构造函数,super关键字进行调用class Parent {
int value = 100;
}
class Child extends Parent {
int value = 200;
void display() {
System.out.println("Parent value: " + super.value); //调用父类的value
System.out.println("Child value: " + this.value);
}
}
public class Main {
public static void main(String[] args) {
Child child = new Child();
child.display();
}
}
在子类中可以使用super关键字子访问父类的方法
class Parent {
void display() {
System.out.println("Parent display method");
}
}
class Child extends Parent {
@Override
void display() {
super.display(); // 调用父类的display方法
System.out.println("Child display method");
}
}
public class Main {
public static void main(String[] args) {
Child child = new Child();
child.display();
}
}
override:也称覆盖,重写是子类对父类非静态，非private，非final方法的实现过程进行重新编写, 返回值(JDK7之后,被重写的方法返回值,类型可以不同,但必须有父子关系)和形参都不能改变.即外壳不能改变→重写的核心
子类中的重写方法必须与父类中的被重写方法具有相同的方法名和参数列表,相同的参数列表即意味着,参数类型,数量,顺序都必须相同
void ,则子类重写的方法的返回值必须与父类方法一直public class Animal {
// ... 其他方法 ...
public Animal getAnimal() {
return new Animal(); // 返回一个Animal对象
}
}
public class Dog extends Animal {
// ... 其他方法 ...
// 重写getAnimal方法，但返回更具体的类型Dog
@Override
public Dog getAnimal() {
return new Dog(); // 返回一个Dog对象，它是Animal的子类 也是合法的
}
}
public,protected,默认,private)都不能低于父类方法的访问权限,例如父类中方法是public,则子类中必须是public被final修饰的方法表示该方法不能被覆盖或继承，因此子类不能重写父类中的final方法
严格的文字定义:它允许我们使用父类类型变量来引用子类对象这意味着,当我们对父类类型的变量进行操作时,具体的行为取决于该变量所引用的实际对象的类型
简单的理解:同一个行为具有不同的表现形式,即执行一段代码java在运行中能根据对象产生不同的结果
抽象类也是类,只是具备了一些特殊的性质;抽象类的主要作用是提供了一个模板或是框架,这个模板中定义了一些属性与方法,但是并不需要完全实现这些方法.→相当于你告诉其他类:你们可以按照我的这个模板来创建自己的类,但是你需要实现我未完成的部分;
Animal，它有一个方法eat()。但不同的动物吃东西的方式可能不同，所以eat()方法没有具体的实现。其他类，比如Dog和Cat，可以继承Animal类，然后各自实现自己的eat()方法.abstract类最基本的特点。由于抽象类可能包含没有具体实现的抽象方法，因此不能创建抽象类的实例。只能创建抽象类的非抽象子类的实例abstract修饰的方法不能有具体的方法体，即没有大括号{}和具体的实现代码private、static、final等关键字共用private修饰的方法表示私有，不允许子类访问，而abstract修饰的方法必须被子类覆盖重写才能使用，所以二者矛盾。static关键字修饰的是静态方法，静态方法属于类而不属于实例→属于类，而抽象方法没有具体的实现，需要子类来提供，所以抽象方法不能是静态的。final关键字表示最终的，不可改变的，而抽象方法需要子类来实现，所以不能是final的。// 抽象类 Animal
abstract class Animal {
// 抽象方法
abstract void makeSound();
// 非抽象方法
void eat() {
System.out.println("The animal eats.");
}
// 构造方法
Animal() {
System.out.println("Animal is being constructed.");
}
}
// Dog 类继承自 Animal
class Dog extends Animal {
// 实现从 Animal 继承的抽象方法
@Override
void makeSound() {
System.out.println("The dog barks.");
}
// Dog 类的构造方法
Dog() {
super(); // 调用父类的构造方法
System.out.println("Dog is being constructed.");
}
}
// 主类
public class Main {
public static void main(String[] args) {
// 抽象类不能被实例化
// Animal animal = new Animal(); // 这是错误的
// 创建 Dog 和 Cat 的对象
Dog dog = new Dog();
Cat cat = new Cat();
// 调用方法
dog.eat();
dog.makeSound();
}
}
Animal is being constructed. //父类无参构造器先被调用
Dog is being constructed.
The animal eats.
The dog barks.
接口声明了一组方法(规范),但不关心这些方法(规范)是怎么实现的,任何实现这些接口的类都必须遵循这些方法(规范),但对于具体方法的细节完全由类自身决定.
接口可以看作是一种特殊的类，但接口中所有的方法都是抽象方法（即没有方法体），通常不会写属性;所有的属性都是常量（即使用
public static final修饰
new关键字来创建接口的实例。但是,可以声明接口的引用变量，该变量引用实现该接口的类的实例。public class Dog implements Animal, Runnable { //多实现接口
@Override
public void eat() {
System.out.println("Dog is eating");
}
@Override
public void sleep() {
System.out.println("Dog is sleeping");
}
@Override
public void run() {
System.out.println("Dog is running");
}
}
extends关键字实现。这允许接口之间共享方法的规范// 定义一个父接口
interface ParentInterface {
void method1();
void method2();
int CONSTANT = 10; // 可以在接口中定义常量
}
// 定义一个子接口，继承自ParentInterface
interface ChildInterface extends ParentInterface {
void method3();
}
ChildInterface继承自ParentInterface，因此它自动包含了ParentInterface中定义的所有方法（method1()和method2()）和常量（CONSTANT）。同时，ChildInterface还可以定义自己特有的方法（如method3()）。// 使用接口名.方法名调用
static void 方法名称() {
}
// 可以被子类继承，实例化子类之后调用
default void 方法名称() {
}
implements 关键字实现,接口中所有的方法都是抽象的,即没有方法体extends 关键字实现,抽象类中可以包含抽象方法和非抽象方法