前言

本文为Java基础面向对象编程相关知识，Java全栈学习路线可参考：【Java全栈学习路线】最全的Java学习路线及知识清单，Java自学方向指引，内含最全Java全栈学习技术清单~

一、认识面向对象

1.面向过程&面向对象

面向过程思想

步骤清晰简单，第一步做什么，第二步做什么….
面对过程适合处理一些较为简单的问题

面向对象思想

物以类聚，分类的思维模式，思考问题首先会解决问题需要哪些分类,然后对这些分类进行单独思考。最后，才对某个分类下的细节进行面向过程的思索。
面向对象适合处理复杂的问题，适合处理需要多人协作的问题!

注意： 对于描述复杂的事物，为了从宏观上把握、从整体上合理分析，我们需要使用面向对象的思路来分析整个系统。但是，具体到微观操作,仍然需要面向过程的思路去处理。

2.什么是面向对象

面向对象编程(Object-Oriented Programming, OOP)
面向对象编程的本质就是:以类的方式组织代码，以对象的形式封装数据
抽象：编程思想!持续的学习，茅塞顿开!多实践,多测试大脑中的想法!实践出真知
三大特性：封装，继承，多态
从认识论角度考虑是先有对象后有类。对象，是具体的事物。类，是抽象的，是对对象的抽象
从代码运行角度考虑是先有类后有对象。类是对象的模板

二、对象的创建与分析

1.类与对象的关系

类是一种抽象的数据类型,它是对某一类事物整体描述/定义,但是并不能代表某一个具体的事物.

动物、植物、手机、电脑….
Person类、Pet类、 Car类等, 这些类都是用来描述/定义某一类具体的事物应该具备的特点和行为

对象是抽象概念的具体实例

张三就是人的一个具体实例,张三家里的旺财就是狗的一个具体实例。
能够体现出特点,展现出功能的是具体的实例,而不是一个抽象的概念.

我们可以将这种思想转换为代码实现!

2.对象创建与初始化

使用new关键字创建对象
使用new关键字创建的时候，除了分配内存空间之外，还会给创建好的对象进行默认的初始化以及对类中构造器的调用
类中的构造器也称为构造方法，是在进行创建对象的时候必须要调用的。并且构造器有以下俩个特点:1.必须和类的名字相同；2.必须没有返回类型,也不能写void
构造器必须要掌握

代码示例：

//学生类
public class Student {
    //属性:字段
    String name;//没有赋值，默认为null
    int age;//没有赋值，默认为0
    //方法
    public void study(){
        System.out.println(this.name+"在学习");
    }
}

//一个项目应该只存一个main方法
public class Application {
    public static void main(String[] args) {
        //类:抽象的，要实例化
        //类实例化后会返回一个自己的对象!
        //student对象就是一个Student类的具体实例!
        Student student = new Student();
        student.name = "张三";
        student.age = 18;
        System.out.println(student.name);
        System.out.println(student.age);
    }
}

3.构造器

构造器：和类名相同；没有返回值
作用：new本质在调用构造方法；初始化对象的值
注意点：定义有参构造之后，如果想使用无参构造，需要显示的定义一个无参的构造

代码示例：

public class Person {
    //一个类即使什么都不写，它也会存在一个方法
    //显示的定义构造器
    String name;
    //实例化初始值
    //1.使用new关键字，本质是在调用构造器
    public Person(){
//        this.name = "张三";
    }
    //有参构造:一旦定义了有参构造，无参就必须显示定义
    public Person(String name){
        this.name = name;
    }
}

//一个项目应该只存一个main方法
public class Application {
    public static void main(String[] args) {
        //new实例化了一一个对象
        Person person = new Person("李四");
        System.out.println(person.name);
    }
}

三、面向对象三大特征

1.封装

我们程序设计要追求“高内聚，低耦合”。高内聚：就是类的内部数据操作细节自己完成，不允许外部干涉；低耦合：仅暴露少量的方法给外部使用。
封装(数据的隐藏)：通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏。记住这句话就够了:属性私有，get/set
封装的优点：1.提高程序的安全性，保护数据；2.隐藏代码的实现细节；3.统一接口；4.系统可维护增加了

代码示例：

