1. 什么是面向对象

面向过程：从上到下一步步按顺序执行 线性思维

面向对象：物以类聚，分类的模式

面向对象编程：本质是以类的方式组织代码，以对象的形式（封装）数据。

抽象

三大特性：

• 封装
• 继承
• 多态

先有对象后有类，对象是具体的事物，类是对对象的抽象

从代码层面，先有类后有对象，类是对象的模板。

2. 回顾方法及加深

方法定义：

修饰符/返回类型/switch/break return区别/方法名/参数列表/异常抛出

方法的调用：

静态方法/非静态方法/形参和实参/值传递和引用传递/this关键字

3. 回顾方法调用

静态方法，直接类名.方法名；

非静态方法，实例化类，用类对象调用。

静态方法不能调用非静态方法；（前者和类一起存在，后者实例化后才存在，存在调用不存在，所以不行）

非静态方法是可以调用静态方法的。

值传递：

//值传递
public class Demo02 {
    public static void main(String[] args) {
        int a = 1;
        System.out.println(a);

        // 虽然调用传进去1，但是a形参是临时变量,和内部的a不是一个东西
        Demo02.change(a);
        System.out.println(a);  // 1   java是值传递
    }
    public static void change(int a) {
        a = 10;
    }
}

引用传递：传递对象，本质还是值传递

//引用传递
public class Demo03 {
    public static void main(String[] args) {
        Person person = new Person();
        System.out.println(person.name); // null

        Demo03.change(person);

        System.out.println(person.name); // 蔡运来
    }

    public static  void change(Person person) {
        // person是一个对象，指向类的实例，是具体的人，可以改变值
        person.name = "蔡运来";
    }
}

//定义一个Person类
class Person{
    String name;
}

4. 类与对象的创建

类与对象的关系：

• 类是一种抽象的数据类型，它是对某一类事物整体描述/定义，但是并不能代表某一个具体的事物。
• 对象是抽象概念的具体实例

创建与初始化对象：

• 使用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 = new Student();
        student.name = "小明";
        student.age = 3;
        System.out.println(student.name + student.age);  // name为赋值前默认是null
    }
}

5. 构造器详解

构造器必须要掌握！

默认无参构造；

使用new本质在调用无参构造器；

使用有参构造时，必须显示定义无参构造

public class Person {
    // 一个空类也会有一个构造方法
    // 显示定义构造器
    String name;
    // 1. 构造器第一个作用，实例化初始值
    // 使用new关键字，本质是在调用构造器
    public Person(){
        this.name = "Qinjiang";
    }
    // 有参构造器
    // 一旦定义有参构造，无参构造必须显式定义！
    public Person(String name) {
        this.name = name;
    }
    // Alt + insert  生成构造器

}

public class Application {
    public static void main(String[] args) {
        // new关键字实例化一个对象
        Person person = new Person("zhangsan");
        System.out.println(person.name);
    }
}

6. 创建对象内存分析

public class Pet {
    public String name;
    public int age;

    public void shout(){
        System.out.println("叫了一声");
    }
}

public class Application {
    public static void main(String[] args) {
        Pet dog = new Pet();  // 第①步
        dog.name = "旺财";
        dog.age = 3;
        dog.shout();

        System.out.println(dog.name);
        System.out.println(dog.age);
    }
}

第①步如下：

第②步：

第③步：

 Pet cat = new Pet();

栈中引用对象名指向的是堆中的数据。

方法区也属于堆。jdk8以后方法区移到本地内存了。

7. 小结

1. 类与对象

类是一个模板： 抽象； 对象是一个具体的实例

2. 方法

定义、调用！

3. 对象的引用

引用类型： 基本类型（8）

对象是通过引用来操作的： 栈->堆

4. 属性： 字段Field 成员变量

默认初始化： 数字，char，boolean，引用

修饰符 属性类型 属性名 = 属性值

5. 对象的创建和使用

必须用new关键字创建对象，调用构造器

对象的属性/方法

6. 类

静态的属性 属性

动态的行为 方法

8. 封装

• 该露的露，该藏的藏

程序设计要求 高内聚，低耦合

• 封装（数据的隐藏）

通常，应禁止直接访问一个对象中数据的实际表示，而应通过接口来访问。

• 属性私有 get/set

public class Student {

    private String name; // 名字
    private int id;  // 学号
    private char sex;  // 性别

