Java（基础07）

Zachsj

已于 2022-07-15 19:39:18 修改

阅读量93

点赞数

分类专栏： Java（学习笔记） # Java（基础）文章标签： java

于 2021-11-08 16:05:03 首次发布

本文链接：https://blog.csdn.net/Zachsj/article/details/118561211

版权

Java（学习笔记）同时被 2 个专栏收录

71 篇文章 0 订阅

订阅专栏

Java（基础）

10 篇文章 0 订阅

订阅专栏

本文介绍了Java面向对象编程的基础概念，包括面向过程与面向对象的区别、面向对象的三大特性（封装、继承、多态），以及如何定义和调用方法、构造器的使用和内存分析。通过实例演示了类与对象的创建、对象属性与方法操作，以及构造器的必要性和注意事项。

摘要由CSDN通过智能技术生成

Java（基础07）

参考视频：面向对象01：什么是面向对象（狂神）

面向过程＆面向对象

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

1. 什么是面向对象

面向对象编程（Object-Oriented Programming, OOP）
面向对象编程的本质就是：以类的方式组织代码，以对象的方式组织（封装）数据。
抽象
三大特性：
- 封装
- 继承
- 多态
从认识论角度考虑：是先有对象后有类。对象，是具体的事物。类，是抽象的，是对对象的抽象。
从代码运行角度考虑：是先有类后有对象。类是对象的模板。

2. 回顾方法的定义

方法的定义
- 修饰符
- 返回类型
- break：跳出switch，结束循环和 return 的区别
- 方法名：注意规范就OK 见名知意
- 参数列表：（参数类型，参数名）…
- 异常抛出：疑问，后面讲解

示例一：

package com.oop.demo01;

import java.io.IOException;

//Demo01 类
public class Demo01 {

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

    }

    /*
    修饰符  返回值类型  方法名（...）｛
        //方法体
        return 返回值
    ｝
     */
    //return 结束方法，返回一个结果！
    public String sayHello(){
        return "hello, world";
    }

//    public void print(){
//        return;
//    }

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

    //数组下标越界：Arrayindexoutofbounds
    public void readFile(String file) throws IOException{

    }

}

3. 回顾方法的调用

方法的调用：递归
- 静态方法
- 非静态方法
- 形参和实参
- 值传递和引用传递
- this关键字

示例一：（静态方法和非静态方法）

package com.oop.demo01;

public class Demo02 {
    public static void main(String[] args) {
        //静态方法  static
//        Student.say();

        //非静态方法
        //实例化这个类 new
        //对象类型  对象名 = 对象值;
        Student student = new Student();
        student.say();

    }

    //  static方法和类一起加载的
    public static void a(){
//        b();
    }

    //  非静态方法需要类实例化之后（new）才存在
    public void b(){
        a();
    }
}

package com.oop.demo01;

//学生类
public class Student {

    //非静态方法
    public void say(){
        System.out.println("学生说话");
    }

}

示例二：（形参和实参）

package com.oop.demo01;

public class Demo03 {
    public static void main(String[] args) {
//        new Demo03().add(1,2);
        //实际参数和形式参数的 类型 要对应。
        int add = Demo03.add(1,2);
        System.out.println(add);
    }

    public static int add(int a, int b){
        return a+b;
    }
}

示例三：（值传递和引用传递）

值传递

package com.oop.demo01;

//值传递
public class Demo04 {
    public static void main(String[] args) {
        int a = 1;
        System.out.println(a);

        Demo04.change(a);
        System.out.println(a);
    }

    //返回值为空
    public static void change(int a){
        a = 10;
    }
}

引用传递

package com.oop.demo01;

//引用传递：对象，本质还是值传递

//对象， 内存！
public class Demo05 {
    public static void main(String[] args) {
        Person person = new Person();
        System.out.println(person.name);//null

        Demo05.change(person);
        System.out.println(person.name);//Zach
    }

    public static void change(Person person){
        //person是一个对象：指向的 ——> Person person = new Person();这是一个具体的人，可以改变属性。
        person.name = "Zach";
    }
}

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

4. 类与对象的创建

类与对象的关系