// Student类

public class Student {
    //属性私有
    private String name;//名字
    private int age;//年龄
    private int idCard;//学号
    private char sex;//性别
    //提供一些可以操作这个属性的方法!
    //提供一些public 的get、set方法
    //get获得这个数据
    public String getName() {
        return name;
    }
    //set给这个数据设置值
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        if (age>120||age<0){ //不合法
            this.age = 3;
        }else{
            this.age = age;
        }
    }
    public int getIdCard() {
        return idCard;
    }
    public void setIdCard(int idCard) {
        this.idCard = idCard;
    }
    public char getSex() {
        return sex;
    }
    public void setSex(char sex) {
        this.sex = sex;
    }
    //学习（）
    //睡觉（）
}

// Application类
public class Application {
    public static void main(String[] args) {
        Student s1 = new Student();
        s1.setName("李白");
        System.out.println(s1.getName());
        s1.setAge(99);
        System.out.println(s1.getAge());
    }
}

2.继承

继承是类和类之间的一种关系。除此之外类和类之间的关系还有依赖、组合、聚合等
继承关系的俩个类，一个为子类(派生类),一个为父类(基类)。子类继承父类,使用关键字extends来表示
子类和父类之间,从意义上讲应该具有”is a”的关系

super注意点:

sulper调用父类的构造方法，必须在构造方法的第一个
super必须只能出现在子类的方法或者构造方法中
super和 this不能同时调用构造方法

super与this比较:

代表的对象不同：this:本身调用者这个对象；super:代表父类对象的应用
前提：this:没哟继承也可以使用；super:只能在继承条件才可以使用
构造方法：this() 是本类的构造；super()是父类的构造

重写

重写:需要有继承关系，子类重写父类的方法!
方法名必须相同
参数列表列表必须相同
修饰符:范围可以扩大但不能缩小:public>Protected>Default>private
抛出的异常:范围，可以被缩小，但不能扩大;ClassNotFoundException —>Exception(大)
重写，子类的方法和父类必要一致;方法体不同
为什么需要重写:父类的功能，子类不一定需要，或者不一定满足

代码示例：

// 父类（B）
//重写都是方法的重写，和属性无关
public class B {
    public  void test(){
        System.out.println("B==>test()");
    }
}

// 子类（A）
public class A extends B{
    //Override重写
    @Override //注解:有功能的注释!
    public  void test(){
        System.out.println("A==>test()");
    }
}

// Application
public class Application {
    public static void main(String[] args) {
        //静态的方法和非静态的方法区别很大!
        //方法的调用只和左边，定义的数据类型有关
        A a = new A();
        a.test();
        //父类的引用指向了子类
        B b = new A();
        b.test();
        /*
        输出结果:
            A==>test()
            A==>test()
        */
    }
}

父类中不能被重写的方法有：

带static修饰的方法（static方法属于类，不属于实例）
带final修饰的方法（final常量修饰符）
带private修饰的类，私有类不能重写

3.多态

多态即同一方法可以根据发送对象的不同而采用多种不同的行为方式
一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多
多态存在的条件：有继承关系；子类重写父类方法；父类引用指向子类对象
注意:多态是方法的多态，属性没有多态性
instanceof (类型转换)引用类型

代码示例：

// Person类
public class Person {
    public void run(){
        System.out.println("run");
    }
}

// Student类
public class Student extends Person{
    @Override
    public void run(){
        System.out.println("son");
    }
    public void eat(){
        System.out.println("eat");
    }
}

// Application类
public class Application {
    public static void main(String[] args) {
        //一个对象的实际类型是确定的
        //new Student();
        //new Person();
        //可以指向的引用类型就不确定了:父类的引用指向子类
        //Student能调用的方法都是自己的或者继承父类的!
        Student s1 = new Student();
        //Person父类型，可以指向子类，但是不能调用子类独有的方法(只能将父类强制转换成子类对象才能调用)
        //父类引用指向子类对象，
        //在父类new子类，调用时是调用父类，要是子类重写了父类，则调用子类方法
        Person s2 = new Student();
        Object s3 = new Student();
        //对象能执行哪些方法，主要看对象左边的类型，和右边关系不大!
        s2.run();//子类重写了父类的方法，执行子类的方法
        ((Student) s2).eat();
        s1.run();
    }
}

