您的位置: 首页  >  文章  >  Java面向对象关键字、继承、多态、接口

Java面向对象关键字、继承、多态、接口

分类: 文章 • 2022-11-07 14:11:55

一、关键字

final和static

final关键字可以修饰成员变量、方法、类，修饰后相当于不可变，无法被重新赋值、重写、继承
static关键字可以修饰成员变量和方法，修饰成员之后被放在类的堆内存中，被修饰的成员和方法可以通过类名.成员名/方法名直接调用

public、private、protected、default

这是用来处理公开私密关系的关键字
Java面向对象关键字、继承、多态、接口

extends、interface、implements

这是用来处理声明继承关系、声明接口、声明实现接口的关键字

class star extends Math                //声明star继承Math
 interface star                        //声明star为接口
class star implements Math             //声明star为接口Math的实现类

abstract

使用 abstract 关键字修饰方法，该方法就成了抽象方法，抽象方法只包含一个方法名，而没有方法体。
继承抽象类的子类必须重写父类所有的抽象方法。否则，该子类也必须声明为抽象类。最终，必须有子类实现该父类的抽象方法，否则，从最初的父类到最终的子类都不能创建对象，失去意义。

  1. 抽象类不能创建对象，如果创建，编译无法通过而报错。只能创建其非抽象子类的对象。
    理解：假设创建了抽象类的对象，调用抽象的方法，而抽象方法没有具体的方法体，没有意义。
  2. 抽象类中，可以有构造方法，是供子类创建对象时，初始化父类成员使用的。
    理解：子类的构造方法中，有默认的super()，需要访问父类构造方法。
  3. 抽象类中，不一定包含抽象方法，但是有抽象方法的类必定是抽象类

super、this

这是在类中处理应用关系的关键字
super ：代表父类的存储空间标识(可以理解为父亲的引用)。
this ：代表当前对象的引用(谁调用就代表谁)

public class Math {
    //finnl修饰，不可改变值
    final int nnum=100;
    //static修饰，为类变量
    static int nsum=0;

    int n;
    public Math(){
        System.out.println("无参数构造方法");
    }
    public Math(int n){
        //编译器报错，numn已经被final修饰，为不可变变量,被static修饰是可以变化的
        //this.nnum=n;
        this.n=n;
        System.out.println("含参构造函数");
    }

    public void show(){
        System.out.println("这是数学方法");
    }
    public void display(String name){
        System.out.println("数学还有一个称呼"+name);
    }
}

class star extends Math{
    int n3;
    //此处继承父类构造方法，需要传递给父类构造函数
    public star(int n2,int n3){
        super(n2);
        //将传入构造函数的变量给当前对象的全局变量
        this.n3=n3;
    }
    public void play(){
        System.out.println("这是用来演示this的一个方法");
    }
    public void show(){
        //无参数父类引用
        super.show();
        //无参数当前对象应用
        this.play();
    }
    public void display(String name){
        //含参数父类对象引用
        super.display(name);
    }
}

Java面向对象关键字、继承、多态、接口

二、继承、多态、抽象类、内部类

继承

子类可以继承父类中所有未被private关键字保护的属性、方法，以此达到复用
子类可以重写父类方法，也可以有自己的方法
子类中可以使用super关键字调用父类属性、方法

多态

多态定义： 是指同一行为，具有多个不同表现形式

体现一：重载

同一方法有多种形式，参数不同实现不同

 public Math(){
        System.out.println("无参数构造方法");
    }
    public Math(int n){
        System.out.println("含参构造函数");
    }
     public Math(int n，int s){
        System.out.println("这也是含参构造函数");
    }

体现二：数据类型引用执行子类方法

父类类型 对象名 = new 子类类型（）；
变量名.方法名()；

当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误；如果有，执行的是子类重写后方法。
类型为父类，使用子类方法

封装类
//父类
public abstract class Animal {
	public abstract void eat(){
		System.out.println("吃瓜");
	}
}
//子类Cat
class Cat extends Animal {
	public void eat() {
			System.out.println("吃鱼");
		}
}
//子类Dog
class Dog extends Animal {
	public void eat() {
			System.out.println("吃骨头");
		}
}
测试类
public class Test {
public static void main(String[] args) {
		// 多态形式，创建对象
		Animal a1 = new Cat();
		// 调用的是 Cat 的 eat
		a1.eat();
		// 多态形式，创建对象
		Animal a2 = new Dog();
		// 调用的是 Dog 的 eat
		a2.eat();
	}
}

体现三：数据类型引用参数传递

实际开发的过程中，父类类型作为方法形式参数，传递子类对象给方法，
进行方法的调用，更能体现出多态的扩展性与便利。

public class Test {
	public static void main(String[] args) {
		// 多态形式，创建对象
		Cat c = new Cat();
		Dog d = new Dog();
		// 调用showCatEat
		showCatEat(c);
		// 调用showDogEat
		showDogEat(d);
		showAnimalEat(c);
		showAnimalEat(d);
	}
public static void showCatEat (Cat c){
		c.eat();
}
public static void showDogEat (Dog d){
		d.eat();
}
/*
以上两个方法, 均可以被showAnimalEat(Animal a)方法所替代
而执行效果一致
*/
public static void showAnimalEat (Animal a){
		a.eat();
	}
}

抽象类

关键字abstract已经说明

abstract

内部类

类的内部中的类

Java面向对象关键字、继承、多态、接口

三、接口

概述：

接口，是Java语言中一种引用类型，是方法的集合，如果说类的内部封装了成员变量、构造方法和成员方法，那么接口的内部主要就是封装了方法，包含抽象方法（JDK 7及以前），默认方法和静态方法（JDK 8），私有方法（JDK 9）
接口的定义，它与定义类方式相似，但是使用 interface 关键字。它也会被编译成.class文件，但一定要明确它并不是类，而是另外一种引用数据类型。

引用数据类型：数组，类，接口。

接口的使用，它不能创建对象，但是可以被实现（ implements ，类似于被继承）。一个实现接口的类（可以看做是接口的子类），需要实现接口中所有的抽象方法，创建该类对象，就可以调用方法了，否则它必须是一个抽象类

格式

public interface 接口名称 {
// 抽象方法
// 默认方法
// 静态方法
// 私有方法
}

实现

类与接口的关系为实现关系，即类实现接口，
该类可以称为接口的实现类，也可以称为接口的子类。
实现的动作类似继承，格式相仿，只是关键字不同，实现使用 implements 关键字。
非抽象子类实现接口：
1. 必须重写接口中所有抽象方法。
2. 继承了接口的默认方法，即可以直接调用，也可以重写。

私有方法：只有默认方法可以调用。
私有静态方法：默认方法和静态方法可以调用。

接口

public interface Person {
    //抽象方法
    public abstract void marry();
    //静态方法
    public static void speak(){
        System.out.println("人类都会吃饭");
    }
    //默认方法
    public default void run(){
        System.out.println("The people run!");
    }
}

实现

public class People implements Person {
    //此处写构造方法
    People(String name){
        System.out.println("我的名字是"+name);
    }
    public void eat(){
        System.out.println("我只负责吃！");
    }
    //此处重写抽象类
    public void marry(){
        System.out.println("不是所有人都想结婚的!");
    }
    //此处可以重写,也可以继承

}

相关推荐