    // 提供一些可以操作这个属性的方法
    // 提供一些public的get、set方法

    // get  获取这个数据
    public String getName(){
        return this.name;
    }
    // set 给这个属性设置值
    public void setName(String name){
        this.name = name;
    }
}

public class Application {
    public static void main(String[] args) {
        Student s1 = new Student();
        s1.setName("Qinjiang");
        System.out.println(s1.getName());
    }
}

鼠标右键 generate 生成 set/get方法。

封装的意义：

• 提高程序安全性，保护数据
• 隐藏代码实现细节
• 统一接口
• 提高系统的可维护性

方法重载：比如println的重载方法

9. 继承

继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模。

extends的意思是“扩展”。子类是父类的扩展。

java中只有单继承，没有多继承！

继承是类和类之间的一种关系；

继承关系的两个类，一为子类（派生类），一为父类（基类）。子类继承父类，使用关键字extends表示。

子类获得父类所有的public属性和方法。

// Person  人
public class Person {
    public void say(){
        System.out.println("说了一句话");
    }
}

// Student  学生   人
public class Student extends Person{

}

public class Application {
    public static void main(String[] args) {
        Student student = new Student();
        student.say();
    }
}

Ctrl + H 右侧显示继承树

在Java中所有的类都默认继承Object类（祖宗类） , java.lang包下

10. 继承之super

super — 父

this — 自己

// Person  人
public class Person {

    protected String name = "Qinjiang";
}

public class Student extends Person{
    private String name = "zhangsan";
    public void test(String name){
        System.out.println(name);  // 传递给的参数
        System.out.println(this.name);   // 本类的属性值
        System.out.println(super.name);  // 父类的该属性值
    }
}

// 一个项目应只存在一个main方法
public class Application {
    public static void main(String[] args) {
        Student student = new Student();
        student.test("李四");
    }
}

// 输出
李四
zhangsan
Qinjiang

默认子类new对象时，先调用父类构造器，在调用子类构造器；另外，调用的父类构造器必须要在子类构造器的第一行。this同理。

// Person  人
public class Person {
    public Person(){
        System.out.println("Person无参执行了");
    }

    protected String name = "Qinjiang";

    public void say(){
        System.out.println("person说了一句话");
    }
}

public class Student extends Person{
    public Student(){
        // 默认调用super()父类构造器
        System.out.println("Student无参执行了");
    }

    private String name = "zhangsan";
    public void test(String name){
        System.out.println(name);  // 传递给的参数
        System.out.println(this.name);   // 本类的属性值
        System.out.println(super.name);  // 父类的该属性值
    }
    public void say(){
        System.out.println("student说了一句话");
    }

    public void test1(){
        say();
        this.say();
        super.say();
    }
}

一个类必有一个无参构造。

小结：super注意点

1. super调用父类的构造方法，必须在构造方法第一个
2. super必须只能出现在子类的方法或构造方法中
3. super和this不能同时调用构造方法
4. super代表父类对象的引用，只有继承情况下才可使用；this本身调用者，没继承也可用；
5. 构造方法：this() 本类构造 super() 父类构造

11. 继承之方法重写

方法static修饰：（静态方法不叫重写）

public class A extends B{
    public static void test(){
        System.out.println("A=>test()");
    }
}

public class B {
    public static void test(){
        System.out.println("B=>test()");
    }
}
public class Application {
    public static void main(String[] args) {
        // 方法的调用只和左边定义的数据类型有关
        A a = new A();
        a.test();   // 调用A类方法

        // 父类的引用指向了子类 !!!
        B b = new A();
        b.test();   // 调用B类方法
    }
}

方法的重写（去掉static修饰的普通方法）：

public class B {
    public void test(){
        System.out.println("B=>test()");
    }
}
public class A extends B{
    @Override   //注解  表示重写
    public void test(){
        System.out.println("A=>test()");
    }
}
public class Application {
    public static void main(String[] args) {
        // 方法的调用只和左边定义的数据类型有关
        A a = new A();
        a.test();   // 调用A类方法

        // 父类的引用指向了子类
        B b = new A();
        b.test();   // 调用A类方法
    }
}
//输出
A=>test()
A=>test()

因为非静态方法子类重写了父类的方法，相当于覆盖了父类方法，所以new的子类实例调用的就是子类方法。

总结:

• 前提：继承关系，且子类重写父类的方法

• 方法名必须相同

• 参数列表必须相同