多态注意事项：

多态是方法的多态，属性没有多态
父类和子类，有联系类型转换异常! ClassCastException!
存在条件: 继承关系，方法需要重写，父类引用指向子类对象! Father f1 = new Son()

多态的总结

父类引用指向子类的对象
把子类转换为父类，向上转型
把父类转换为子类，向下转型; 强制转换
方便方法的调用，减少重复的代码
简洁封装、组承、多态! 抽象类，接口

4.static的使用

静态变量与方法

//static
public class Student {
    public static  int age;//静态变量   大多只会出现在多线程
    private double score;//非静态变量
    //下面这个是非静态方法
    public void run(){
        System.out.println("run");
        //go();//非静态方法里可以调用静态方法
    }
    //下面这个是静态方法
    public static void go(){
        System.out.println("go");
    }
    public static void main(String[] args) {
        Student s1 = new Student();
        //静态变量对于类，所有对象（实例）所共享，当直接使用类名去调用变量名，说明这个变量名是static（静态）的
        System.out.println(Student.age);
        //System.out.println(Student.score);会报错，提示score是非静态变量，无法用类名调用。
        System.out.println(s1.age);
        System.out.println(s1.score);
        System.out.println("========================");
        /*
        s1.run();(想使用run()方法，就必须new一个Student，即new一个对象,调用的写法只能是 对象名称.方法名)
        go();(即使没有new一个Student，也可以直接调用go()方法，)
        Student.go();(也可以在go()方法前面加类名，也可以像上面一样不加类名,(不加类名的前提是必须在同一个类下面))
        */
    }
}

匿名代码块/静态代码块

//当下面public class Person写成public final class Person时，表示当前类不能被继承
//final有最终的意思
public class Person {
    //第二个执行，每new一次对象就会执行一次(可以用来赋初始值)
    {
        System.out.println("匿名代码块");
    }
    //第一个执行，并且只执行一次
    static {
        System.out.println("静态代码块");
    }
    //第三个执行，每new一次对象就会执行一次
    public Person() {
        System.out.println("无参构造方法");
    }
    public static void main(String[] args) {
        Person person = new Person();
        /*
        输出结果：
                静态代码块
                匿名代码块
                无参构造方法
         */
    }
}

静态导入包

//静态导入包~
import static java.lang.Math.random;
public class Test {
    public static void main(String[] args) {
        //System.out.println(Math.random());//静态导入包的方法之后，连类名都可以不写了
        System.out.println(random());
        System.out.println(Math.PI);//这里没导入包的方法，所以要写Math
    }
}

四、抽象类与接口

1.抽象类

abstract修饰符可以用来修饰方法也可以修饰类：如果修饰方法,那么该方法就是抽象方法；如果修饰类,那么该类就是抽象类。
抽象类中可以没有抽象方法,但是有抽象方法的类一定要声明为抽象类。
抽象类,不能使用new关键字来创建对象,它是用来让子类继承的。
抽象方法,只有方法的声明,没有方法的实现,它是用来让子类实现的。
子类继承抽象类,那么就必须要实现抽象类没有实现的抽象方法,否则该子类也要声明为抽象类。
抽象类中存在无参构造方法。

代码示例：

// 抽象类Action
public abstract class Action {
    //约束~有人帮我们实现~
    //abstract，抽象方法，只有方法名字，没有方法的实现!
    public abstract void doSomething();
    //1.不能new这个抽象类，只能靠子类去实现它;约束!
    //2.抽象类中可以写普通的方法
    //3.抽象方法必须在抽象类中
    public void run(){
        System.out.println("run");
    }
}

// 普通类A继承抽象类Action
//抽象类的所有方法，继承了它的子类，都必须要实现它的方法~（重写父类的方法），除非把这个类也设置为抽象类
public class A extends Action {
    @Override
    public void doSomething() {
    }
}

2.接口

