1 面向对象

面向对象是编程的一种思维方式。
分析思路：面对程序设计时，分析有什么对象，对象有什么数据（属性），对象有什么操作方法。

2 对象

万事万物都是对象
对象强调的是一个具体的个体
例如：杨树就不是对象，在小河边的那个杨树才是对象，强调的是个体。

2.1 对象的构成

2.1.1对象是由数据和操作构成

对象的状态是指对象的数据，对象的状态由变量表示，也叫对象的属性。
对象的行为是指对象的功能，对象的行为由方法表示。
例如：

学生对象{
    数据：姓名、成绩
    行为：听课，做作业
}

2.1.2对象的创建

对象是由类实例化时创建的，因此创建对象必须先定义类。
类是对象的模板，类中定义了什么属性和方法，由这个类实例化的对象就有什么属性和方法。
类是一次性定义，对象可以多次创建。

3 类

3.1 类的定义

类是具有相同的状态和相同的行为的一组对象的集合。

3.2 类和对象的关系

类和对象的关系就如同模具和用这个模具制作出来的物品之间的关系。一个类给出它的全部对象的一个统一的定义，而它的每个对象则是符合这种定义的一个实体（也称作实例），因此类和对象的关系就是抽象和具体的关系。

3.3 类的构成

类是由属性和方法构成的

3.4 类的创建

public class 类名 {
    //可编写0至n个属性
    数据类型 变量名1；
    数据类型 变量名2；
    
    //可编写0至n个方法
    修饰符 返回值类型 方法名(参数){
        执行语句;
    }
}

示例：

public class Student {
    //类的属性（类的状态）
    String name; 
    int score;
    String no;
    //类的方法（类的行为）
    public void play(){
        System.out.printf("我的名字是%s,我的成绩是%d,我的学号是%s",name,score,no);
    }
}

注意：

public类的类名必须和类所在文件的文件名一致

如果不是public类，那么类名与类所在的文件名可以不一致

类名的命名规范是：帕斯卡命名法

4 实例化对象

通过类创建对象的过程称为类的实例化。实例化的结果是产生了一个实例，实例也叫对象。

类名 对象名 = new 类名();

示例：

Student s1 =new Student();
Student s2 =new Student();

5 类和对象的区别

类是对某一类事物的抽象描述，不是具体的个体
对象是对某一事物的具体描述，是具体的个体

6 方法的重载

在同一个类中：同名不同参，与返回值无关。
示例：

public class Student{
    public void play(){
        
    }
    public int play(int time){
        return 0;
    }
}

7 构造方法

构造方法也叫构造函数，或者叫构造器

构造方法的方法名必须与类名相同
构造方法没有返回值，也不写void
示例：

class Student {
    //构造方法
    Student(){

    }
}

7.1 构造方法的作用

为对象的属性初始化。

8 变量

变量分为局部变量和成员变量

8.1 局部变量

定义在方法中的变量
示例：

 public void sayHello(){
      int height = 20;//局部变量
}

8.2 成员变量

成员变量是类的属性，是定义在类内，方法外的变量。
示例：

class Student {
    String name;
    int score;
    String no;
}

9 面向对象的三大特性

9.1 封装

为了保护数据，用访问修饰符实现封装

9.1.1 访问修饰符

public：公共的
protected：受保护的
默认 | default（什么都不写）
private：私有的

9.1.1.1 public

public修饰的属性没有访问限制，是最宽松的封装。
示例：

public class Person {
    public String name;//公有
}

name可以在任何地方被访问呢，也就是可以读和写
pubilc修饰类：类可以在任何地方被访问
public修饰属性和方法：属性和方法可以在任何地方被访问

9.1.1.2 protected

被protected修饰的属性或方法在子类中一定可以访问。无论子类是否与父类在一个包里。同包也可以访问。
示例：

package com.sunmer.tmp;

public class Father {
    protected int age;
    int weight;
}

package com.sunmer.tmp;

public class Sub1 extends Father{
    public static void main(String[] args) {
        Sub1 sub1 = new Sub1();
        sub1.age= 1;//可以访问
        sub1.weight = 1;//可以访问
    }
}

package com.sunmer.oop;
import com.sunmer.tmp.Father;
public class Sub2 extends Father {
    public static void main(String[] args) {
        Sub2 sub2 = new Sub2();
        sub2.age = 0;//可以访问
    }
}

9.1.1.3 private

private修饰的属性只能在类内被访问，类外无法访问，是最严格的封装。
示例：

public class Person {
    private String name;//私有
}

name属性只能在Person类的类内使用，类外无法使用。

注意：

private不能修饰类

private class Classinfo{//报错，private不能修饰类

}
public class Student {

}

private可以修饰类的成员，无论类的成员是什么。
示例：

public class Student {
    int age;
    private class Classinfo{//不报错，因为Cassinfo类是Student类的成员

    }
}

9.2 继承

9.2.1 继承的优点

继承的出现提高了代码的复用性，提高软件开发效率。
继承的出现让类与类之间产生了关系，提供了多态的前提。

9.2.2 继承的定义

在程序中，如果想声明一个类继承另一个类，需要使用extends关键字。

class 子类 extends 父类 {
    
}

9.2.3 继承的注意事项

9.2.3.1 类只支持单继承，不允许多继承

class A{} 
class B{}
class C extends A,B{}  // C类不可以同时继承A类和B类

9.2.3.2 多个类可以继承一个父类

class A{}
class B extends A{}
class C extends A{}   // 类B和类C都可以继承类A

9.2.3.3 允许多层继承

class A{}
class B extends A{}   // 类B继承类A，类B是类A的子类
class C extends B{}   // 类C继承类B，类C是类B的子类，同时也是类A的子类

9.3 多态

多态就是多种形态，多种形式。

9.3.1 多态的语法格式

多态的定义格式：就是父类的引用变量指向子类对象

父类类型  变量名 = new 子类类型();
变量名.方法名();
Pet pet = new Cat();
pet.toString();

面向对象简述（oop）