Study13（从小白到大佬）

面向对象

什么是面向对象

• 面向对象编程（Object-Oriented Programming,OOP）

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

• 抽象

• 三大特征：

  • 封装
  • 继承
  • 多态

---

类与对象的创建

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

---

构造器详解

构造器：

​ 1.和类名相同

​ 2.没有返回值

作用：

​ 1.new本质在调用构造方法

​ 2.初始化对象的值

注意点：

​ 1.一个类即使什么都不写，也会存在一个空的构造方法

​ 2.定义有参构造后，无参构造消失，如果想使用无参构造，就必须显式定义无参构造，即创建一个空函数体的无参构造

​ 3.alt+Insert快捷键创建构造器

​ 4.this.name指代当前对象name

---

创建对象内存分析

---

封装

• 该露的露，该藏的藏

  • 我们程序设计要追求**“高内聚，低耦合”**。高内聚就是类的内部操作细节自己完成，不允许外部干涉；低耦合：仅暴露少量的方法给外部使用。

• 封装（数据的隐藏）

  • 通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏。

• 记住：属性私有get/set（快捷键：Alt+Insert）

//主函数
package com.hao.OOP;

import com.hao.OOP.Demo04.Student;

public class Application {
    public static void main(String[] args) {
        Student s1 = new Student();
        s1.setAge(13);
        System.out.println(s1.getAge());
    }
}
//学生类
package com.hao.OOP.Demo04;

public class Student {
    private String Name;
    private int Age;


    public String getName() {
        return this.Name;
    }

    public void setName(String name) {
        this.Name = name;
    }

    public int getAge() {
        return this.Age;
    }

    public void setAge(int age) {
        this.Age = age;
    }
}

---

继承

• JAVA中类只有单继承，没有多继承！（一个父有多个儿，一个儿只有一个父）。
• 继承是类和类之间的一种关系。除此之外，类和类之间的关系还有依赖，组合，聚合等。
• 子类继承父类，使用关键字extends来表示。public class Teacher extends Person
• 继承后，子类拥有父类的全部方法。
• 快捷键Ctrl+H打开继承树
• 在JAVA中，所有的类都默认直接或间接继承Object类

---

super

super：调用父类对象和方法

1. 私有属性不可继承
2. this/super调用方法的方式跟调用属性相同
3. 子类new了一个对象后，会先执行父类的无参构造，再执行子类的无参构造
4. 调用父类的构造器（super();），或者调用自身（this(形参);）有参构造，必须在子类构造器函数体里的第一行，所以super和this不能同时调用构造方法。

重写

重写：需要有继承关系，子类重写父类的方法！

1. 方法名，参数列表必须相同，方法体不同

2. 修饰符：范围可以扩大但不能缩小（假设private可以继承，父类private，子类可以public）
3. public>protected>default（默认）>private
4. 抛出的异常：范围可以缩小但不能扩大

为什么需要重写：

• 父类的功能，子类不一定满足

快捷键：Alt+Insert，选中override

---

多态

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

//Person父类
package com.hao.OOP.Demo06;

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


}


//Student子类
package com.hao.OOP.Demo06;

public class Student extends Person{

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

    public void eat(){
        System.out.println("eat");
    }
}


//Application主函数
package com.hao.OOP;

import com.hao.OOP.Demo06.Person;
import com.hao.OOP.Demo06.Student;

public class Application {
    public static void main(String[] args) {
        //一个对象的实际类型是确定的，可以指向的引用类型不确定
        Student s1 = new Student();
        Person s2 = new Student();//new Stuedent(实际类型)		Person(引用类型)
        Object s3 = new Student();

        s1.run();//son		
        s2.run();//son		//子类重写了父类的方法(子类父类都有run)，执行子类

        //父类不能调用子类独有的方法
        //Person无法直接调用eat()，但是可以类型转换
        ((Student)s2).eat();		//eat
    }
     }

注意事项：