普通类: 只有具体实现
抽象类: 具体实现和规范(抽象方法)都有!
接口: 只有规范! 自己无法写方法~专业的约束! 约束和实现分离: 面向接口编程~
接口就是规范，定义的是一组规则，体现了现实世界中“如果你…则必须能…的思想。如果你是天使，则必须能飞。如果你是汽车，则必须能跑。如果你好人，则必须干掉坏人;如果你是坏人，则必须欺负好人。
接口的本质是契约，就像我们人间的法律一样。制定好后大家都遵守。
OO的精髓，是对对象的抽象，最能体现这一点的就是接口。为什么我们讨论设计模式都只针对具备了抽象能力的语言(比如c++. java、c#等) ，就是因为设计模式所研究的，实际上就是如何合理的去抽象。
注意：声明类的关键字是class 声明接口的关键字是interface

// 接口UserService
//interface 定义的关键字  接口都需要有实现类
public interface UserService {
    //接口中的所有定义其实都是抽象的public abstract
    //返回值类型+参数名+(参数有就写，没有就不写)
    /*
    void shout();
    void run(String name);
    */
    //常量~ public static final
    int AGE = 99;
    //接口中的所有定义的方法其实都是抽象的public abstract
    void add(String name);
    void delete(String name);
    void update(String name);
    void query(String name);
}

// 接口TimeService
public interface TimeService {
    void timer();
}

// 普通类UserServiceImpl实现（也叫继承）UserService,TimeService
//抽象类   extends 只能单继承
//类可以实现接口   implements 接口名  （implement可以多实现，也叫多继承）
//实现了接口的类，就需要重写接口中的方法
public class UserServiceImpl implements UserService,TimeService {
    @Override
    public void add(String name) {
    }
    @Override
    public void delete(String name) {
    }
    @Override
    public void update(String name) {
    }
    @Override
    public void query(String name) {
    }
    @Override
    public void timer() {
    }
}

接口的作用

约束
定义一些方法，让不同的人实现~ 10—- >1
public abstract 成员方法
public static final 成员变量
接口不能被实例化，接口中没有构造方法
implements可以实现多个接口
必须要重写接口中的方法

五、内部类

1.内部类的概念与分类

内部类就是在一个类的内部在定义一个类，比如，A类中定义一个B类，那么B类相对A类来说就称为内部类，而A类相对B类来说就是外部类了。
内部类的分类：1.成员内部类；2.静态内部类；3.局部内部类；4.匿名内部类。

2.成员内部类

成员内部类是最普通的一种内部类，成员内部类可以访问外部类所有的属性和方法。但是外部类要访问成员内部类的属性和方法，必须要先实例化成员内部类。
成员内部类里面不能包含静态的属性和方法（只有将某个内部类修饰为静态类，才能够在这个类中定义静态的成员变量与成员方法）。
成员内部类是依附于外部类的，所以只有先创建了外部类才能够创建内部类。
用内部类定义在外部类中不可访问的属性，这样就在外部类中实现了比外部类的private还要小的访问权限。

public class Outer {
    private int id = 10;
    public void out(){
        System. out. println("这是外部类的方法");
    }
    public class Inner{
        public void in(){
            System.out.println("这是内部类的方法");
        }
        //获得外部类的私有属性~
        public void getID(){
            System.out.println(id);
        }
    }
}

Application

public class Application {
    public static void main(String[] args) {
        //new
        Outer outer = new Outer();
        //通过这个外部类来实例化内部类
        Outer.Inner inner = outer.new Inner();
        inner.in();
        inner.getID();
    }
}

3.静态内部类

静态内部类就是在成员内部类多加了一个 static 关键字，在静态内部类中可以定义静态或者非静态的成员。
静态内部类可以用public,protected,private修饰。
静态内部类只能访问外部类的静态成员变量和方法（包括私有静态）。
静态内部类与非静态内部类之间存在一个最大的区别：非静态内部类在编译完成之后会隐含地保存着一个引用，该引用是指向创建它的外部类，但是静态内部类却没有。
静态内部类的创建不依赖外部类，可以直接创建，而不需要将静态内部类的实例绑定在外部类的实例上。（非静态内部类创建：Outer.Inner in = new Outer.Inner();）
静态内部类的使用频率并不是很高，但是在有一些场合，如果没有这个内部静态类的话，可能会起到事倍功半的反面效果。

public class Outer {
    private int id = 10;
    public void out(){
        System. out. println("这是外部类的方法");
    }
    public static class Inner{
        public void in(){
            System.out.println("这是内部类的方法");
        }
    }
}

Application

public class Application {
    public static void main(String[] args) {
        Outer outer = new Outer();
    }
}

4.局部内部类

局部内部类是定义在代码块内的一个内部类。比如在方法里面定义一个内部类，就是局部内部类。
局部内部类的作用范围仅仅就在它所在的代码块里，局部内部类不能被public，protected，private以及static修饰，但是可以被final修饰。

public class Outer {
    //局部内部类(方法里面写一个类)
    public void method( ){
        class Inner {
            public void in() {
            }
        }
    }
}
//一个java类中可以有多个class类， 但是只能有一个public class
/*class A{
    public static void main(String[] args) {
    }
}*/

5.匿名内部类

定义类的最终目的是创建一个类的实例，但是如果某个类的实例只是用一次，则可以将类的定义与类的创建放到一起完成，或者说在定义类的同时就创建一个类。以这种方法定义的没有名字的类称为匿名内部类。

匿名内部类：顾名思义就是没有名字的类，匿名内部类是没有访问修饰符的。
匿名内部类所在方法的形参需要被匿名内部类使用时，这个形参必须是final。
匿名内部类是没有构造方法的，因为他没有类名。由于不知道类名，也不能使用关键字来创建该类的实例。实际上匿名内部类的定义、构造、和第一次使用都发生在同样一个地方。
匿名内部类中不能存在任何静态变量和方法。
匿名内部类必须继承一个抽象类或者实现一个接口，一般隐式的继承某一个父类或者实现某一个接口，不需要使用extends和implements关键字。但不能同时继承类和实现接口。
一个匿名内部类一定是在new的后面，用其隐含地实现一个接口或者实现一个类，没有类名，根据多态，我们使用其父类名。因为他是局部内部类，那么局部内部类的所有限制都对其生效。匿名内部类是唯一一种无构造方法类。
大部分匿名内部类是用于接口回调用的，匿名内部类在编译的时候由系统自动起名Out$1.class。如果一个对象编译时的类型是接口，那么其运行的类型为实现这个接口的类。
匿名内部类不能是抽象的，它必须要实现继承的类或者实现的接口的所有抽象方法。

public class Test {
    public static void main(String[] args) {
        /*
        正常情况下我们想调用Apple类中eat方法，我们会先new一个对象，然后初始化类
        Apple apple = new Apple();
        然后用对象名调用eat
        apple.eat();
        但是这里我们不需要去初始化，直接new
        */
        //没有名字初始化类,不用将实例保存到变量中
        new Apple().eat();
        //下面的也叫匿名内部类
        //new UserService()其实是长这样， UserService userService =  new UserService()
        new UserService(){
            @Override
            public void hello() {
            }
        };
    }
}
class Apple {
    public void eat() {
        System.out.println("1");
    }
}
interface UserService{
    void hello();
}

6.内部类的作用总结

（1）内部类可以实现多重继承问题：Java中只能继承一个类，多重继承在没有内部类之前是使用接口来实现的。但使用接口有时候有很多不方便的地方。比如我们实现一个接口就必须实现它里面的所有方法。而有了内部类就不一样了，它可以使我们的类继承多个具体类或抽象类。
（2）内部类可以解决同时继承类和实现接口的时候，类和接口中出现同名方法的情况。
（3）内部类提供了更好的封装和隐藏，除了外部类，其他类都不能访问内部类。而且，一般外部类，是不允许有private和protected权限的，但是内部类可以。
（4）内部类中的属性和方法，即使是外部类也不能直接访问，相反，内部类拥有外部类所有元素的访问权限，可以直接访问外部类的属性和方法，即便是private。
（5）内部类可以有多个实例，每个实例都有自己的状态信息，并且与其他外部类对象的信息相互独立。
（6）在单个外部类中，可以让多个内部类以不同的方式实现同一个接口，或者继承同一个类，不受外部类是否继承接口影响。
（7）内部类并没有令人迷惑的“is-a”关系，他就是一个独立的实体。
（8）有利于回调函数的编写。