【JavaSE】11-OOP 面向对象编程[对象与方法，对象的创建]

①.初识面向对象

面向对象与面向过程：

• 面向过程：
  步骤清晰简单，第一步做什么，第二部做什么······
  面向过程，适合处理一些较为简单的问题
• 面向对象：
  物以类聚，分类的思考方式，思考问题首先会解决，问题需要哪一些分类，然后对着一些分类进行单独思考。最后对某一个分类下的细节进行面向过程的思索。
  面向对象适合处理复杂问题，适合多人协助的问题。

在达成复杂的需求时，为了从宏观上把握、从整体上合理分析，我们需要使用面向对象的思路来分析整个系统。但是具体到微观的操作，任然需要面向过程的思路去解决问题。

- 面向对象编程(Object-Oriented Programming OOP)

本质：以类的方式组织代码，以对象组织(封装)数据
面向对象是抽象的
三大特性：继承，多态，封装
认识论的角度先有对象后有类。对象是具体事物，类是抽象的，是对象的对象。
代码的角度先有类后有对象。类是对象的模板。

②.方法的回顾与加深

public class Method {

    //Main方法
    public static void main(String[] args) {

    }

    /*
        修饰符  返回值类型  方法名(形参列表 ){  //形参列表参数名
            //方法体
            return 返回值;
        }
     */

    public String sayHello(){  //方法名：驼峰命名法，见名知意
        return "Hello World";
    }

    //无返回值也可以写return代表方法结束
    public void hello(){
        return;
    }

    public int max(int a,int b){
        return a > b ? a : b;  //三元运算符
    }

    public void readFile(String file) throws IOException{
        
    }
}

-方法的调用

• 静态方法、非静态方法

public class MethodUse {
    public static void main(String[] args) {
        //实例化学生类 new
        //对象类型 对象名 = 对象值;
        //非同一个包中的静态方法，需要先获取实例对象再调用当中的方法
        Student student = new Student();  
        student.say();  //输出 "i'm a student"

    }
    //static方法是和类一起加载的
    public static void a(){
        //b();  //不能被a()方法调用
    }
    //类已经存在之后才存在的
    public void b(){

    }
}

• 形参与实参

public class Formal_ActualParameter {
    public static void main(String[] args) {
        //获取实列对象并且调用类中的方法
        int add = new Formal_ActualParameter().add(1, 2); //传入实参到具体的方法
        System.out.println(add);  //输出a b的和 3
    }
    public int add(int a,int b){  //定义形参以便接受传入的量
        return a + b;
    }
}

• 值传递、引用传递

	//值传递
public class ValueTransmit {
    public static void main(String[] args) {
        int a = 1;
        System.out.println(a); //输出1
        
        ValueTransmit.change(a);  //将a的值传递给change方法
        System.out.println(a);  //输出1
        //传递的时候是将a的值copy之后作为实参传入，并不会影响a本身的值
    }
    //无返回值
    public static void change(int a){
        a = 10;
    }
}

//引用传递:传递对象，本质还是值传递
public class QuoteTransmit {
    public static void main(String[] args) {
        Person person = new Person();     //创建了一个Person类的person实例对象
        System.out.println(person.name);  //输出：null

        QuoteTransmit.change(person);     //将person实例对象传递给change方法
        System.out.println(person.name);  //输出：iFinder
    }

    public static void change(Person person){
        //person是一个对象，它指向的是--->Person person = new Person(); 是一个具体的对象，可以改变其属性
        person.name = "iFinder";           //拿到person对象的属性name的地址，修改值
    }
}

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

③.对象的创建与内存分析

-类与对象的关系

• 类是一种抽象的属性，是对某一事物的整体描述/定义，他不能代表某一个具体的事物。
  动物、植物、电脑、手机····等等都是类的概念
  对应代码，Person类，Cat类都是用来描述/定义某一类事物应该具备的特点和行为的，是一个抽象的存在
