Java面向对象编程知识点的一些总结

包

• 查看源码（idea）：

  • 1、鼠标点击源码（Ctrl+鼠标点击）
  • 2、Alt+7目录显示

• Java.lang 下的包不需要手动导入

• 访问权限：

  • public：不同包之间访问
  • private: 本类访问
  • protected：保护访问权限，是介于public和private之间的一种访问修饰。被protected修饰的属性及方法只能被类本身的方法和子类访问。（子类在不同的包中也可以访问）
  • 默认权限（不加权限修饰限定符）:同一个包下访问
    

• 静态导入

  • 使用 import static 可以导入包中的静态的方法和字段

• 包名一般小写

继承

• 基本语法：

class 子类 extends 父类 {
}

• 使用 extends 指定父类

• Java 中一个子类只能继承一个父类 (而C++/Python等语言支持多继承)

• 子类会继承父类的所有 public 的字段和方法

• 对于父类的 private 的字段和方法, 子类中是无法访问的

• 子类的实例中, 也包含着父类的实例. 可以使用 super 关键字得到父类实例的引用

• 优点：

  • 1、代码的重复使用
  • 2、代码简洁

• 子类在构造时，需要先帮助父类来构造（即需要使用super关键字构造）

 class Animal{
        public String name;
    
        public Animal(String name) {
            this.name = name;
        }
    
        public void eat(){
            System.out.println(this.name+"::eat()");
        }
    }
    
    class Cat extends Animal{
    
        public Cat(String name) {
            super(name);
        }
    }

• super：

  • 代表父类对象的引用
  • super.data：访问父类的数据成员
  • super.fun()：调用父类的方法
  • super()：调用父类的构造方法

• super关键字与this关键字的区别：
  

• 子类继承了父类除构造方法外所有的东西

  • 注意：私有的东西也被继承了，但是不能在子类中访问

• 一个类继承了其它类的话就不会在继承object类了

• final：

  • final int SIZE = 10; 常量,不能改变
  • final class Animal{} 当前类不能被继承

多态

• 向上转型：

  • 父类引用 引用子类对象，同时父类引用去调用父类和子类同名的覆盖(重写)方法
  • 向上转型的三种方式：
    • 1、直接赋值：Animal animal1 = new Cat("mimi");
    • 2、方法传参：public void func(Animal animal){}
    • 3、方法返回：public Animal func(){ Cat cat = new Cat("mimi"); return cat;}

• 重写（override）

  • 1、方法名称相同
  • 2、参数列表相同
  • 3、返回值相同
  • 4、访问修饰限定符，父类不能是private
  • 5、子类的访问权限一定是大于等于父类的访问权限的（public > protected > 默认权限 > private）
  • 6、static方法不能被重写

• 重载

  • 1、方法名称相同
  • 2、参数列表不同
  • 3、返回值不做要求

• 动态绑定

  • 前提是发生了向上转型
  • 注意：在构造函数中也可以发生动态绑定，只是一般不会这样用

class Animal{
        public String name;
    
        public Animal(String name) {
            this.name = name;
        }
    
        public void eat(){
            System.out.println(this.name+"::eat()");
        }
    }
    
    class Cat extends Animal{
    
        public Cat(String name) {
            super(name);
        }
    
        public void eat(){
            System.out.println(this.name+"Cat::eat()");
        }
    }
    
    public class TestDemo {
        public static void main(String[] args) {
            Animal animal1 = new Cat("mimi");   //向上转型
    //        animal1.function(); //通过父类的引用调用的方法，一定是在父类当中存在的，而不能调用父类中没有的方法
            animal1.eat(); //发生动态绑定，执行的是子类的eat()方法，输出结果是：mimiCat::eat()
        }
    }

• 执行animal1.eat();这行代码执行的是子类eat()方法的原因：
  • 在 Java 中, 调用某个类的方法, 究竟执行了哪段代码 (是父类方法的代码还是子类方法的代码) , 要看究竟这个引用指向的是父类对象还是子类对象. 这个过程是程序运行时决定的(而不是编译期), 因此称为 动态绑定
  • 使用javap -c 命令可以反编译查看，可以看到程序在编译时调用的是父类eat()方法，说明动态绑定是发生在程序运行时
    
• 使用多态的好处：
  • 1、类调用者对类的使用成本进一步降低
    • 封装是让类的调用者不需要知道类的实现细节
    • 多态能让类的调用者连这个类的类型是什么都不必知道，只需要知道这个对象具有某个方法即可
    • 多态可以理解成是封装的更进一步，让类调用者对类的使用成本进一步降低
  • 2、能够降低代码的 “圈复杂度”, 避免使用大量的 if - else
  • 3、可扩展能力更强，代码的改动成本低

抽象类

• 抽象类：
  • 1、包含抽象方法的类，抽象类。使用abstract关键字来修饰的。
  • 2、抽象方法是不能够有具体的实现的。
  • 3、在抽象类中可以定义和普通类相同的数据成员和方法。
  • 4、抽象类不能够进行实例化。例：Shape shape = new Shape();是错误的
  • 5、抽象类天生就是为了被继承。
  • 6、一个普通类继承了抽象类之后一定要重写抽象类的抽象方法。
  • 7、如果一个类继承了抽象类但是又不想重写这个抽象方法，那么就把这个类也设置为抽象类，但是迟早都要重写的。
  • 8、抽象方法不能是private。
  • 9、抽象类中可以包含其他的非抽象方法, 也可以包含字段. 这个非抽象方法和普通方法的规则都是一样的可以被重写,也可以被子类直接调用

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

class Cycle extends Shape{

    @Override
    public void draw() {
        System.out.println("○");
    }
}

接口

• 接口是抽象类的更进一步. 抽象类中还可以包含非抽象方法, 和字段. 而接口中包含的方法都是抽象方法, 字段只能包含静态常量

• 接口：

  • 1、接口当中的方法，一定是不能够有具体的实现的
  • 2、接口当中default中修饰的方法才能够有具体的实现的
  • 3、接口当中的成员变量都是public static final的
  • 4、接口当中的方法都是public abstract
  • 5、如果不写，默认都是public abstract和public static final的
  • 6、接口不能够进行实例化 ，例：Shape shape = new Shape();是错误的
  • 7、注意子类重写接口方法时，一定是public修饰的，因为接口的方法一定是public修饰的
  • 8、接口也可以发生向上转型和运行时绑定

• 使用接口的好处：

  • 1、实现多继承
  • 2、可扩展性非常强
  • 接口实际上就是对某一种功能的抽象

• 注意：

  • 1、类和接口的关系：implements
    • 抽象类可以实现接口，但是这样写并没有意义
  • 2、接口和接口之间的关系：extends（拓展）

• 抽象类和接口的区别

• Cloneable为什么是一个空接口（标记接口），作用是什么？

  • 标记当前类是可以克隆的

抽象类和接口的区别：