面向对象
将功能封装进对象，强调具备了功能的对象，以类或对象为最小单位，考虑谁来做。
面向对象的三大特征：封装、继承、多态
类
就是对一类事物的描述，是抽象出来的。对象就是实例，是实际存在的该类事物的每个个体。一个类中可以包括：属性、构造器、方法、代码块、内部类。
比如我们把汽车定义为一个类。汽车包括各种类型，如越野车、SUV、轿车等，那SUV就可以是我们创建的对象，它属于汽车这个类。一辆汽车的指标有驱动方式（两驱或者四驱）、排量等等，这些都是“汽车”这个类的属性。我们创建的每个对象都会包含这些属性。汽车可以前进，可以倒车，这些“行动”就是汽车类的方法。
属性 = 成员变量 = field = 域、字段
方法 = 成员方法 = 函数 = method
创建类的对象 = 类的实例化
类的实例化：类名 对象 = new 类名();
例：假设有一个Person类包含三个属性和三个方法
class Person{
//属性
String name;
int age;
boolean isMale;
//方法
public void eat(){
System.out.println("吃饭");
}
public void sleep(){
System.out.println("睡觉");
}
public void talk(String language){
System.out.println("说话：" + language);
}
}在main函数中可以实例化这个类并能够用别称调用该类的属性和方法：
Person p1 = new Person();
//调用属性：“对象.属性”
p1.name = "Tom";
p1.isMale = true;
System.out.println(p1.name);
//调用方法：“对象.方法”
p1.eat();
p1.sleep();
p1.talk("Chinese");类和对象的创建和执行操作有三步：
1.创建类
2.类的实例化
3.调用对象的结构：属性和方法
注：如果创建了一个类的多个对象，则每个对象都独立的拥有一套类的属性。（非static的）
属性（成员变量）与局部变量辨析：
相同点：定义变量的格式是相同的
格式：数据类型 变量名 = 变量值
都需要先声明，后使用。都有其对应的作用域
不同点：
1.在类中声明的位置的不同
属性：直接定义在类的一对{}内
局部变量：声明在方法内、方法形参、代码块内、构造器形参、构造器内部的变量
2.关于权限修饰符的不同
属性：可以在声明属性时，指明其权限，使用权限修饰符。
常用的权限修饰符：private、public、缺省、protected
在定义时不使用权限修饰符则
局部变量：不可以使用权限修饰符。
3.默认初始化值的情况：
属性：类的属性，根据其类型，都有默认初始化值。
整型（byte、short、int、long）：0
浮点型（float、double）：0.0
字符型（char）：0 （或’\u0000’）
布尔型（boolean）：false
引用数据类型（类、数组、接口）：null
局部变量：没有默认初始化值，即在调用局部变量之前，一定要显式赋值。
特别地：形参在调用时，我们赋值即可。
4.在内存中加载的位置：
属性：加载到堆空间中 （非static）
局部变量：加载到栈空间
定义方法可以有形参也可以没有形参。有形参在调用的时候就需要传值。方法可以通过对象名调用。
如何在当前文件类里调用其他java文件中的类，例：
(1)创建Person类的对象，设置该对象的name、age和sex属性，调用study方法，
输出字符串“studying”，调用showAge()方法显示age值，
调用addAge()方法给对象的age属性值增加2岁。
(2)创建第二个对象，执行上述操作，体会同一个类的不同对象之间的关系。
Person类：
public class Person {
String name;
int age;
// 1 表明是男性0 表明是女性
int sex;
public void study(){
System.out.println("studying");
}
public void showAge(){
System.out.println("age:" + age);
}
public int addAge(int i){
age += i;
return age;
}
}PersonText类：
public class PersonText {
public static void main(String[] args) {
Person p1 = new Person();
p1.name = "Lorito";
p1.age = 20;
p1.sex = 0;
p1.study();
p1.showAge();
int newAge = p1.addAge(2);
System.out.println(p1.name + "的新年龄为：" + newAge);
System.out.println(p1.age);
Person p2 = new Person();
p2.showAge(); //结果为0 因为是新建的对象且没有赋值
p2.addAge(10);
p2.showAge(); //10
p1.showAge();
}
}用哪个对象去调用addAge就在哪个对象的age属性基础上进行加10，每个对象的值都是独立的。
对象数组练习：
定义类Student，包含三个属性：学号number(int)，年级state(int)，成绩score(int)。
创建20个学生对象，学号为1到20，年级和成绩都由随机数确定。
问题一：打印出3年级(state值为3）的学生信息。（年级为[1,6]）
问题二：使用冒泡排序按学生成绩排序，并遍历所有学生信息
提示：1) 生成随机数：Math.random()，返回值类型double;
2) 四舍五入取整：Math.round(double d)，返回值类型long。
在此题目中new20个学生对象是不现实的，因此要考虑对象数组。新建了长度为20的对象数组后，要先给每一个位置new一个对象用于存放student属性，最后再给每一个对象的属性赋值。对象数组的每一个位置存放的是一个student对象，每一个对象内又包含三个属性和一个方法。另外在冒泡排序交换时，不能交换成绩，要连同对象交换。假如A同学的成绩是a，B同学的成绩是b，如果只交换成绩就会变成A同学的成绩是b，B同学的成绩是a。
public class ObjectArrayText{
static class Student{
int number;
int state;
int score;
public String info(){
return "学号：" + number + ",年级：" + state + ",成绩：" + score;
}
}
public static void main(String[] args) {
Student[] student = new Student[20];
for (int i = 0; i < 20; i++){
student[i] = new Student();
student[i].number = i + 1;
student[i].state = (int)(Math.random() * 6 + 1);
student[i].score = (int)(Math.random() * 101);
}
for (int j = 0;j < 20; j++) {
//if (student[j].state == 3)
System.out.println(student[j].info());
}
Sort(student);
}
public static void Sort(Student[] st){//只排序成绩
for(int i = 0;i < st.length - 1;i++){
for(int j = 0;j < st.length - 1 - i;j++){
if(st[j].score > st[j + 1].score){
//如果需要换序，交换的是数组的元素：Student对象！！！
Student temp = st[j];
st[j] = st[j + 1];
st[j + 1] = temp;
}
}
}
System.out.println("排序结果如下：");
for (int k = 0 ; k < 20; k++){
System.out.println(st[k].info());
}
}
}JVM内存结构
类加载到内存中是在程序运行时开始，即对编译完源程序生成的字节码文件进行解释运行。
程序中的局部变量存储在虚拟机栈中，而new出来的对象、数组等加载在堆控件中。非static的对象的属性也加载在堆空间中。