• 修饰符：范围可以扩大，但不能缩小 public > protected > default > private (即子类可以扩大父类方法的范围重写)

• 抛出的异常：范围可以缩小但不能扩大（异常抛出范围不能大于父类） 例如：ClassNotFoundException–>Exception

• 子类父类方法相同，方法体不同

为什么要重写？

• 父类功能子类不需要/不满足

12. 多态

• 即同一方法可以根据发送对象的不同而采用多种不同的行为方式
• 一个对象的实际类型是确定的（new谁就是谁），但可以指向对象的引用的类型有很多
• 多态存在的条件
  • 有继承关系
  • 子类重写父类方法
  • 父类引用指向子类对象
• 多态 是方法的多态，属性没有多态

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

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

public class Application {
    public static void main(String[] args) {
        Student s1 = new Student();
        Person s2 = new Student(); // 父类引用指向子类对象
        Object s3 = new Student();

        s2.run(); // 子类重写父类方法后，都执行子类方法
        s1.run(); // 子类没有重写父类方法时，都执行父类方法
    }
}

子类可调用方法是 自己的或继承父类的；

父类只能调用自己的，不能调用子类独有的。

多态注意事项：

• 父类和子类有联系才行，否则强转出现类型转换异常

• 被static/final/private修饰的方法不能被重写

• 运行期间才确定调用谁的方法

13. instanceof和类型转换

判断一个对象是什么类型。

对象名 instanceof 类名  //判断对象是否属于某一类类型

x instanceof y

两者有关系(x和y父子关系)才会编译通过，再去判断是不是该类型

// Person父类，Teacher/Student子类
public class Application {
    public static void main(String[] args) {

        // Object > Person > Student
        // Object > Person > Teacher
        // Object > String
        Object object = new Student();

        System.out.println(object instanceof Student);//true
        System.out.println(object instanceof Person);//true
        System.out.println(object instanceof Object);//true
        System.out.println(object instanceof Teacher);//false
        System.out.println(object instanceof String);//false
        System.out.println("====================================");
        Person person = new Student();
        System.out.println(person instanceof Student);//true
        System.out.println(person instanceof Person);//true
        System.out.println(person instanceof Object);//true
        System.out.println(person instanceof Teacher);//false
        //System.out.println(person instanceof String);//编译就报错
        System.out.println("====================================");
        Student student = new Student();
        System.out.println(student instanceof Student);//true
        System.out.println(student instanceof Person);//true
        System.out.println(student instanceof Object);//true
        //System.out.println(student instanceof Teacher);//编译就报错
        //System.out.println(student instanceof String);//编译就报错
    }
}

类型转换：

1. 父类引用指向子类对象
2. 把子类转换为父类 向上转型；
3. 把父类转换为子类，向下转型，要强制转换；
4. 方便方法调用，不需要重新new类，减少重复代码

public class Application {
    public static void main(String[] args) {
        //类型之间的转化   父   子
        //高              低
        Person obj = new Student();
        // obj想访问Student类的say方法,但是编译不通过
        //将这个obj对象转化为Student类型，就可以使用Student类的方法了
        // 高         低      强转
        ((Student) obj).say();

        //低转高，子类转父类对象失去访问自己方法的权限
        Student student = new Student();
        student.say();
        Person person = student;  //低转高自动就转过去了
        person.say();//报错，无法访问Student类方法
    }
}

14. static关键字讲解

使用一：

public class Student {

    private static int age;  //静态变量
    private double score;  //非静态变量

    public void run(){
        go(); //非静态方法可以调用静态方法
    }
    public static void go(){
        // 静态方法随类加载而加载，普通方法还未加载，所以访问不到
    }

    public static void main(String[] args) {
        Student s1 = new Student();
        System.out.println(s1.score); // 输出内容+ .sout回车
        System.out.println(s1.age);
        System.out.println(Student.age); // 直接类名调用

        Student.go();

    }
}

public class Person {
    {
        //代码块（匿名代码块）创建对象时产生，在构造器之前
    }
    static {
        //静态代码块 随类加载，永远执行一次
    }
}

public class Person {
    // 2   可通过这里赋初值
    {
        System.out.println("匿名代码块");
    }
    //执行顺序  1   但是只执行一次（尽管new多个对象）
    static {
        System.out.println("静态代码块");
    }
    //  3
    public Person(){
        System.out.println("构造方法");
    }

