面向过程思想（线性）：
1. 步骤清晰简单，第一步做什么，第二步做什么…
2. 面对过程适合处理一些较为简单的问题
面向对象思想：
1. 物以类聚，分类的思维模式，思考问题首先会解决问题需要哪些分类，然后对这些分类进行单独思考。最后，才对某个分类下的细节进行面向过程的思索。
2. 面向对象适合处理复杂的问题，适合处理需要多人协作的问题。

对于描述复杂的事物，是为了从宏观上把握，从整体上合理分析，我们需要使用面向对象的思路来分析整个系统。但是，具体到微观操作，仍然需要面向过程的思路去处理。

面向对象定义

什么是面向对象：
面向对象编程（Object-Oriented Programming,OOP）
面向对象编程的本质：以类的方式组织代码，以对象的组织（封装）数据。

三大特征：封装、继承、多态

从认识论角度考虑是先有对象后有类。对象，视具体的事物。类，是抽象的，是对对象的抽象
从代码运行角度考虑是先有类后有对象。类是对象的模板。

修饰符 返回值类型 方法名（…){
方法体
return 返回值；
}

*注意：return返回值和返回值类型保持一致
字符串类型

public String hello(){
        return "hello";
}

void，return之间返回空

public void max(){
        return;
}

静态方法
非静态方法

a,b同时有Static时，二者可以相互调用，若只有其中一个含有Static，则不可以互相调用

//和类一起加载
    public static void a(){
        b();//会报错
    }
    //类实例话new之后才存在
    public void b(){

    }

调用方法：

public static void main(String[] args) {
    new Demo2().add(1,2);//实参，动态调用方法
    }//形参
    public int add(int a,int b){
        return a+b;
    }
    /*
    静态调用方法
    public static void main(String[] args) {
        int add = Demo2.add(1, 2);//返回int类型的方法
        System.out.println(add);
    }
    public static int add(int a,int b){
        return a+b;
    }
    */

值传递和引用传递

值传递***

 public static void main(String[] args) {
        int a=1;
        System.out.println(a);//a:1
        PassByValueDemo3.change(a);
        System.out.println(a);//a:1
    }
    //返回值为空
    public static void change(int a){//a:1,a:10
        a=10;//a:1,a:10
    }

引用传递***

public static void main(String[] args) {
        person person = new person();
        System.out.println(person.name);//null


        PassByReference.change(person);
        System.out.println(person.name);//廾匸

    }
    public static void change(person person){
        //person是一个对象：指向的--->Person person =new Person();
        //这是一个具体的人，可以改变属性
        person.name="廾匸";
    }
}
//定义一个person类，有一个属性：name
class person{
String name;//null
        }

类和对象的创建

类是一种抽象的数据类型，他是对某一类事物整体描述、定义，但并不代表某一个具体的事物

动物，植物，手机，电脑…
Person类，Pet类，Car类等，这些类都是用来描述或定义某一类具体的事物应该具备的特点和行为

对象是抽象概念的具体实例：

张三就是人的一个具体实例，张三家里的旺财就是狗的一个具体实例
能够体现出特点，展现出功能的是具体的实例，而不是一个抽象的概念。

创建：
1.使用new关键字创建对象
2.使用new关键字创建的时候，除了分配内存空间之外，还会给创建好的对象进行默认的初始化，以及对类中构造器的使用。

//mian方法
//类：抽象，实例话
        //类实例化后会返回一个值
        //student对象就是Student类的具体实例

       Student student1 = new Student();
        Student student2 = new Student();

        student1.name="小明";
        student1.age=18;

        student2.name="廾匸";
        student2.age=20;

        System.out.println(student1.age+"岁的"+student1.name+"正在学习！");
        System.out.println(student2.age+"岁的"+student2.name+"正在学习！");
    }
    System.out.println("=======================================");
    //学生类
public class Student {
    //属性
    String name;
    int age;

    //方法：字段
    public void study(){
       System.out.println(this.name+"在学习");
   }

构造器*****

类中的构造器也称为构造方法，是在进行创建对象的时候要调用的。并且构造器有以下两个特点：

1.必须和类的名字相同
2.必须没有返回类型，也不能写void

一个类即使什么都不写，他也存在一个构造方法。编译后的class文件中默认存在相对应的构造器。

//显示的定义构造器
String name;
    //无参构造：
    public Person(){
}
  //有参：一但定义了有参构造，无参就必须显示定义
    public Person(String name){
        this.name=name;
    }

构造器作用：
使用new关键字，本质是在调用构造器
初始化值
快捷键：alt+insert

创建对象内存分析

public static void main(String[] args) {
	Pet dog=new Pet();
	dog.name="旺财"；
	dog.age=3;
	dog.shout();
	System.out.println();
	
	Pet cat=new Pet();
    }
    public class Pet(){
    	public String name;
    	public int age;
    public void shout(){
 
    }
    }

默认初始化：

数字：0 0.0
char: u0000
boolean: false
引用：null