学习Java Day11

面向对象编程

Java的核心思想就是OOP

OO ：面向对象

OOP:面向对象编程

面向过程&面向对象

• 面向过程思想（具体）

  • 步骤清晰简单，第一步做什么，第二步做什么…
  • 面对过程适合处理一些较为简单的问题

• 面向对象思想(抽象)

  • 物以类聚，分类的思维模式，思考问题首先会解决问题需要哪些分类，然后对这些分类进行单独思考。最后才对某个分类下的细节进行面向过程的思索。
  • 面向对象适合处理复杂的问题，适合处理需要多人协作的问题。

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

---

拓展：属性+方法 =类

​ 自变量的集合=结构体

​ 语句的集合 = 方法

---

定义：

• 面向对象编程（Object Oriented Programming , OOP)

• 面向对象编程的本质就是：以类的方式组织代码，以对象的组织（封装）数据。

• 抽象

• 三大特性：

  • 封装

  封装指将数据整合到一个密闭的容器中，只留一个开口（IO接口）供存取

  • 继承

  子类继承父类，拥有父类的东西

  • 多态

  同一事物有多种形态

• 从认识论的角度考虑是先有对象后有类。对象，是具体的事物。类，是抽象的，是对对象的抽象

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

---

回顾方法及加深

• 方法的定义

  • 修饰符
  • 返回类型
  • break： 跳出switch，结束循环 和return 的区别
  • 方法名：注意规范 见名知意
  • 参数列表：（参数类型，参数名）…可变参数
  • 异常抛出：疑问

• 方法的调用：递归

  • 静态方法
  • 非静态方法
  • 形参和实参
  • 值传递和引用传递
  • this关键字

定义：

package com.hashiqi.oop.demo01;

import java.io.IOException;

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

        String a = sayHello();
        System.out.println(a);
    }
    /*
    修饰符 返回值类型 方法名（...）{
       //方法
       return 返回值；
       }
    */
    public static String sayHello(){
        return "Hello ,World";
    }
    public  int max(int a,int b){
        return a>b ? a:b;   //三元运算符
    }
    //数组下标越界：Array index out of bounds
    public void readFile(String file) throws IOException{

    }
}

方法的调用：递归

静态与非静态方法

区别，定义方法的时候是否加了static

package com.hashiqi.oop.demo01;

//学生类
public class Student {
    //静态方法
    public static void say(){
        System.out.println("学生说话了");
    }
    //非静态方法
    public void say1(){
        System.out.println("学生");
    }
}

调用

在另一个Java中，若要调用上述方法

调用静态方法

//静态方法可以直接调用
Student.say();

调用非静态方法

//实例化Student这个类 (new) 才能进行调用
Student student = new Student();
student.say();

形参和实参：

实参，在main方法中，直接定义的数据

例如：

pubulic static void main(String args[]){
    //此时定义的x和y就是实参
    int x =5;
    int y =6;

    //调用下面的方法
    int z = add(x,y);
    System.out.println(z);//11
    或者
    int z = add(5,6);
    System.out.println(z);//11
    //两者效果是相同的
    //注：直接给值的前提是数据类型相同，如果方法定义的形参是int型数据，赋值是double型数据，将会报错 
}

形参，在被调用的方法中，定义的数据

例如：

public static add(int a ,int b){
    return a+b;
    //此时定义的a和b就是形参
}

值传递和引用传递：

学完面向对象在回顾

com.hashiqi.oop.demo01.Demo05

this关键字（后讲）：

类与对象的关系

类是一种抽象的数据乐行，它是对某一类食物整体描述/定义，但是并不能代表一个具体的事物.

• 动物、植物、手机、电脑…

• Person类、Pet类、Car类等，这些类都是用来描述/定义某一类具体的事物应该具备的特点和行为

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

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

---

我们可以将这些思想转换为代码实现!

---

类里面只有属性跟方法，没有其他东西

创建与初始化对象

• 使用new关键字创建对象
• 使用new关键字创建的时候，除了分配内存空间之外，还会给创建好的对象进行默认的初始化以及对类中构造器的调用
• 类中的构造器也称为构造方法，是在进行创建对象的时候必须要调用的。并且构造器有以下两个特点：
  1. 必须和类的名字相同
  2. 必须没有返回类型，也不能写void

//被下面的程序调用
package com.hashiqi.oop.demo02;

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


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

package com.hashiqi.oop.demo02;

import org.w3c.dom.ls.LSOutput;

//一个项目应该只存在一个Main方法
public class Application {
    public static void main(String[] args){

        //类：是抽象的，需要实例化
        //类实例化之后会返回一个自己的对象！
    //student对象就是一个Student类的具体实例！
    Student xiaoming = new Student();
    Student xiaohong = new Student();

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

    xiaohong.name = "小红";
    xiaohong.age = 18;
        System.out.println(xiaoming.name);//小明
        System.out.println(xiaoming.age);//15
        System.out.println(xiaohong.name);//小红
        System.out.println(xiaohong.age);//18
    }
}

//程序员,是对世界进行更好的建模! - - -在建模中体会乐趣

构造器

定义:

构造方法是一种特殊的方法，具有以下特点。

（1）构造方法的方法名必须与类名相同。

（2）构造方法没有返回值类型，可以有return，但是不能有返回值，在这里只是表示结束，并不是返回的表示，一般也不使用return。

（3）构造方法的主要作用是完成对象的初始化工作，它能够把定义对象时的参数传给对象的域。

（4）一个类可以定义多个构造方法，如果在定义类时没有定义构造方法，则编译系统会自动插入一个无参数的默认构造方法，这个构造方法不执行任何代码。

（5）构造方法可以重载，以参数的个数，类型，顺序。

无参构造

public class Person{
    public Person{
        //语句
    }
}

有参构造

public class Person{
    String name;
    int    age ;

    public Person(String name){
    this.name =name;
   }
}

package com.hashiqi.oop.demo02;

//java --->class
public class Person {

    //一个类即使什么都不写,它也会存在一个方法
    //显示的定义构造器

    String name;
    int     age;
    
    //实例化 初始值
    //1.使用new关键字,本质是在调用构造器
    //2.用来初始化值
    //无参构造
    public Person() { }

    //有参构造，一旦定义了有参构造，无参构造就必须显示定义

    public Person(String name，int age){
        this.name = name;
        this.age  = age ;
    }


}

package com.hashiqi.oop.demo02;

import org.w3c.dom.ls.LSOutput;

//一个项目应该只存在一个Main方法
public class Application {
    public static void main(String[] args) {

        //实例化了一个对象
        Person p1 = new Person("hashiqi",24);
        Person p2 = new Person("哈士奇",34);
        
        System.out.println(p1.name+"\t"+p1.age);  //hashiqi
        System.out.println(p2.name+"\t"+p2.age);  //哈士奇
    }
}

个人总结：实例化了一个对象，就是指Person是一个对象，p1跟p2都是Person这个对象的实例.而每个实例具有唯一性，不能重复定义

如果没有定义有参构造，IDEA会自动生成一个无参构造，如果手动定义了

快捷定义有参构造.无参构造

alt + insert （insert在键盘的功能键，笔记本的话，在Backspace的上方）

---

创建对象内存分析

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-PKXEzAVg-1593957668129)(对象内存分析.png)]

需要多花时间梳理：

https://www.bilibili.com/video/BV12J41137hu?p=65