面向对象特征——封装、继承、多态、方法的重写、抽象类、final关键字、接口

本文详细介绍了Java面向对象的几个核心特性：封装、继承、多态，以及方法的重写、抽象类、final关键字和接口的使用。封装通过访问控制实现信息隐藏；继承提供了代码复用和扩展性；多态允许同一种类型在不同场景下表现出不同行为。此外，还讨论了方法重写、抽象类、final关键字的规则及其在实际编程中的应用，并阐述了接口在实现多继承逻辑中的重要性。

1、面向对象特征——封装

封装：将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问。
封装的优点
- 只能通过规定方法访问
- 隐藏类的实现细节
- 方便加入控制语句
- 方便修改实现
具体表现
- 使用不同的访问权限

public class Demo1 {
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

Dog封装案例

/*
    封装：将类的某些信息隐藏起来（用到访问权限修饰符来实现），不让外部直接访问，
    可以通过一个特定的方法进行访问，便于控制。
 */
public class Dog {

    private String name;

    public Dog() {

    }

    public Dog(String name) {
        if (name != null) {
            this.name = name;
        }
    }

    public void eat() {

    }

    //提供特定的方法，对隐藏的成员进行访问
    public void setName(String name) {
        if (name != null) {
            this.name = name;
        }
    }

    public String getName() {
        return name;
    }
}

public class TestDog {
    public static void main(String[] args) {
        Dog dog = new Dog("金毛");
        //dog.name = "金毛";//直接访问类的成员
        Dog dog1 = new Dog();
        dog1.setName("柯基");
        System.out.println(dog.getName());
        System.out.println(dog1.getName());
    }
}

WindowDemo单例模式案例

public class WindowDemo {

    /*
        设计模式：解决某一类问题的解决方案（模式）
        单例模式：让一个类在一个程序中只能创建一个对象
        将构造方法设置为私有权限，在其他类中不能随便使用
     */

    private static WindowDemo windowDemo;

    private WindowDemo() {

    }

    public static WindowDemo getWindow() {
        if (windowDemo == null) {
            windowDemo = new WindowDemo();
        }
        return windowDemo;
    }
}

public class TestWindow {

    public static void main(String[] args) {
        //new WindowDemo();
        //new WindowDemo();

        WindowDemo windowDemo = WindowDemo.getWindow();
        WindowDemo windowDemo1 = WindowDemo.getWindow();
        System.out.println(windowDemo);
        System.out.println(windowDemo1);
    }
}

在这里插入图片描述

2、面向对象特征——继承

继承：继承是面向对象程序设计不可缺少的设计思想，是实现代码可重用的根基，是提高代码可扩展性的主要途径。
继承是从已有的类中派生出新的类，新的类能吸收已有类的属性和行为，并能扩展新的能力。
- 在JAVA中使用extends关键字来表示继承关系。
- JAVA不支持多继承，单继承使JAVA的继承关系很简单，一个类只能有一个直接父类。
- 继承之后子类可以调用父类的所有非私有属性和非私有方法。
- 符合is-a关系的设计,使用继承。
- 将子类共有的属性和行为放到父类中。
- 继承是代码重用的一种方式
继承的形式：

[访问权限修饰符][修饰符] 子类名 extends 父类名{
	子类体
}

public class Animal {
    public void eat() {
    }
}

public class Dog extends Animal {
    public void play() {
    }
}

子类对象可以直接调用父类的方法，强调复用性。

Dog dog = new Dog();
dog.eat();

Dog类是Animal类的子类, Animal类是Dog类的父类；
Dog类是 Animal类的派生类,Animal类是Dog类的基类。

继承的传递性
- C类从B类继承,B类又从A类继承，那么C类就具有B类和A类的所有非私有属性和非私有方法，当一个没有继承任何一个类时，jvm会默认让类继承Object类，Object是java为所有类提供的基类。
继承中的构造方法
- 子类构造方法会先调用父类构造方法；
- 使用super关键字调用父类任意一个构造方法,必须写在构造方法的第一行；
- 如果子类的构造方法中没有显式地调用基类构造方法，则系统默认调用基类无参数的构造方法。
super关键字用途
- 用super关键字访问父类成员；
- 用super.成员变量名来引用父类成员变量；
- 用super.方法名（参数列表）访问父类的方法。
- 用super.构造方法(参数列表)访问父类构造方法
  注意：: 不要把super误认为是父类对象.在创建子类对象时，不会创建父类对象。只会将父类中的信息加载到子类对象中存储。

Animal父类：

/*
    动物类 -- 基类(父类)
    当一个类没有显示的继承某个类,那么这个类默认继承Object,Object这个类是所有类的基类
 */
//public class Animal extends Object{
public class Animal {
    //成员变量
    private String name;
    private int age;

    //构造方法
    public Animal() {
        super();
        System.out.println("Animal类中的无参构造方法");
    }

    public Animal(String name) {
        super();
        this.name = name;
        System.out.println("Animal类中的有参构造方法");
    }

