前言

面向对象在百度百科中是这样解释的：“面向对象是一种对现实世界理解和抽象的方法，是计算机编程技术发展到一定阶段后的产物”。说的好像很流弊的样子，看看就行。

包的认识

1.1：包的概念包是组织、整合类的一种方式其目的在于保证使用类的唯一性（同一个包中，里面所包含的类名是唯一的）比如在包A中定义了一个Test类，在包B中也定义了一个Test类，那么当使用A中的Test类时便导入包A调用A中的Test类（A.Test），以此保证类的唯一性。

1.2：导入包中的类 Java 中有很多现成的包供我们使用，使用这些包的方式有两种

 public class TestDemo {
    public static void main(String[] args) {
        java.util.Date time = new java.util.Date();
        //使用 util 包中的Date类创建一个对象
        System.out.println(time.getTime());
        //调用该对象的 getTime 方法，获得一个毫秒级别的时间戳
    }
}
  

上述代码中，util 就是一个包，Date就是该包中的一个类，使用时用 java.包名.类名 使用

 import java.util.Date;
public class TestDemo {
    public static void main(String[] args) {
        Date time = new Date();
        System.out.println(time.getTime());
    }
  

第一个代码每次使用类时都要加包的前缀，太过麻烦，因此还可使用第二种方式，在代码最开头使用 import 关键字导入需要的包，这样就可以像使用自己定义的类一样，直接用类名创建对象当同时需要同一个包中的多个类是，可以用 import.java.包名.* 的方式导入包，这样就可以使用该包下的所有类（但建议不要这么使用，否则当导入多个包时还是会出现类名重复的现象）。

1.3：静态导入包中除了类的普通方法外，还有一些静态方法，使用这些方法时，可以使用 import static 的方式导入包中的静态字段和方法，无需创建对象直接使用

 import static java.lang.Math.*;
public class TestDemo {
    public static void main(String[] args) {
        double x = 10.5;
        double y = 3.0;
        double result = sqrt(pow(x,y)+pow(x,y));
        System.out.println(result);
    }
  

1.4：自定义类放入包中基本规则

• 在文件的最上方加一个 package 语句指定该代码在哪个包中
• 包名尽量指定成唯一名字，防止多文件间冲突
• 包名和代码路径相匹配
• 如果一个类没有 package 语句，则该类会被放到默认包中

1.5：包的访问权限控制如果某个成员不包含 public 和 private 关键字，此时这个成员可以被包中的其他类使用，但不能在包外部类中使用

1.6：常见的系统包 1、java.lang：系统常用基础类（String，Object），jdk1.1以后自动导入 2、java.lang.reflect: java 反射编程包3、java.net：进行网络编程开发包4、java.sql:进行数据库开发的支持包。 5、java.util:是java提供的工具程序包。(集合类等) 6、java.io:I/O编程开发包。

继承

2.1 概念：当创建多个类时发现这些类之间存在一定的关联关系，则可以创建一个父类拥有这些类的相同属性和方法，让这些类继承与父类，来提高效率，达到代码重用的效果。此时被继承的类我们成为 父类、基类或者超类，而继承的类我们称为子类或者派生类，子类会继承父类除构造方法外的其他所有东西。2.2 语法规则：class 子类 extend 父类{

}

• 子类使用 extend 关键字继承父类
• Java中一个子类只能继承一个父类
• 子类会继承父类的所有 public 的字段和方法
• 对于父类的 private 的字段和方法，子类无法访问
• 子类实例中也包含父类实例，可使用 super 关键字得到父类的引用

 class Animal{
    public String name;//父类的name必须为 public 否则子类将无法访问
    public Animal(String name) {
        this.name = name;
    }

