OOP
面向对象程序设计（Object Oriented Programming，OOP）是编写程序时的一种思维方法。
特性
(1)封装
(2)继承
(3)多态
对象
万事万物皆对象，对象强调的是一个具体的个体。
对象对象由状态和行为构成。
对象的状态是指对象的数据，对象的状态由变量表示，也叫对象的属性。
对象的行为是指对象的功能，对象的行为由方法表示。
类
类是具有相同的状态和相同的行为的一组对象的集合，由属性和方法构成，对象所拥有的特征在类中表示时称为类的属性，属性使用变量表示。
类的定义
public class 类名
类和对象的关系
类和对象的关系就如同模具和用这个模具制作出来的物品之间的关系。一个类给出它的全部对象的一个统一的定义，而它的每个对象则是符合这种定义的一个实体（或实例），因此类和对象的关系是抽象和具体的关系。
对象的创建
对象是由类实例化时创建的，因此创建对象必须先定义类。
类是对象的模板，类中定义了什么属性和方法，由这个类实例化的对象就有什么属性和方法。
类是一次性定义，对象可以多次创建。
对象的使用
对象调用属性和方法是使用成员运算符.来完成的。
对象的内存分配
public class Person{//定义人类
public String name;//定义姓名属性
public String identity;//定义身份属性
public int money;//定义金钱属性
publice static void main(String[] args){
Person ash = new Person();//实例化对象ash
ash.name = "灰烬";//为对象的name属性赋值
ash.identity = "骑士";//为对象的indentity属性赋值
ash.money = 0;//为对象的money属性赋值
}
}
对上述代码进行内存的分配，示例图如下：
对象数组
数组是相同类型的一组数据，对象数组是引用类型的数组。
对象数组的内存分配
public class Animal{//定义动物类
public String name;//定义姓名属性
public String habit;//定义进食习属性
public int life;//定义寿命属性
public static void main(String[] args){
//实例化第一个Animal对象
Animal lion = new Animal();
lion.name = "狮子";
lion.habit = "肉食";
lion.life = 15;
//实例化第二个Animal对象
Animal rabbit = new Animal();
rabbit.name = "兔子";
rabbit.habit = "素食";
rabbit.life = 7;
//实例化第三个Animal对象
Animal crow = new Animal();
crow.name = "乌鸦";
crow.habit = "杂食";
crow.life = 13;
//定义Animal类型的数组，并初始化数组元素
Animal animals[] = new Animal[]{
lion,
rabbit,
crow
};
//输出
for(int i = 0; i < animals.length; i++){
System.out.println(animals[i].name+","+animals[i].habit+","+animals[i].life);
}
}
}
运行结果
狮子，肉食，15
兔子，素食，7
乌鸦，杂事，13
内存分配如下图所示
面向过程和面向对象的差别
面向过程的程序设计方式的特点是按照步骤思考问题，强调步骤。
面向对象的程序设计方式的特点是分析有什么对象，对象有什么数据，对象有什么操作。
构造方法
构造方法也叫构造函数，或者叫构造器。
1.构造方法的方法名必须与类名相同。
2.构造方法没有返回值，也不写void。
例如
class Student {
//构造方法
Student(){
}
}
构造方法的作用
对象的属性的默认值是由构造方法赋值的。
默认构造函数
一个类如果没有显示的定义构造函数，那么这个类默认具有无参的构造函数。
默认构造函数为对象的属性赋默认值。
代码示例
class Student {
String name;
int score;
String no;
public void play(){
System.out.printf("我的名字是%s,我的成绩是%d,我的学号是%s",this.name,this.score,this.no);
}
}
public class StudentTest {
public static void main(String[] args) {
Student s =new Student();
s.play();
}
}
输出结果为：我的名字是null,我的成绩是0,我的学号是null
如果定义了构造函数，那么默认构造函数就没有了。
构造函数的调用
构造方法是在实例化对象时调用的。并且实例化时传递的参数必须有构造方法的参数一致。构造方法不允许通过对象名调用。
this
this代表的是当前正在运行的对象。
在类中，如果类的属性名和方法内部的局部变量同名时，那么在方法内部使用的是局部变量，也就是变量使用遵循就近原则。所以类的属性名和构造方法的参数名称不能相同。
在非static方法内部使用属性，可以省略this。
变量
变量分为成员变量和局部变量。
成员变量
成员变量是类的属性，是定义在类内，方法外的变量。
例如
class Student {
String name;
int score;
String number;
}
局部变量
局部变量是定义在方法内的变量。
例如
public void information(){
int score = 0;//局部变量
}
成员变量和局部变量的区别
(1)作用域不同
成员变量作用域：整个类
局部变量的作用域：方法内
(2)初始值不同
成员变量由构造函数初始化的
局部变量需要手动初始化
在同一个方法中不允许有同名的局部变量，在不同的方法中可以有同名的局部变量。
局部变量可以和成员变量名相同，并且在使用时局部变量有更高的优先级。
封装
封装是为了保护数据，这里的数据是指对象的属性（不是方法的局部变量）。
访问修饰符
(1)public：公共的
(2)protected：受保护的
(3)默认|default（什么都不写）
(4)private：私有的
public
public修饰的属性没有访问限制，是最宽松的封装。
例如
public class Person {
public String name;//公有
}
name可以在任何地方被访问。
pubilc修饰类：类可以在任何地方被访问。
public修饰属性和方法：属性和方法可以在任何地方被访问。
private
private修饰的属性只能在类内被访问，类外无法访问，是最严格的封装。
public class Person {
private String name;//私有
}
name属性只能在Person类的类内使用，类外无法使用。
private无法修饰类，但可以修饰类的成员。
getter and setter
最典型封装是：共有方法封装私有属性。
例如
public class Person {
private String name;
private int money;
public String getName() {//共有的读方法，外界可以读取
return name;
}
public void setName(String name) {//共有的写方法，外界可以写入
this.name = name;
}
public int getMoney() {//共有的读方法，外界可以读取
return money;
}
名字允许外界读取和写入，钱只允许外界读取。
方法重载（overload）
方法重载是OOP中的一个重要概念。
定义
在同一个类中：同名不同参，与返回值无关。
例如
public class Student{
public void play(){
}
public int play(int time){
return 0;
}
}
方法重写(方法覆盖|override)
在子类中将父类的方法再重新定义一遍。
如果子类从父类继承的方法不能满足子类的需要，或者不适合子类的需要。此时子类可以将从父类继承的方法重写定义成满足自己需要的方法。重新定义称为重写。
定义
方法重写时，方法的返回值类型 方法名 参数列表都要与父类一样。（同名，同参，同返回）
子类方法覆盖父类方法，必须要保证权限大于等于父类权限。
方法重载（overload）和方法重写（override）的区别
1. 方法重载：
(1)在同一个类中（包括从父类继承的） 方法 同名 不同参 与返回值无关。
2. 方法重写：
(1) 方法重写存在于继承关系中。
(2) 父子类之间的方法 同名，同参，同返回。