• 对象是抽象概念类的具体实例
  波斯猫，棕榈树，Mac，iPhone···等等就可以看作上边大类的实例对象
  对象能够体现出某些具体的特点，实现某些特定的功能，是一个具象的存在

-创建与初始化对象

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

//一个项目只应该存在一个main方法
public class Application {
    public static void main(String[] args) {
        //类：抽象的
        //类实例化之后，会返回一个自己的对象
        //student 对象就是一个Student类的具体实例
        //同一个类是可以创建出多个不同的对象的
        Student iFinder = new Student();
        Student xiaoMing = new Student();

        System.out.println(iFinder.name); //输出默认值 null
        System.out.println(xiaoMing.age); //输出默认值 0

        iFinder.name = "iFinder";
        iFinder.age = 24;
        xiaoMing.name = "XiaoMing";
        xiaoMing.age = 18;

        //当根据类中的属性给实例对象的变量赋值之后，对象有了自己的特点
        System.out.println(iFinder.name);  //输出：iFinder
        System.out.println(iFinder.age);   //输出：24
        System.out.println(xiaoMing.name); //输出：XiaoMing
        System.out.println(xiaoMing.age);  //输出：18
    }
}

public class Student {
    //属性：字段
    String name;
    int age;

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

-构造器详解

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

• 必须和类的名字相同
• 必须没有返回值类型，也不能写void
  构造器的作用
  1.new关键词会调用构造器
  2.构造器可以初始化对象的值
  注意：定义了有参构造器之后，无参构造器就必须显示调用
  快捷键：alt + insert

public class Application {

    public static void main(String[] args) {
        //new关键词实例化了一个对象
        Constructor constructor = new Constructor();
        //如果构造器没有实例化初始值，则输出null，实例化之后则输出实例化之后的值
        System.out.println(constructor.modName);  //输出默认值：Constructor

        Constructor constructor1 = new Constructor("iFinder");
        System.out.println(constructor1.modName);  //输出传参值：iFinder
    }
}

class Constructor {
    //定义类中的属性
    String modName;

    //一个类即使什么都不写它也会存在一个构造方法
    //可以显式定义一个构造器
    //构造器可以实例化初始值
    public Constructor(){
        this.modName = "Constructor";
    }
    //构造器的作用
    //1.使用new关键字必须有构造器
    //new关键字的本质就是调用构造器
    //2.用来初始化值


    //有参构造:一旦定义了有参构造，无参构造就必须显示定义！
    public Constructor(String name){
        this.modName = name;
    }
    //定义了有参构造器的话，直接new对象就会报错：无法将类 com.oop.oppadvanced.Constructor中的构造器 Constructor应用到给定类型;
    //快捷键alt + insert生成构造器

}

-内存分析

public class Application {

    public static void main(String[] args) {
        Pet dog = new Pet();
        dog.name = "旺财";
        dog.age = 3;
        dog.shout();   //输出：叫了一声
        System.out.println(dog.name);    //输出：小白
        System.out.println(dog.age);     //输出：3
    }
}
class Pet {
    public String name;
    public int age;

    //默认不写的话，Java会自动生成一个无参构造器

    public void shout(){
        System.out.println("叫了一声");
    }
}

④.小结

• 类与对象：
  类是一个模板，是抽象的
  对象是个实例，是具象的
• 方法：
  一定要掌握方法的定义、调用！
• 对象的引用
  引用类型：基本类型(8)外的类型
  对象是通过引用来操作的，在栈中的引用类型指向堆中的具体属性
• 属性：字段Field / 变量 / 成员变量
  定义： 修饰符 属性类型 属性名 = 属性值;
  会默认初始化：
  数值：0 ，0.0
  char：u0000
  boolean：false
  引用：null
• 对象的创建和使用
  必须使用new关键字创造对象，调用构造器 Person iFinder = new Person();
  对象的属性：iFinder.name;
  对象的方法：iFinder.study();
• 类：
  静态的属性
  动态的行为

扩展：IDEA查看class文件方法

编程界面Ctrl + Alt + Shift + S
选择Modules，点击Add Content Root
选择out文件并添加