    public void eat(String  food ){
        System.out.println(this.name+"吃"+food);
    }
}
class Dog extends Animal{
    public Dog(String name){
        super(name);
    }
}

class Bird extends Animal{
    public Bird(String name){
        super(name);
    }
    public void  fly (){
        System.out.println(this.name+"正在飞");
    }
}

public class TestDemo {
    public static void main(String[] args) {
        Dog dog = new Dog("旺旺");
        dog.eat("骨头");
        Bird bird = new Bird("啾啾");
        bird.eat("米粒");
        bird.fly();
    }
  

2.3、protected关键字上述代码中，如果将父类的 name 设为 private子类将无法访问，但设为 public 又违背了封装的规则，此时就需要用到 protect 关键字

• 对于其他类的调用者来说，被 protect 修饰的字段和方法是不能被访问的
• 但对于 该类的子类 和 同一个包下的其他类 来说，被 protect 修饰的字段和方法是可以被访问的

小结：Java中对字段和方法共有四种访问权限

• private：只能在类内部访问，内外部一律不行
• 默认：在类内部能访问，同一个包中的类也可以访问
• protect：在类内部能访问，且在其子类和同一个包中的类也可以访问
• public：类内部和类的调用者都能访问

2.4、final关键字final 可以修饰一个变量或者字段，用来表示常量final 也恶意修饰一个类，用来表现该类不能被继承组合：即一个类中对另一个类的嵌套，在一个类中实例另一个类，达到代码重用的效果

多态

3.1、向上转型：如上代码，创建一个 Bird 的对象可以写成

 Bird bird = new Bird()；
  

也可以写成

 Bird bird = new Bird()；
Animal bird2 = bird；
Animal bird3 = new Bird()；

  

此时bird2、bird3是一个父类(Animal)的引用，指向子类(bird)的实例，这称为向上转型。向上转型发生的时机：

• 直接赋值（即上述代码演示）
• 方法传参
• 方法返回

方法传参：

 public static void main(String[] args) {
    Bird bird = new Bird("啾啾");
    feed(bird);
}
public static void feed(Animal animal){
    animal.eat("谷子");
}
  

此时形参的类型是 Animal(父类) ,实际上是对应到 Bird(子类)的实例

方法返回：

 public static void main(String[] args) {
    findAnimal().eat("谷子");
}
public static Animal findAnimal(){
    Bird bird = new Bird("啾啾");
    return bird;
}
  

方法 findAnimal 返回值是 Animal 的一个引用，但实际指向 Bird 的一个实例

3.2：动态绑定子类和父类出现同名方法时发生

 class Animal{
    public String name;
    public Animal(String name) {
        this.name = name;
    }

    public void eat(String food){
        System.out.println("我是一只小动物");
        System.out.println(this.name+"正在吃"+food);
    }
}
class Bird extends Animal{
    public Bird(String name){
        super(name);
    }
    public void eat(String food){
        System.out.println("我是一只小鸟");
        System.out.println(this.name+"正在吃"+food);
    }
    public void fly(){
        System.out.println(this.name+"正在飞");
    }
}
public class TestDemo {
    public static void main(String[] args) {
        Animal animal1 = new Animal("动物");
        Animal animal2 = new Bird("小鸟");
        animal1.eat("谷子");
        animal2.eat("谷子");
    }
  

执行以上代码我们发现：

• animal1 和 animal2 虽然都是 Animal 类型的引用，但animal1指向 Animal 实例的对象，animal2指向 Bird 实例的对象
• 对 animal1 和 animal2 分别调用eat方法，发现 animal1 调用的是父类的方法，animal2 调用的是子类的方法

在Java中，调用某个方法，究竟执行哪段代码（是父类方法还是子类），取决于看这个引用指向的对象是父类对象还是子类对象，这个过程是在运行时才决定的，因此成为动态绑定父类引用，引用子类对象时，只能访问自己特有的，不能访问子类独有的

3.3、重写对于上述代码，父类和子类的eat方法来说，就构成了重写重写的注意事项：

• 普通方法可以重写，static 修饰的方法不能重写
• 重写中子类的访问权限不能低于父类的访问权限
• 重写和重载不同

重写和重载的区别

1.要求不同重载：a.方法名相同 b.参数列表不同 c.返回值不做要求重写：a.方法名相同 b.参数列表相同（参数类型和个数） c.返回值也要相同2.范围不同重载：同一个类中重写：继承关系，不同类中3.限制重载：无限制重写：子类中重写的方法访问权限不能低于父类的访问权限

3.4、理解多态

