面向过程编程：（1）步骤清晰简单（2）适合处理一些较为简单的问题
面向对象编程：（1）分类的思维模式，思考问题首先会解决问题需要哪些分类，然后对这些分类进行单独思考。最后，才对某个分类下的细节进行面向过程的思索；（2）面向对象适合处理复杂的问题，适合处理需要多人协作的问题。
总结：对于描述复杂的事务，为了从宏观上把握、从整体上合理分析，我们需要使用面向对象的思路来分析整个过程。但是，具体到微观操作，仍然需要面向过程的思路去处理。
定义：面向对象编程（Object-Oriented Programming, OOP）
本质：以类的方式组织代码，以对象的组织（封装）数据。
思想：（1）抽象思想（2）三大特性--封装、继承、多态；
从认识论角度考虑是先有对象后有类。对象，是具体的事物。类，是抽象的，是对对象的抽象。
从代码运行角度考虑是先有类后有对象。类是对象的模板。
二 方法回顾和加深两部分内容：方法的定义；方法的调用
1 方法的定义 (1)结构：
修饰符 返回值类型 方法名(...){
//方法
return 返回值
}
(2)修饰符：形如 public 、static，等
(3)返回类型：确定方法返回值的类型：基本数据类型、数组、其他结构体、空等
(4)break和return的区别
return 结束方法，返回一个结果
break 结束循环或者switch循环
(5)方法名：驼峰原则
(6)参数列表：输入到该方法的参数列表，例如 public int max (int a, int b)
可变长参数的使用 public int max (int... x)
(7)异常抛出 :暂不细讲解，之前出现过数组出界的异常。
2 方法的调用（1）静态方法：static的类。静态方法 static 直接调用
（2）非静态方法：不带static的类，在调用时需要实例化之后再调用
创建一个学生类进行调用它的静态类方法和非静态类方法，调用类自己内部的静态类方法；
package OOP;
public class Demo02 {
public static void main(String[] args) {
//静态方法 static 直接调用
Student.say();
//非静态方法 不可以直接调用
//Student.study();//会报错
//调用需要实例化
Student student2 = new Student();
student2.study();
}
//方法调用的其他例子：static
//当方法a和方法b都是static时，可以互相调用，当其中一个不是static时，另一个无法对其进行调用！
public static void a() {
b();
//c(); //会报错
}
public static void b() {
System.out.println("hello,我是b函数");
}
public void c() {
System.out.println("C");
}
}
待调用的学生类：
package OOP;
public class Student {
public static void say() {
System.out.println("学生说话了");
}
public void study() {
System.out.println("学生学习了");
}
}
（3） 形参和实参
形参：定义方法时，用在描述传入参数类型的参数
实参：调用方法时，传入到方法中的参数
下面代码中，max方法中的int a, int b就是形参；调用max方法时，max(i,j) 中的i和j就是实参。
public class Demo03 {
public static void main(String[] args) {
int i = 1, j = 2;
int ans = max(i,j);//传入的i，j就是实参
System.out.println(ans);
}
public static int max(int a, int b){ //规定的传入数据类型 a，b就是形参
return a>b?a:b;
}
}
（4）值传递和引用传递
Java都是值传递。得到的是返回值。
引用传递类似C的指针传递，就是传递的是地址，在修改时也就直接在地方上进行修改了。
值传递的例子：
//值传递的例子
int a = 1;
System.out.println("当前的值为："+a);
Demo04 demo04 = new Demo04();
demo04.fun1(a);
System.out.println("当前的值为："+a);
public class Demo04 {
public void fun1(int a){
a = a+1;
System.out.println("在demo04的方法中a的值已经改变为："+a);
System.out.println("但是demo04的方法没有返回值！");
return;
}
}
引用传递的例子
//引用传递的例子
Person person = new Person();
System.out.println("改变person的name属性前的值:"+person.name);
change(person);//改变person的name属性值
System.out.println("改变person的name属性后的值:"+person.name);
//引用传递例子的调用方法
public static void change(Person person) {
person.name = "yuan";
//引用传递的调用的类
class Person{
String name;
}
（5）this关键字
指的是访问类中的成员变量，用来区分成员变量和局部变量（重名问题）
三 对象的创建分析(1)类和对象的关系：
类是一种抽象的数据结构，它是对某一种事务整体描述/定义，但是并不能代表某一个具体的事物。
对象是抽象概念的具体实例。
(2) 创建与初始化对象
使用new关键字创建对象。：在使用new关键字创建的时候，除了分配内存空间之外，还会给创建好的对象进行默认的初始化，调用类中的构造器。
package OOP.Demo_main;
public class Student {
//属性
String name;
int age;
//方法
public void study() {
System.out.println("在学习");
}
}
package OOP.Demo_main;
//一个项目中只存有一个main方法
public class Demo01 {
public static void main(String[] args) {
//类进行实例化
Student student = new Student();
// student对象就是一个Student类的具体实例
student.study();
//在实例化后会将对象初始化，string为null，int为0
System.out.println(student.name + " " + student.age);
student.age = 15;
student.name = "xian";
System.out.println(student.name + " " + student.age);
}
(3) 构造器
类中的构造器也称为构造方法，是在进行创建对象的时候必须要调用的，并且构造器有两个特点：1 必须和类的名字相同；2必须没有返回值，也不能写void
一个类即使什么也没写，也会存在一个构造器；
public Student(){
}
利用显式构造器，我们可以初始化对象的值
//显式无参构造器,默认name值为yuan2，在实例化这个类时，就会得到name为yuan2的对象
public Student(){
this.name = "yuan2";
}
定义有参构造时，无参构造器就必须显示定义。如下
//构造有参构造器时，必须有显示构造器
public Student(){
}
public Student(String name){
this.name = name;
}
构造器总结：1 和类名相同； 2 没有返回值
作用：1 new本质在调用构造方法 2 初始化对象的值
注意点：定义有参构造之后，如果想使用无参构造，显示定义一个无参的构造
快捷键：alt+insert键，快速构建有参或无参构造器
（4）内存分析
1 类创建好后统一放在方法区
2 当进行调用时，首先main方法压入栈底（未开辟堆的内存）
3 调用方法时，作为引用变量名，先压入栈中，之后在堆中开辟内存空间，引用变量名指向该块内存地址。
4 调用结束，内存收回，从栈中pop出。
static ：存放在静态方法区，和类一起加载，以致于所有对象都可以调用它。
