06 面向对象

01 什么是面向对象

面向对象的本质以类的方式组织代码，以对象的组织封装数据
三大特性：封装，继承，多态（顺序固定）

02 回顾方法的定义

package com.kuang.oop.demo01;

import java.io.IOError;
import java.io.IOException;

public class Demo01 {
    public static void main(String[] args) {
        System.out.println();
    }

/*
    修饰符 返回值类型 方法名（...){
        //方法体
        return 返回值;
    }
 */
//break停止switch和跳出循环
//return结束方法，返回一个结果
//方法名要见名知意
//    参数列表(参数类型，参数名)..
//    抛出异常
    public String sayHello(){
        return "hello,world";
    }
    public void print(){
        return;
    }
    public int max(int a,int b){
        return a>b? a:b; //三元运算符
    }

    public void readFile(String file) throws IOException{

    }
}

03 回顾方法的调用

• 静态方法，通过类名直接调用
  
• 动态方法，需要实例化（new）后再调用
  
  也可以改为：

Demo02 demo02 = new Demo02();
demo02.say();

静态方法的加载

非静态方法可以互相调用，这里死循环了不用在意

同为静态方法也可以相互调用

但在a方法为静态，b方法为非静态就无法调用了
因为静态方法与类同时加载，而非静态方法在类实例化后才存在，时间线不同所以不可调用

值传递与引用传递

值传递：

在调用change()方法后改变的是形式参数a的值，并没有返回值，所以main方法中的a的值不变，仍为1。

引用传递

package com.kuang.oop.demo01;
//引用传递:对象，本质还是值传递
//类似于指针传递
public class Demo05 {
    public static void main(String[] args) {
        Person person = new Person();
        System.out.println(person.name);

        Demo05.change(person);
        System.out.println(person.name);
    }
    public static void change(Person person){
        //person是一个对象，指向的是--->Person person = new Person();这是一个具体的人，可以改变属性
        person.name = "好哥哥";
    }

}
class Person{
    String name;
}

类似于C语言中的指针引用传递。

04 类与对象的创建

• 对象就是类的具体实例化。
• 使用new关键字创建对象
• 面向对象编程的本质就是以类的方式组织代码，以对象的方式封装数据。

05 构造器详解

-使用new关键字创建的时候，除了分配内存空间之外，还会给 创建好的对象进行默认的初始化和对类中构造器的调用。
构造器必须掌握

• 建立一个类Teacher，在测试类中建立Teacher类对象。即使Teacher类中什么也没写也可以调用。
• 通过java文件编译后生成.class文件查看：
  
  Teacher类中有默认的构造方法。

public class Person {
    //显示的定义和构造
    String name;
    int age;
    //alt+insert

    public Person() {
    }

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

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

}
/*
 public static void main(String[] args) {
        //实例化一个对象
        Person person = new Person("wsh",20);
        System.out.println(person.name);
    }
    构造器：
       1和类名相同
       2没有返回值
    作用：
        1new本质在调用构造方法
        2初始化对象的值
    注意点：
        1定义有参构造方法后，若要调用无参构造方法，必须显示定义

     Alt+insert
    this表示当前类
 */

06 创建对象内存分析（便于理解，真正的内存很复杂）

首先加载测试类Application，

07 简单小结类与对象

1.类与对象
类是一个模板：抽象，对象是一个具体的实例
2.方法
定义、调用
3.对应的引用
引用类型： 基本类型（8）
对象是通过引用来操作的：栈--》堆
4.属性：字段Field 成员变量
默认初始化：
数字：0 0.0
char: u0000
boolean:false
引用：null

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

5.对象的创建和使用

• 必须使用new关键字创建对象，构造器 Person kuangshen = new Person();
• 对象的属性 kuangshen.name
• 对象的方法 kuangshen.sleep()
  6.类
  静态的属性 属性
  动态的行为 方法

封装、继承、多态

08封装详解

该露的露，该藏的藏

“高内聚，低耦合”，高内聚就是类的内部数据操作细节自己完成，不允许外部干涉；低耦合，仅暴露少量的方法给外部使用。
对于代码来说，就是属性私有，get/set

package com.kuang.oop.demo04;
/*
封装
1、提高代码的安全性
2、隐藏代码实现细节
3、统一接口get/set
4、系统可维护
记住这句话：属性私有，get/set
 */
public class Student {
    //封装大多数是对于属性来的
    //类 private 私有 属性私有
    public String name;  //姓名
    private int id;  //年龄
    private char sex;  //性别
    private int age; //年龄
    //提供一些 可以操作这些属性的方法！
    //提供一些public的get、set方法

    //get 获得这个数据
    public String getName(){
        return this.name;
    }
    //set 设置值
    public void setName(String name){
        this.name=name;
    }
    //alt+insert生成get/set方法

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if(age<120||age>0)
            this.age = age;
        else
            this.age=3;
    }
}

09 什么是继承

• extends的意思是“扩展”，子类是父类的继承
• java类中只有单继承，没有多继承-----儿子可以有多个，爹只能有一个
• 继承是类与类之间的关系，除此之外，还有依赖，组合，聚合等。
• 继承关系的两个类，一个为子类，一个为父类，子类继承父类，使用关键字extends来表示。
• 子类和父类之间，从意义上应该有“is a”的关系。
  建立一个包demo05，存放三个类，Person，Student类。

package com.kuang.oop.demo05;
//java中所有的类都默认直接或间接继承了Object类
public class Person /*extends Object*/{
    //public
    //protected
    //default
    //private
    private int money = 10_0000_0000;

    public int getMoney() {
        return money;
    }