 class Shape {
    public void draw(){

    }
}
class Circle extends Shape{
    public void draw(){
        System.out.println("画一个圆圈○");
    }
}
class Rectangle extends Shape{
    public void draw(){
        System.out.println("画一个矩形□");
    }
}
class Triangle extends Shape{
    public void draw(){
        System.out.println("画一个三角△");
    }
}
//================================================
//================================================
public class TestDemo {
    public static void main(String[] args) {
        Shape shape1 = new Circle();
        Shape shape2 = new Rectangle();
        Shape shape3 = new Triangle();
        drawMap(shape1);
        drawMap(shape2);
        drawMap(shape3);
    }
    public static void drawMap(Shape shape){
        shape.draw();
    }
  

以上代码，分割线以上是由类的实现者编写的，分割线以下是由类的调用者编写的当调用者编写drawMap方法的时候（参数类型为父类Shape），并不关心当前shape引用指向哪个类型的实例，此时shape调用的draw方法只取决于shape指向的哪个类型的实例，以实现不同的表现形式，这种思想叫做多态。

3.5、向下转型父类引用，引用子类对象称为向上转型；子类引用，引用父类对象称为向下转型。

 class Animal{
    public String name;
    public Animal(String name) {
        this.name = name;
    }

    public void eat(String food){
        System.out.println("我是一只小动物");
        System.out.println(this.name+"正在吃"+food);
    }
}

ass Bird extends Animal{
    public Bird(String name){
        super(name);
    }
    public void eat(String food){
        System.out.println("我是一只小鸟");
        System.out.println(this.name+"正在吃"+food);
    }
    public void fly(){
        System.out.println(this.name+"正在飞");
    }
}
    public class TestDemo {
    public static void main(String[] args) {
        Animal animal = new Bird("啾啾");
        animal.eat("谷子");
        animal.fly();//执行该行代码时，会报错误
    }
  

编译过程中 animal 的类型时 Animal ，编译器编译时根据类型只知道 animal 中只有一个eat方法，找不到fly方法

• 编译器检查存在哪些方法时候，看的是 Animal 类型
• 执行时究竟执行父类方法还是子类方法，看的是 Bird 类型
  但很多时候为了让向下转型更安全，需要判断一下 animal 是否指向 Bird 的引用，使用instanceof 关键字判断

 Animal animal = new Cat("小猫");
if (animal instanceof Bird) {
Bird bird = (Bird)animal;
bird.fly();
}
  

3.6、super关键字当在子类内部要调用父类方法时，就要用到 super 关键字super 表示获取到父类实例的引用，其有两种常用方法

一、使用 super 来调用父类的构造方法，super（参数）

 public Bird(String name){
    super(name);
}
  

二、使用 super 来调用父类的普通方法，super.方法名（参数）

 class Bird extends Animal{
    public Bird(String name){
        super(name);
    }
    public void eat(String food){
        super.eat(food);
        System.out.println("我是一只小鸟");
        System.out.println(this.name+"正在吃"+food);
    }
}
  

上述代码中个，如果直接调用eat方法，则被编译器认为是调用子类的方法（同递归），想要调用父类方法则需要使用 super 关键字

this和super的区别：

1、概念this：访问本类的属性和方法super：访问父类的属性和方法2、查找范围this：先查找本类，子类没有再调用父类super：不查找本类，直接调用父类3、特殊this:表示当前对象的引用super：表现父类对象的引用

多态存在的意义就在于， 让调用者不必关注对象的具体类型 ，降低用户的使用成本

4、抽象类

4.1语法规则类似于之前代码的父类 Shape 中的draw方法，其中并没有实际工作，而由其子类重新该方法实现，那么像这种没有实际工作的方法我们就可以用 abstract 关键字修饰把它设计成一个抽象方法，而包含抽象方法的类我们就称为抽象类

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

• 在draw方法前加一个 abstract 修饰表示该方法是抽象方法，抽象方法没有方法体
• 对于包含抽象方法的类，class 前必须加一个 abstract 关键字表示是抽象类

注意事项：

• 抽象类不能直接实例
• 抽象方法的访问权限不能是private
• 抽象类中可以包含其他非抽象方法，也可以包含字段，和普通方法一样，可以被重新可以被调用

4.2抽象类的作用抽象类的意义在于为了被继承抽象类本身不能实例化，想要使用，必须创建该抽象类的子类，在子类中重写抽象方法使用抽象类相当于多了一重编译器的检验（对于抽象了来说，如果继承的子类不重写父类的抽象方法，则会报错）

5、接口

接口是比抽象类还抽象，接口只包含抽象方法，其字段也只能包含静态常量