类是一种抽象的数据类型，它是对某一类事物的整体描述/定义，但是并不能代表某一个具体的事物。
- 动物、植物、手机、电脑…
- Person类、Pet类、Car类等，这些类都是用来描述/定义某一类具体的事物应该具备的特点和行为的
对象是抽象概念的具体实例
- 张三就是人的一个具体实例，张三家里的旺财就是狗的一个具体实例。
- 能够体现出特点，展现出功能的是具体的实例，而不是一个抽象的概念。

创建与初始化对象

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

示例一：
（程序入口（测试类）可拉至右边）

package com.oop.demo02;

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

        //类：抽象的，（所以）需要实例化。
        //类实例化后会返回一个自己的对象！
        //类：抽象的。对象：具体的。
        //student对象就是一个Student类的具体实例！
        Student zach = new Student();//(引入了局部变量)
        Student jay    = new Student();

        zach.name = "柴客";
        zach.age = 23;

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

        jay.name = "佳哥";
        jay.age = 22;

        System.out.println(jay.name);
        System.out.println(jay.age);
    }
}

（类可放左边）

package com.oop.demo02;

//学生类（类只包含 属性 和 方法）
public class Student {

    //属性：字段
    String name;    //默认为null
    int age;    //默认为0

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

}

//学程序好处？对世界进行更好的建模！---宅？×   音乐！旅游！出国！

/*
    public static void main(String[] args) {

        //类：抽象的，（所以）需要实例化。
        //类实例化后会返回一个自己的对象！
        //类：抽象的。对象：具体的。
        //student对象就是一个Student类的具体实例！
        Student zach = new Student();//(引入了局部变量)
        Student jay    = new Student();

        zach.name = "柴客";
        zach.age = 23;

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

        jay.name = "佳哥";
        jay.age = 22;

        System.out.println(jay.name);
        System.out.println(jay.age);
    }
 */

5. 构造器详解

构造器（存在条件）：
- 1.和类名相同
- 2.没有返回值
构造器（作用）：
- 1.new 本质在调用构造方法
- 2.初始化对象的值
注意点：
- 1.定义有参构造之后，如果想使用无参构造，显式地定义一个无参的构造
快捷键：Alt + Insert
this. =
- （左边this. 代表当前类的，右边为参数传进来的值）

示例一：

package com.oop.demo02;

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

        //new 实例化了一个对象
        Person person = new Person("zach");

        System.out.println(person.name);//null、zach...
    }
}

package com.oop.demo02;

//java文件 ——> class文件
public class Person {

    //一个类即使什么都不写，它也会存在一个（构造）方法
    //显式地定义构造器

    String name;

    //构造器作用：1.使用new关键字，本质是在调用构造器（没有构造器就报错）
    //         2.用来初始化值
    public Person() {   //无参构造
//        this.name = "zach";
    }

    public Person(String name) {    //有参构造（重载）
        // 一旦定义了有参构造，无参构造必须显式定义
        this.name = name;
    }

    //快捷键:alt+insert
}

/*
    public static void main(String[] args) {

        //new 实例化了一个对象
        Person person = new Person("zach");

        System.out.println(person.name);//null、zach...
    }

    总结：
    构造器：
        1.和类名相同
        2.没有返回值
    作用：
        1.new 本质在调用构造方法
        2.初始化对象的值
    注意点：
        1.定义有参构造之后，如果想使用无参构造，显式地定义一个无参的构造

    快捷键：Alt + Insert
    this. =
    （左边this. 代表当前类的，右边为参数传进来的值）
 */

6. 创建对象内存分析

本节详解：面向对象6：创建对象内存分析（狂神）

示例一：在这里插入图片描述

极简内存图：
在这里插入图片描述

7. 简单小结类与对象

类与对象
- 类是一个模板：抽象的。
- 对象是一个实例：具体的。
方法
- 定义、调用！
对象的引用
- 引用类型（除基本类型的其他所有类型）
- 基本类型（8个）
- 对象是通过引用来操作的：栈——>堆（地址）
属性：字段（Field）成员变量
- 默认初始化：
  数字： 0 0.0
  char： u0000
  boolean： false
  … …
  引用： null
- 属性定义公式：修饰符属性类型属性名 = 属性值！
对象的创建和使用
- 必须使用new关键字创建对象，构造器 Person zach = new Person();
- 对象的属性 zach.name
- 对象的方法 zach.sleep()
类：（类中只写这两个）
- 静态的属性属性
- 动态的行为方法