面向对象

第六天

什么是面向对象

1. 面向过程思想
   步骤清晰简单，第一步做什么，第二步做什么，面对过程适合处理一些较为简单的问题
2. 面向对象思想
   物以类聚，分类的思维模式，思考问题首先会解决问题需要哪些分类，然后对这些分类进行单独思考。最后，オ对某个分类下的细节进行面向过程的思索，面向对象适合处理复杂的问题，适合处理需要多人协作的向题！
3. 对于描述复杂的事物，为了从宏观上把握、从整体上合理分析，我们需要使用面向对象的思路来分析整个系统。但是，具体到微观操作，仍然需要面向过程的思路去处理

面向对象编程( Object- Oriented Programming,ooP)
面向对象编程的本质就是：以类的方式组织代码，以对象的组织（封装）数据

抽象：
三大特性
封装
继承
多态
从认识论角度考虑是先有对象后有类。对象，是具体的事物。类，是抽象的，是对对象的抽象

从代码运行角度考虑是先有类后有对象。类是对象的模板

---

类和对象

创建与初始化对象

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

类中的构造器也称为构造方法，是在进行创建对象的时候必须要调用的。

并且构造器有以下俩个特点：
1.必须和类的名字相同
2.必须没有返回类型，也不能写void
构造器必须要掌握

package com.oop.standard;

//一个项目应该只存在一个main方法
public class Demo01 {

    //属性:字段
    String name;
    int age;

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

}

package com.oop.standard;

public class Application {
    public static void main(String[] args) {

        Demo01 xiaoming = new Demo01();
        Demo01 xiaoyan = new Demo01();
        //实例化以后会返回一个自己的对象

        xiaoming.name = "小明";
        xiaoming.age = 3;

        System.out.println(xiaoming.name);
        System.out.println(xiaoming.age);

        xiaoyan.name = "小言";
        xiaoyan.age = 5;

        System.out.println(xiaoyan.name);
        System.out.println(xiaoyan.name);

    }
}

---

构造器

package untitled.基础语法.src.com.oop.standard;

public class Demo02 {
    //一个类型什么都不写,它也会存在一个方法,构造方法
    // public Demo02(){ }  
    String name;

    //实例化的初始值
    // 方法名和类名相同
    //没有返回值也不能写void
    //使用new必须有构建器，new一个对象实质是在调一个构造器

    //有参构造 一旦定义了有参构造,无参必须显示定义
    public Demo02(String name){
        this.name = name;
    }
}

package untitled.基础语法.src.com.oop.standard;

public class total {
    public static void main(String[] args) {

        Demo02 demo02 = new Demo02("xiaoyan");

        System.out.println(demo02.name);


    }
}

构造器：

1. 和类名相同
2. 没有返回值

作用

1. new本质是在调用构造器
2. 初始化对象的值

注意点：

1. 定义构造器，如果想使用无参的构造器，显示的定义一个无参的构造器

alt + inster

---

方法调用

package com.oop;

import com.array.Demo;

public class Demo01 {
    public static void main(String[] args) {
        //静态方法 类名.方法名 Demo02.say();
        //动态方法 实例这个类new

        //对象类型 对象名 = 对象值
        Demo02 i = new Demo02();
        //调用类,然后可以直接调用类下的方法,把类赋给一直对象
        i.say();//调用对象

        String s = new Demo01().sayHello();
        System.out.println(s);

    }
    //修饰符 返回值类型 方法名（） {
    //方法体
    //return 结束方法返回结果
    public String sayHello(){
        return "hello,world";
    }
}

package com.oop;

public class Demo02 {
    //定义一个方法
    public void say(){

        System.out.println("学生说话了");
    }
    //static和类一起加载
    public static void a(){
    }
    //动态,实例化之后才存在，
    public void b(){
    }//所以同一类下的两个方法同静态或动态都可相互调用，但不同类无法调用
}

package com.oop;
//值传递
public class Demo03 {
    public static void main(String[] args) {
        int a = 0;
        System.out.println(a);
        changer(a);
        System.out.println(a);//输出还是0
    }
    //返回值为空
    public static void changer(int a) {
        a=10;

    }
}

package com.oop;

//引用传递: 对象,本质还是值传递
public class Demo04 {
    public static void main(String[] args) {
        Perosn perosn = new Perosn();

        System.out.println(perosn.name);//输出一个null

        Demo04.change(perosn);

        System.out.println(perosn.name);
    }

    public static void change(Perosn perosn) {
        perosn.name = "小言";

    }

}
//定义了一个Perosn类,有一个属性name
class Perosn{
    String name;
}

---

创建对象内存分析

---

小结

难，是真的难