1. 多态是方法的多态，属性没有多态
2. 父类和子类要有联系才能转换，否则转换异常！ClassCastException!
3. 存在条件：继承关系，方法需要重写，父类引用指向子类对象！Father f1 = new Son();

哪些方法不能被重写？

1. static方法，静态的，属于类，不属于实例
2. final，常量，被final修饰也不能重写
3. private方法

---

instanceof和类型转换

X和Y存在直系父子关系，则TRUE，同级比较，则编译错误

类型之间的转换：（同基本类型的强制转换相似）

Person obj = new Student();//高->低：自然转换

Student student = (Student) obj;//低->高：强制转换

Person person = student;//Person转成student，自然转换，但是转换后会失去子类独有的方法

---

static关键字详解

package com.hao.OOP.Demo07;

public class Student {
        //想要很多类去操作这个变量，就可以定义静态
    private static int age; //静态变量  到后面多线程会具体讲解，先了解
    private double score;   //非静态变量


    public void run(){

    }

    public static void go(){

    }



    public static void main(String[] args) {
        //属性
        Student s1 = new Student();

        System.out.println(Student.age);/*如果是静态的就推荐使用类名去使用，
                                          很明显知道是静态。*/
        System.out.println(s1.age);
        System.out.println(s1.score);

        //方法
        Student.go();//静态的可以不new直接调用
        go();        //同个类中的静态方法可以不加类名.

    }
}

package com.hao.OOP.Demo07;

public class Person {
    {
        System.out.println("匿名代码块");//2 和对象同时产生，一般可以用来赋初值
    }

    static{
        System.out.println("静态代码块");//1 只执行1次
    }

    public Person() {
        System.out.println("构造方法");//3
    }

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

package com.hao.OOP.Demo07;

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

public class Test {
    public static void main(String[] args) {
        System.out.println(random());
        System.out.println(PI);

    }
}

---

抽象类

package com.hao.OOP.Demo08;

//抽象类
public abstract class Action {
    //约束~希望有人帮我们实现
    //抽象方法，只有方法名字，没有方法的实现！
    public abstract void doSomething();
}

package com.hao.OOP.Demo08;

//抽象类的所有方法，继承它的子类需要重写父类的抽象方法，除非子类也是抽象类
public class A extends Action{
    @Override
    public void doSomething() {

    }
}

1. 不能new这个抽象类，只能靠子类去实现它。约束！
2. 抽象类中可以写普通的方法，有抽象方法的类必须是抽象类

思考：

• 既然不能new对象，那是否存在构造器？
• 存在的意义是什么？

---

接口

普通类：只有具体实现

抽象类：具体实现和规范（抽象方法）都有

接口：只有规范！自己无法写方法~专业的约束！ 可以实现约束和分离：面向接口编程

接口的本质是契约，就像人间的法律，制定后都必须遵守。

OO的精髓，是对对象的抽象，最能体现这一点的就是接口。

//接口

package com.hao.OOP.Demo09;

//interface定义的关键字
public interface UserService {
    //常量,默认修饰public static final
    int AGE=99;
    //很少人会用，一般不会这么用


    //接口中所有的方法都默认修饰 public abstract
    void add(String name);
    void delete(String name);
    void udpate(String name);
    void query(String name);
}

//锻炼抽象的思维->架构师

//实现接口的类

package com.hao.OOP.Demo09;

//抽象类：extends
//类 可以实现接口 implements接口
//实现了接口的类，就需要重写接口中的方法

//多继承->利用接口实现public class UserServiceImpl implements UserService,接口1,接口2
public class UserServiceImpl implements UserService{
    @Override
    public void add(String name) {

    }

    @Override
    public void delete(String name) {

    }

    @Override
    public void udpate(String name) {

    }

    @Override
    public void query(String name) {

    }
}

接口的作用：

1. 约束
2. 定义一些方法，让不同的人实现。（10个人实现同一个接口，10种不同的方式）
3. 接口没有构造方法（实现类），不能被实例化
4. implement可以实现多个接口
5. 必须要重写接口中的方法

内部类（了解）