    //成员方法,是类的功能
    public void eat() {
        System.out.println("动物吃东西");
    }

    //为私有属性对外提供的操作入口
    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;
    }
}

Dog子类继承父类Animal：

/*
   狗是动物,  狗是子类(派生类)
   狗类继承动物类,使用extends关键字
   一个类只能直接继承一个父类,继承后子类就可以使用父类中非私有的成员
   在子类中可以扩展子类特有的属性和方法
 */
public class Dog extends Animal {

    private String color;

    public Dog() {
        super();
        System.out.println("狗类中的无参构造方法");
    }

    public Dog(String name) {
        super(name);
        System.out.println("狗类中的有参构造方法");
    }

    public void play() {
        System.out.println("狗会玩");
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }
}

XiaoTianQuan子类继承父类Dog：

/*
   继承具有传递性  C继承B  B继承A  那么C类就具有B,A类中非私有的属性和方法
 */
public class XiaoTianQuan extends Dog {

    public XiaoTianQuan() {
        super();//super()表示调用父类中无参构造,默认存储在,必须放在第一行
        System.out.println("哮天犬类中的无参构造方法");
    }

    public void fly() {
        System.out.println("哮天犬会飞");
        //super.play();  //误区: super表示父类对象
    }

    public XiaoTianQuan(String name) {
        super(name);
        System.out.println("哮天犬类中的有参构造方法");
    }

    /*
      哮天犬它是神犬,它的吃,玩与父类中的实现方式不同,父类中吃,玩不能满足哮天犬需求
      在子类中对父类中的方法进行重写(覆盖)
      具体语法:方法名相同,参数列表;返回值类型相同;访问权限修饰符等于或者大于父类的权限
      @Override 这java中提供的一个注解标签(是一种标记，记号),
      添加此注解的标签表示此方法是从父类重写过来的,就会对其进行语法验证
      Override(重写) overload(重载)
     */
    @Override
    public void eat() {
        System.out.println("神犬坐着吃饭");
    }

    public void play() {
        System.out.println("神犬飞着玩");
        super.eat();//调用父类anilaml中的eat方法
    }
}

测试1：

public class Test1 {

    public static void main(String[] args) {
        Dog dog = new Dog();
        //调用父类功能
        dog.setName("二狗");
        dog.setAge(3);
        dog.eat();

        //调用子类特有的功能
        dog.setColor("金色");
        dog.play();

        XiaoTianQuan xtq = new XiaoTianQuan();
        xtq.hashCode();//调用的是Obejct类中的方法
        xtq.setName("哮天犬");
        xtq.setAge(5000);
        xtq.eat();
        xtq.setColor("黑色");
        xtq.play();
        xtq.fly();
    }
}

测试2：

public class Test2 {
    /*
        new XiaoTianQuan();
        Animal类中的无参构造方法
        狗类中的无参构造方法
        哮天犬类中的无参构造方法
        在创建子类对象后,调用构造方法时,从上向下的调用,先初始化父类信息
        使用super()在子类构造方法的第一行默认执行,调用父类无参的构造方法
     */
    public static void main(String[] args) {
        XiaoTianQuan xtq = new XiaoTianQuan();
        xtq.setName("哮天犬");
        xtq.setAge(5000);
        xtq.setColor("黑色");
        xtq.eat();
        xtq.play();
        xtq.fly();

        XiaoTianQuan xtq2 = new XiaoTianQuan("哮天犬二代");
        System.out.println(xtq2.getName());
    }
}

3、方法的重写（OverRide）

当父类的方法实现不能满足子类需求时,可以对方法进行重写( override)。
在子类中可以根据需要对从基类中继承来的方法进行重写。
方法重写规则
- 方法名相同、参数列表相同；
- 返回值类型相同；
- 访问权限不能小于父类权限。
注意：构造方法,静态方法不能重写,成员变量不存在重写。

测试3：

public class Test3 {
    public static void main(String[] args) {
        XiaoTianQuan xtq = new XiaoTianQuan();
        xtq.setName("哮天犬");
        xtq.setAge(5000);
        xtq.eat();
        xtq.play();
        xtq.fly();
    }
}

在这里插入图片描述

4、抽象类

抽象方法
- 抽象方法是一种特殊的方法：它只有声明，而没有具体的实现。
- 抽象方法必须用abstract关键字进行修饰。
如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。
抽象类除了不能实例化对象之外，类的其它功能依然存在，成员变量、成员方法和构造方法。
用abstract修饰的类就是抽象类。如果某个类中包含有抽象方法，那么该类就必须定义成抽象类。
特点：
- 抽象类不能被实例化，但可以有构造方法,因为抽象类中含有无具体实现的方法，所以不能用抽象类创建对象。
- 抽象类只能用作基类，表示的是一种继承关系。继承抽象类的非抽象类必须实现其中的所有抽象方法，而已实现方法的参数、返回值要和抽象类中的方法一样。否则，该类也必须声明为抽象类。
- 使用关键字abstract定义抽象类，一般语法：

