跟着大佬学java第八课，面向对象编程（一）

面向对象编程

什么是面向对象

本质

以类的方式组织代码，以对象的组织（封装）数据

三大特性

封装、继承、多态

认识

1. 从认识论角度考虑是先有对象后又类。对象，是具体的事物。类，是抽象的，是对对象的抽象
2. 从代码运行角度考虑是先有类后有对象，类是对象的模板

方法回顾

方法的定义

修饰符、返回类型、break和return的区别、方法名、参数列表（参数类型 参数名，……）、异常抛出

方法的调用

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

代码演示

异常抛出

import java.io.IOException;

public class Demo01 {
    public static void main(String[] args) {
    }

    /*
    * 修饰符 返回值类型 方法名（参数）{
    * 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{
    }
}

静态方法与非静态方法

package oop.Demo01;

public class Student {

    //静态方法
    public static void say(){
        System.out.println("学生说话了!");
    }

    //非静态方法
    public void notSay(){
        System.out.println("学生没有说话");
    }
}

package oop.Demo01;

public class Demo02 {
    //静态方法和非静态方法
    public static void main(String[] args) {

        //静态直接调用
        Student.say();

        //非静态，实例化后调用
        Student student = new Student();
        student.notSay();
    }

    //static 和类一起加载
    public static void a(){
//        b();
    }

    //类实例化之后才存在
    public void b(){}

    //所以方法a不能调用方法b，加载时间不同
}

形参和实参

package oop.Demo01;

public class Demo03 {
    //形参和实参
    public static void main(String[] args) {

        //实际参数和形式参数的类型要对应
        Demo03 demo03 = new Demo03();
        int add = demo03.add(1, 2);
        System.out.println(add);
    }

    public int add(int a, int b){
        return a+b;
    }
}

值传递

package oop.Demo01;

public class Demo04 {
    //值传递，只是将值传递给形参change(int a),main方法里的a无影响
    public static void main(String[] args) {
        int a = 1;
        System.out.println(a);      //结果为1

        Demo04.change(a);
        System.out.println(a);      //结果为1
    }

    //返回值为空
    public static void change(int a){
        a = 10;
    }
}

引用传递

package oop.Demo01;

//对象、内存结构

public class Demo05 {
    //引用传递，对象，本质还是值传递
    public static void main(String[] args) {
        Person person = new Person();
        System.out.println(person.name); //null

        Demo05.change(person);
        System.out.println(person.name);//老秦
    }

    public static void change(Person person){
        //person是一个对象，指向的是  Person person = new Person();这是一个具体的人，可以改变属性
        person.name = "老秦";
    }
}

//定义了一个Person类，有一个属性：name
class Person{
    String name;
}

类与对象的关系

1. 类是一种抽象的数据类型，它是对某一类事物政务描述/定义，但是并不能代表某一个具体的事物
   1. 用来描述/定义某一类具体的事物应该具备的特点和行为
2. 对象是抽象概念的具体实例
   1. 能够体现出特点，展现出功能的是具体的实例，而不是一个抽象的概念

创建与初始化对象

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

代码演示

类名和构造方法

package oop.Demo02;

public class Student {

    //属性、字段
    String name;       //null
    int age;        //0

    //方法
    public void study(){
        System.out.println(this.name+"在学习");
    }
}

使用new创建对象

package oop.Demo02;

//一个项目应该只存在一个main方法
public class Application {
    public static void main(String[] args) {

        //实例化一个对象
        Student xiaoming = new Student();
        System.out.println(xiaoming.name);  //nuLl
        xiaoming.name = "小明";
        System.out.println(xiaoming.name);  //小明

    }
}

构造器详解

实例化对象

调用构造器，需要实例化一个新对象

package oop.Demo02;

//一个项目应该只存在一个main方法
public class Application {
    public static void main(String[] args) {

        //实例化一个对象
        Person person = new Person();

//        System.out.println(person.name);//person中未初始化，null
        System.out.println(person.name);//person中进行初始化后，老秦
    }
}

创建构造器

package oop.Demo02;

public class Person {

    //一个类即使什么都不写，也会存在一个方法，在class文件中，无参构造不显示
    String name;

    //无参构造，初始化信息
    //1.使用new关键字，本质是在调用构造器
    //2.用来初始化值
    public Person(){
        this.name = "老秦";
    }

    //重载
    //有参构造，一旦定义了有参构造，无参构造就必须显示定义
    public Person(String name){
        this.name = name;
    }
}

特点

1. 和类名相同
2. 没有返回值

作用

1. new本质在调用构造器
2. 初始化对象的值

注意点

1. 定义有参构造之后，如果想使用无参构造，显示的定义一个无参的构造

快捷键：alt + insert

小结

1. 类与对象

   类是一个模板，抽象。

   对象是一个具体的实例

2. 方法

   定义+调用

3. 对应的引用

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

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

4. 属性

   字段Filed 成员变量

   默认初始化：

   ​	数字：0   0.0

   ​	char： u0000

   ​	boolean：false

   ​	引用：null

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

5. 方法的创建和使用

   必须使用new关键字创建对象，构造器 Person person = new Person

   对象的属性 person.name

   对象的方法 person.changeName()

6. 类：

   静态的属性	属性

   动态的行为	方法

   封装、继承、多态