面向过程思想：
步骤清晰简单，第一步做什么，第二步做什么
面对过程适合处理一些较为简单的问题
面向对象思想：
物以类聚，分类的思维模式，思考问题首先会解决问题需要哪些分类，然后对这些分类进行单纯思考，最后，才对某个分类下的细节进行面向过程的思索。
面向对象适合处理复杂的问题，适合处理需要多人协作的问题。
属性+方法会变成一个类
对于描述复杂的事物，为了从宏观上把握、从整体上合理分析，我们需要使用面向对象的思路来分析整个系统。但是，具体到微观操作，仍然需要面向过程的思路去处理。
面向对象编程的本质就是：以类的方式组织代码，以对象的组织（封装）数据。
抽象
三大特性：
封装，继承，多态。
从认识论角度考虑是先有对象后有类。对象，是具体的事物。类，是抽象的，是对对象的抽象。
从代码运行角度考虑是先有类后有对象。类是对象的模板。
静态方法的体现：
package com.rgf.oop;
public class B {
public static void main(String[] args) {
//如果是静态方法，调用Student类里面的say方法，采用类名.方法，即Student.say();。
Student.say();
}
}
package com.rgf.oop;
//学生类
public class Student {
//静态方法
public static void say() {
System.out.println("学生不说话了");
}
}
采用静态方法去调用另一个类中的方法的时候，我们采用类名.方法。
非静态方法的体现：
package com.rgf.oop;
public class B {
public static void main(String[] args) {
//如果是调用非静态方法，则先实例化这个类，即new一个对象,然后利用对象名调用此方法。
//对象类型 对象名 =对象值;
Student student = new Student();
student.say();
}
}
package com.rgf.oop;
//学生类
public class Student {
//非静态方法，没有static.
public void say() {
System.out.println("学生不说话了");
}
}
采用非静态方法去调用另一个类中的方法的时候，我们采用先把所调用的那个类new一个对象，然后利用该对象的对象名进行调用此方法，即实例对象名.方法(),即student.say()。
方法调用的体现：
package com.rgf.oop;
public class C {
//当a和b都是静态方法的时候，a可以调用b，b也可以调用a.
public static void a() {
b();
}
public static void b(){
a();
}
}
package com.rgf.oop;
public class C {
//当a和b都是非静态方法的时候，a可以调用b，b也可以调用a.
public void a() {
b();
}
public void b(){
a();
}
}
package com.rgf.oop;
public class C {
//当a是静态方法，而b不是非静态方法的时候，a不可以调用b，但b可以调用a.
//这是因为static是和类一起加载的，存在时间比较早。
// 而b方法是和对象有关的，是在类实例化之后才存在的,即是在对象创建之后才存在的。
public static void a() {//已经存在的东西去调用不存在的东西，所以会报错。
// b();
}
public void b(){
a();
}
}
综上所述，方法调用的两种方法：
1.直接将此方法转变为静态方法，然后利用类名.方法直接进行调用。
2.面对非静态方法，可以先实例化一个对象，即new该类，并调用该类的方法。
实际参数和形式参数的体现：
package com.rgf.oop;
public class D {
public static void main(String[] args) {
//第一种非静态方法：我们采用new,实例化一个对象进行调用。
new D().add(1,5);
System.out.println( new D().add(1,5));
}
public int add(int a,int b){//形式参数
return a+b;
}
}
package com.rgf.oop;
public class D {
public static void main(String[] args) {
//第二种静态方法：类名.方法，点击alt+enter可以自动获得一个返回值。
//实际参数要和形式参数的类型对应。
int add = D.add(1, 5);
System.out.println(add);
}
public static int add(int a,int b){//形式参数
return a+b;
}
}
值传递和引用传递：
值传递：
package com.rgf.oop;
//值传递
public class E {
public static void main(String[] args) {
int a=1;
System.out.println(a);
E.change(a);
System.out.println(a);
}
//返回值为空。
public static void change(int a){
a=10;
}
}
通过结果可知，我们并没有获得返回值，由于在change方法中并没有返回值类型，而是返回为空，所以相当于走完这个方法了，但并没有改变值，具体的运行过程，可以通过debug进行了解。
值传递，只是把值传递过去了，在函数里修改变量的值，原变量的值不变。
引用传递是把地址传递过去了 ，修改变量的值，原变量的值也会变。
引用传递：
package com.rgf.oop;
//引用传递：对象，本质还是值传递
//对象，内存。
public class F {
public static void main(String[] args) {
//用下面的Person类，需要new一个对象。
//我们new一个对象的时候，需要alt+enter,进行获得对象名。
//同类方法可以直接调用，非同类非静态用对象调，静态用类名调用。
Person person = new Person();
System.out.println(person.name); //第一次打印出来为null
F.change(person);
System.out.println(person.name);
}
public static void change(Person person) {
//person是一个对象，指向的是一个具体的人Person person = new Person();
//这是一个具体的人，即Person类里面的name属性。可以改变属性。
person.name="rgf";
}
//定义了一个Person类，有一个属性：name;
static class Person{
String name; //默认值为null
}
}