[访问权限] abstract class 类名 {
	成员列表
}

public abstract class Shapes {
	public abstract void draw();
}

public abstract class Shapes {
	public void draw(){
		//具体代码
	}
}

抽象类，抽象方法，在软件开发过程中都是设计层面的概念。也就是说，设计人员会设计出抽象类，抽象方法，程序员都是来继承这些抽象类并覆盖抽象方法，实现具体功能。

5、面向对象特征——多态

多态：同一种事物，在不同时刻表现不同的状态。
多态存在的三个必要条件
- 要有继承（包括接口的实现）(前提条件)
- 要有重写(前提条件)
- 父类引用指向子类对象
当编译期类型是父类，运行期类型是子类时，被称为父类引用指向子类对象：

class Animal{
	……
}
class Cat extends Animal{
	……
}
class Dog extends Animal {
	……
}
Animal x = new Cat() //Animal 的引用指向Cat的对象

多态环境下对成员方法的调用：

class Animal{
	void show() {
		System.out.println(“Anmial");
	}
}
class Cat extends Animal{
	void show() {
		System.out.println(“cat");
	}
}
……
Animal x = new Cat();
x.show() //调用的是子类中的方法
//简单的说：编译看左边，运行看右边。

多态环境下对静态成员方法的调用：

class Animal{
	static void show() {
		System.out.println(“Animal");
	}
}
class Cat extends Animal {
	static void show() {
		System.out.println(“Cat");
	}
}
……
Animal x = new Cat();
x.show() //调用的是动物类中的静态成员方法。
//简单的说：编译和运行都看左边。

多态环境下对成员变量的调用：

class Animal{
	int num = 3;
}
class Cat extends Animal {
	int num = 4;
}
……
Animal x = new Cat();
x.num; //调用的是动物类中的成员变量。
//简单的说：编译和运行都看等号左边。 注意：变量不存在被子类覆写这一说法，只有方法存在覆写。

方法参数具有多态性：

class Animal{
	void eat() {
	}
}
class Cat extends Animal{
	void eat() {
	}
}
class Dog extends Animal{
	void eat(){
	}
}//方法的形式参数类型是父类类型，而传递的实际参数可以是任意 子类的对象
method(Animal animal){
	animal.eat();
}
//方法参数多态性的好处：提高代码的扩展性

向上转型：

class Animal{
	void eat(){
	}
}
class Cat extends Animal{
	void look() {
		System.out.println("看家");
	}
}
………
Animal x=new Cat() //向上造型，Cat对象提升到Animal对象 
x.eat() //只能使用父类中的方法
x.look()//报错！不能使用子类中的方法
//向上转型的作用是：提高程序的扩展性。

向下转型：

class Animal{
	void eat(){
	}
}
class Cat extendsAnimal{
	void look() {
		System.out.println("看家");
	}
}
………
Animal x=new Cat();
Cat m=(Cat)x; //向下转型
m.eat();
m.look();//子父类中的方法都可以使用
//向下转型的作用是：为了使用子类中的特有方法。

6、final关键字

final 用于声明属性，方法和类。
属性:定义就必须直接赋值或者在构造方法中进行赋值，并且后期都不能修改。
方法:子类里不可以重写。
类:不能被定义为抽象类或是接口,不可被继承。

private int index;
private static final double pai=3.14;
private final int level;
public Test(){
	level=0;
}
public Test(int index){
	this.index=index;
	level=1;
}

final属性赋值
- 在声明时同时赋值，往往与static 一起使用。
- 声明时不赋值，必须在构造方法中逐一赋值。
- 总的原则：保证创建每一个对象的时候，final属性的值是确定的。
对参数做final修饰。
- 在方法参数前面加final关键字，为了防止数据在方法体中被修改。

7、接口

可以使用Java接口来实现
- 根据需求设计方法
- 实现所有方法
- 用多态的方式使用
面向接口编程
- 接口存在的意义：java中一个类只能有一个父类，所以用接口可以实现多继承的逻辑。
- 从本质上讲，接口是一种特殊的抽象类，这种抽象类中包含抽象方法。

public interface MyInterface {

    int num = 10;

    public void foo();

    public static void test() {
    }

    public default void test1() {
    }
}

使用interface关键字用来声明一个接口。

[访问修饰符] interface 接口名称 [extends 其他的接口名1,…,其他的接口名n] {
	// 声明常量 抽象方法 静态方法 默认方法
}

接口的特性
- 接口是隐式抽象的，当声明一个接口的时候，不必使用abstract关键字；
- 接口中方法可以是抽象的,静态的,默认的；
- 接口中声明的属性默认为 public static final 的；
- 接口不是被类继承了，而是要被类实现；
- 接口不能实例化对象,无构造方法；
- 一个类可以实现多个接口；
- 与继承关系类似，接口与实现类之间存在多态性；
- 一个接口能继承其它多个接口；
- 当类实现接口的时候，类要实现接口中所有的抽象方法。否则，类必须声明为抽象的类。