JavaSE篇学习之路：（七）【面向对象------下】

目录

• ​​第一章：final关键字​​
• ​​第二章：抽象类和接口​​

• ​​1.1抽象类（abstract)​​
• ​​2.1接口（interface）​​
• ​​能插拔的就是接口，代码演示：​​
• ​​一个类可以实现多个接口，代码演示：​​
• ​​3.1抽象类与接口的区别？​​

• ​​总结：​​
• ​​今天的分享就到这喽，希望对大家有帮助！！！~​​
• ​​一起学习，快乐编程，欢迎攻城狮们多多交流！！！~​​

第一章：final关键字

1. final修饰的类无法继承。
2. final修饰的方法无法覆盖。
3. final修饰的变量只能赋一次值。
4. final修饰的引用一旦指向某个对象，则不能再重新指向其它对象，但该引用指向的对象内部的数据是可以修改的
5. final修饰的实例变量必须手动初始化，不能采用系统默认值。
6. final修饰的实例变量一般和static联合使用，称为常量。
   

代码演示：

public static final double PI = 3.1415926;

第二章：抽象类和接口

1.1抽象类（abstract)

1. 类到对象为实例化，对象到类为抽象
2. 抽象类：类与类之间存在共同特征，将公共同特征抽取出来形成的类为抽象类。（属于引用类型）
3. 基础语法：​​[修饰符列表] abstract class 类名{}​​
4. 抽象类是无法实例化的，无法创建对象的，所以抽象类是用来被子类继承的。
5. 抽象类虽然无法实例化，但是抽象类有构造方法，这个构造方法是供子类使用的。
6. 抽象类的子类可以是抽象类。也可以是非抽象类。
7. 抽象类中不一定有抽象方法，抽象方法必须出现在抽象类中
   ​​​java 抽象方法怎么定义？ public abstract void doSome();​​
8. 一个非抽象的类，继承抽象类，必须将抽象类中的抽象方法进行覆盖/重写/实现。
   

面试题（判断题）：

java语言中凡是没有方法体的方法都是抽象方法。

不对，错误的。

Object类中就有很多方法都没有方法体，都是以“;”结尾的，但他们

都不是抽象方法，例如：

public native int hashCode();

这个方法底层调用了C++写的动态链接库程序。

前面修饰符列表中没有：abstract。有一个native。表示调用JVM本地程序。

代码演示：

/**
 * 抽象类：人类
 */
abstract class Person{
    private String name;

    public Person() {

    }

    public Person(String name) {
        this.name = name;
    }
    //抽象方法：跑的抽象方法
    public abstract void run();
}

/**
 * 学生类 继承抽象类 人类
 */
class Student extends Person{
    private String name;
    public Student() {

    }

    public Student(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    //子类实现父类的抽象方法
    public void run() {
        System.out.println("学生"+getName()+"在跑步");
    }

}

//测试类
public class Demo1 {
    public static void main(String[] args) {
    Student student=new Student();
    //使用set()方法写入数据。
    student.setName("张三");
    student.run();
    }
}

2.1接口（interface）

1. 接口是一种“引用数据类型”。
2. 接口是完全抽象的。
3. 基本语法：​​[修饰符列表] interface 接口名{}​​
4. 接口支持多继承，一个接口继承多个接口
5. 接口中只有常量+抽象方法。
6. 接口中所有的元素都是public修饰的
7. 接口中抽象方法的public abstract可以省略，常量的public static final可以省略。
8. 接口中方法不能有方法体。
9. 接口是提取的行为和动作，能插拔是接口

注意：
一个类可以实现多个接口类似于多继承，必须实现每个接口中的方法。
接口与接口进行强转时，没有继承关系也可以强转，运行时可能发生ClassCastException异常

代码演示：

/**
 * 接口 Inter1
 */
interface Inter1{
    //常量 省略了 public static final
    String name="接口1";
    //抽象方法
    public void method();
    public void method2();
}

/**
 * Inter2实现了接口Inter1
 */
class Inter2 implements Inter1{
    //实现接口中的方法
    public void method() {
        System.out.println("Inter2实现"+name+"method方法");
    }
    public void method2() {
        System.out.println("Inter2实现"+name+"method2方法");
    }
}

/**
 * 测试类u
 */
public class InterfaceText {
    public static void main(String[] args) {
    Inter2 inter2=new Inter2();
    inter2.method();
    //接口类似于多态
    Inter1 inter1=new Inter2();
    inter1.method();
    }
}

能插拔的就是接口，代码演示：

// 可飞翔的接口（是一对翅膀）
// 能插拔的就是接口。（没有接口你怎么插拔。）
// 接口通常提取的是行为动作。
interface Flyable{
  void fly();
}

// 动物类：父类
class Animal{
}

// 动物类子类：猫类
// Flyable是一个接口，是一对翅膀的接口，通过接口插到猫身上，让猫变的可以飞翔。
class Cat extends Animal implements Flyable{
  public void fly(){
    System.out.println("飞猫起飞，翱翔太空的一只猫，很神奇，我想做一只猫！！");
  }
}

// 蛇类，如果你不想让它飞，可以不实现Flyable接口
// 没有实现这个接口表示你没有翅膀，没有给你插翅膀，你肯定不能飞。
class Snake extends Animal{
}

// 想飞就插翅膀这个接口。
class Pig extends Animal implements Flyable{
  public void fly(){
    System.out.println("我是一只会飞的猪！！！");
  }
}

class Fish implements Flyable{ //没写extends，也是有的，默认继承Object。
  public void fly(){
    System.out.println("我是六眼飞鱼（流言蜚语）！！！");
  }
}

public class Test04{
  public static void main(String[] args){
    // 创建对象（表面看Animal类没起作用！）
    Flyable f = new Cat(); //多态。
    f.fly();

    // 同一个接口
    Flyable f2 = new Pig();
    // 调用同一个fly()方法，最后的执行效果不同。
    f2.fly();

    Flyable f3 = new Fish();
    f3.fly();
  }
}

一个类可以实现多个接口，代码演示：

interface A{
  void m1();
}

interface B{
  void m2();
}

interface C{
  void m3();
}

// 实现多个接口，其实就类似于多继承。
class D implements A,B,C{
  // 实现A接口的m1()
  public void m1(){
    
  }
  // 实现B接口中的m2()
  public void m2(){
    System.out.println("m2 ....");
  }
  // 实现接口C中的m3()
  public void m3(){
  
  }
}

3.1抽象类与接口的区别？

抽象类：半抽象，有构造方法，单继承。
接口：完全抽象，无构造方法，多继承，一个类多个接口，只允许常量和抽象方法。

总结：

面向的思想需要慢慢的培养，多动手，多敲才会体会到其中的奥秘，加油，奥利干！！

今天的分享就到这喽，希望对大家有帮助！！！~

一起学习，快乐编程，欢迎攻城狮们多多交流！！！~