 interface IShape{
    abstract public void draw();
}

class Circle implements Shape{
    @ Override 
    public void draw() {
        System.out.println();
    }
}
  

• 用 interface 定义一个接口
• 接口中的方法只能是抽象方法，所以可以省略 abstract
• 并且接口中的方法只能是 public ，所以可以省略
• Circle 用 implement 来实现接口
• 在调用的时候同样可以创建一个接口的引用，对应到一个子类的实例
• 接口不能被单独实例化

在Java中一个类只能继承一个父类，但同时可以实现多个接口

 class Animal{
    public String name;
    public Animal(String name){
        this.name = name;
    }
}
interface IFlying{
    void fly();
}
interface IRunning{
    void run();
}
interface ISwimming{
    void swim();
}
class Dog extends Animal implements IRunning{
    public Dog(String name){
        super(name);
    }
    @Override
    public void run() {
        System.out.println(this.name+"正在跑步");
    }
}
class Frog extends Animal implements IRunning,ISwimming{
    public Frog(String name){
        super(name);
    }
    @Override
    public void run() {
        System.out.println(this.name+"正在跑步");
    }
    @Override
    public void swim() {
        System.out.println(this.name+"正在游泳");
    }
}
class Duck extends Animal implements IRunning,ISwimming,IFlying{
    public Duck(String name){
        super(name);
    }
    @Override
    public void fly() {
        System.out.println(this.name+"正在飞");
    }
    @Override
    public void run() {
        System.out.println(this.name+"正在游泳");
    }
    @Override
    public void swim() {
        System.out.println(this.name+"正在游泳");
    }
}

public class TestDemo {
    public static void main(String[] args) {
        Dog dog = new Dog("汪汪");
        Frog frog = new Frog("呱呱");
        Duck duck = new Duck("嘎嘎");
        dog.run();
        frog.run();
        frog.swim();
        duck.fly();
        duck.run();
    }
}
  

接口使用实例——给对象数组排序创建一个学生类

 class Students implements Comparable{
    private String name;
    private int score;
    public Students(String name, int score) {
        this.name = name;
        this.score = score;
    }

    @Override
    public String toString() {
        return "Students{" +
                "name='" + name + ''' +
                ", score=" + score +
                '}';
    }

    @Override
    public int compareTo(Object o) {
        Students s = (Students)o;
        if(s.score > ((Students) o).score){
            return 1;
        }else if(s.score == ((Students) o).score){
            return 0;
        }else{
            return -1;
        }
    }
}
  

在 sort 方法中会自动调用 compareTo 方法.compareTo 的参数是 Object，其实传入的就是Students类型的对象，然后比较当前对象和参数对象的大小关系

接口间的承接一个接口可以承接另一个接口，达到复用效果，使用 extends 关键字接口间承接相当于把多个接口凭借在一起

Clonable 接口和深拷贝Object 类中存在一个 clone 方法，调用这个方法可以创建一个对象的“拷贝”，但是想要合法的调用clone方法，必须先要实现 Clonable 接口，否则就会抛出 CloneNotSupportedException 异常

 class Person implements Cloneable{
    public String name;

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

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + ''' +
                '}';
    }
}

public class TestDemo {
    public static void main(String[] args) throws CloneNotSupportedException {
        Person person1 = new Person("小明");
        Person person2 = (Person) person1.clone();
        person2.name = "小红";
        System.out.println(person1);
        System.out.println(person2);
    }
}
  

如下代码即深拷贝：

 class Money implements Cloneable{
    public int m=10;

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}
class Person implements Cloneable{
    public String name;
    public Money money ;

    public Person(String name) {
        this.name = name;
        this.money = new Money();
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        Person person = (Person) super.clone();
        person.money = (Money) this.money.clone();
        return person;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + ''' +
                ", money=" + money.m +
                '}';
    }
}

public class TestDemo {
    public static void main(String[] args) throws CloneNotSupportedException {
        Person person1 = new Person("小明");
        Person person2 = (Person) person1.clone();
        person2.name = "小红";
        person2.money.m = 15;
        System.out.println(person1);
        System.out.println(person2);
    }
}
  

总结

• 抽象类和接口都是Java中多态的常见使用方法，但两者又有区别
  最核心区别：抽象类可以包含普通方法和普通字段，可以被子类直接使用，而接口中只有抽象方法，实现该接口的类必须重写所有抽象方法

最后

感谢你看到这里，看完有什么的不懂的可以在评论区问我，觉得文章对你有帮助的话记得给我点个赞，每天都会分享java相关技术文章或行业资讯，欢迎大家关注和转发文章！