    public void setMoney(int money) {
        this.money = money;
    }

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

这里的Person类为父类，Object类为所有类的父类（基类）

package com.kuang.oop.demo05;
//学生 is 人
//子类继承了父类，就会拥有父类的全部方法
public class Student extends Person{
    //CTRL+H 继承树
}

Student类继承了Person类，在建立学生对象后即可调用父类的方法run()

• ctrl+h 可以在右边查看继承树
  
• 在测试类中建立Student类的对象，点 一下可以查看可调用方法
  
  上方红框内为Person类的方法，下方框内为Object类的方法。

10 Super详解

//父类 Person类
public class Person /*extends Object*/{
    protected String name = "kuangshen";
    public void print(){
        System.out.println("Person");
    }
}

//Student类 
package com.kuang.oop.demo05;
//学生 is 人
//子类继承了父类，就会拥有父类的全部方法
public class Student extends Person{
    //CTRL+H 继承树
    private String name = "qinjiang";
    public void test(String name){
        System.out.println(name); //秦疆
        System.out.println(this.name);  //qinjiang
        System.out.println(super.name);//kuangshen
        
    }
}

输出的三个结果分别为方法的参数，当前类的属性name，父类的属性name

同样的对于方法，

package com.kuang.oop.demo05;
//学生 is 人
//子类继承了父类，就会拥有父类的全部方法
public class Student extends Person{
    //CTRL+H 继承树
    private String name = "qinjiang";
    public void print(){
        System.out.println("Student");
    }
    public void test1(){
        print(); //Student
        this.print(); //Student
        super.print(); //Person
    }
}

显示定义Person类和Student类的构造方法，

只建立一个Student对象会发现，Person类和Student类的构造方法都被执行了。

隐藏代码：调用了父类的无参构造
调用父类的构造器，必须要在子类构造器的第一行

super注意点：
    1、super调用父类的构造方法，必须在构造方法的第一个
    2、super必须出现在子类的方法或者构造方法中！
    3、super和this不能同时调用构造方法

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

11 方法重写

首先定义两个静态方法，结果为AB

非静态方法时，结果都为A
即b是A new 出来的对象，因此调用的是A的方法。
因为静态方法是类的方法，而非静态是对象的方法。
有static时，b调用了B类的方法，因为b是用b类定义的
没有static时，b调用的是对象的方法，而b是用A类new的
区别：静态与非静态 重写与静态方法没有任何关系，静态方法在类加载时就已经出来了
主要是和非静态方法有关。

重写：需要有继承关系，子类重写父类的方法！
    1.方法名必须相同
    2.参数列表必须相同
    3.修饰符：范围可以扩大，但是不能缩小private->protected->Deafault->public
    4.抛出的异常：范围，可以被缩小，但不能扩大；ClassNotFoundException -->exception(大）
重写：子类的方法和父类必须要一致，方法体不同！

为什么需要重写：
    1.父类的功能，子类不一定需要，或者不一定满足

初期可能不太理解，没有关系，也可以死记硬背一些，在后面的使用中去慢慢理解。

12 什么是多态

• 即同一方法可以根据发送对象的不同而采用多种不同的行为方式。

• 一个对象的实际类型是确定的，但可以指向的引用的类型很多。

• 多态存在的条件

  • 有继承关系
  • 子类重写父类的方法
  • 父类引用指向子类对象

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

///测试类
package com.kuang.oop;
import com.kuang.oop.demo06.Person;
import com.kuang.oop.demo06.Student;


//静态与非静态的方法区别很大！
public class Application {
    public static void main(String[] args) {
        //一个对象的实际类型是确定的
        //new Student();
        //new Person();

        //可以指向的引用类型就不确定了，父类的引用指向子类
        Student s1 = new Student();
        //Person父类型，可以指向子类，但是不能调用子类独有的方法
        Person s2 = new Student();
        Object s3 = new Student();

        //对象能执行哪些方法，主要看对象左边的类型，和右边关系不大
        s2.run();
        
    }
}

执行结果为：
run

子类Student继承父类方法，则调用输出run。

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

子类Student重写run方法，则优先调用子类方法，输出son.run。

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

在子类中添加eat方法，发现s2不可调用eat方法，因为父类不可调用子类独有的方法。
father f1 = new son();
意思就是new了一个子类的对象，子类的对象里面有继承父类的方法。

多态注意事项：
1.多态是方法的多态，属性没有多态
2.父类和子类有联系 类型转换异常ClassCastException
3.存在条件： 继承关系，方法需要重写，父类的引用指向子类对象！

不可实现多态：
1.static 方法，属于类，不属于实例
2.final常量
3.private方法

instance of 和类型转换

instanceof 是 Java 的保留关键字。它的作用是测试它左边的对象是否是它右边的类的实例，返回 boolean 的数据类型。

package com.kuang.oop;
import com.kuang.oop.demo06.Person;
import com.kuang.oop.demo06.Student;
import com.kuang.oop.demo06.Teacher;
//instanceof 是 Java 的保留关键字。
// 它的作用是测试它左边的对象是否是它右边的类的实例，返回 boolean 的数据类型。
public class Application {
    public static void main(String[] args) {
        //Object > String
        //Object > Person > Teacher
        //Object >Person> Student
        Object ob = new Student();

        System.out.println(ob instanceof Student);
        System.out.println(ob instanceof Person);
        System.out.println(ob instanceof Object);
        System.out.println(ob instanceof Teacher);
        System.out.println(ob instanceof String);
        System.out.println("=======================");
        Person person = new Person();
        System.out.println(person instanceof Student);
        System.out.println(person instanceof Person);
        System.out.println(person instanceof Object);
        System.out.println(person instanceof Teacher);
        //System.out.println(person instanceof String);    //编译报错
    }
}

static 关键字详解