    public static void main(String[] args) {
        Person person1 = new Person();
        System.out.println("==================");
        Person person2 = new Person();
    }
}
//输出
静态代码块
匿名代码块
构造方法
==================
匿名代码块
构造方法

使用二：

//静态导入包~
import static java.lang.Math.random;

public class Test {
    public static void main(String[] args) {
        System.out.println(Math.random());
        //当不想输入Math类，只想输入random时
        //使用静态导入包，看最上面
        System.out.println(random());
    }
}

另外，final修饰常量，被修饰的类不能被继承。

15. 抽象类

• abstract 修饰符可以用来修饰方法也可以修饰类，修饰方法，方法就是抽象方法；修饰类，类就是抽象类；
• 抽象类中可以没有抽象方法，但是有抽象方法的类一定要声明为抽象类；
• 抽象类，不能用new关键字来创建对象，它是用来让子类继承的；
• 抽象方法，只有方法的声明，没有方法的实现，它是用来让子类实现的；
• 子类继承抽象类，就必须要实现抽象类没有实现的抽象方法，否则该子类也要声明为抽象类。

// abstract   抽象类    单继承
// java  接口可以多继承
public abstract class Action {

    // 约束，让别人帮我们实现
    // 抽象方法，只有方法名字，没有方法实现
    public abstract void doSomething();

    // 1. 不能new这个抽象类，只能靠子类去实现它  这就是约束
    // 2. 抽象类可以有普通方法
    // 3. 抽象方法必须在抽象类中
    // 思考：  不能new，那存在构造器吗？
    //         抽象类存在的意义？  将共有属性方法抽象出来
}

//抽象类的所有抽象方法，继承了它的子类都必须实现，否则(除非)该子类也是抽象类
public class A extends Action{
    @Override
    public void doSomething(){

    }
}

16. 接口的定义与实现

• 普通类：只有具体实现
• 抽象类：具体实现和规范（抽象方法）都有
• 接口：只有规范 没有实现 ———约束和实现分离：面向接口编程
• 接口就是规范，定义的是一组规则，体现了现实世界中“如果你是…则必须能…”的思想。例如如果你是汽车，则必须能跑
• 接口的本质是契约，就像我们的法律一样，大家一起遵守
• OO的精髓，是对对象的抽象，最能体现这一点的就是 接口。 我们讨论设计模式，都只是针对具备了抽象能力的语言，如c++,java,c#等，就是因为设计模式所研究的，正式如何合理的去抽象
• 声明接口的关键字是 interface

//关键就是抽象思维
public interface UserService {
    //接口中的所有定义都是默认  public abstract
    // 定义就是常量  public static final
    int age = 99;

    void add(String name);
    void delete(String name);
    void update(String name);
    void query(String name);
}

public interface TimeService {
    void time();
}

//类可以实现接口   implements 实现接口关键字
//实现了接口的类，必须重写接口中的方法

//利用接口实现了多继承
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 time() {

    }
}

接口作用：

1. 约束
2. 定义一些方法，让不同的人实现
3. public abstract
4. public static final
5. 接口不能被实例化，接口中没有构造方法
6. implements可以实现多个接口
7. 必须要重写接口中的方法

17. N种内部类

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

1. 成员内部类：

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

    public class Inner{
        public  void in(){
            System.out.println("这是内部类方法");
        }

        //获得外部类的私有属性、私有方法等
        public void getID(){
            System.out.println(id);
        }
    }
}

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

2. 静态内部类：

内部类加一个static关键字，即静态内部类；

静态内部类A就无法访问外部类B属性和方法，因为先实例化A，此时B没有实例化，访问不到。

3. 匿名内部类：

一个java文件只能有一个public class类，可以有多个class类。

即可以在类的外面再写一个类；

匿名内部类即初始化类时没有用变量保存实例。

public class Test {
    public static void main(String[] args) {
        // 没有名字去初始化类,不用将实例保存到变量中
        new Apple().eat();   //  1
        //没有名字初始化接口，实现重写接口方法
        new UserService(){
            @Override
            public void hello() {
                System.out.println("2");
            }
        }.hello();   //  2
    }
}

class Apple{
    public void eat(){
        System.out.println("1");
    }
}
interface UserService{
    void hello();
}

4. 局部内部类：

也可以在类内部方法里再写一个类：

public class Outer {

    // 局部内部类，类似局部变量
    public void method(){
        class Inner{
            public void in(){
                
            }
        }
    }
}