8.1 Java面向对象之初识面向对象

一、初识面向对象

1.1 面向过程 & 面向对象

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

1.2 什么是面向对象

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

二、方法回顾和加深

2.1 方法的定义

• 修饰符
• 返回类型
• break和return的区别
  • break：跳出switch、跳出循环
  • return：结束方法，返回一个结果
• 方法名：注意规范
• 参数列表：参数类型，参数名
• 异常抛出

package com.lanseyutou.oop;

import java.io.IOException;

//Demo01 类
public class Demo01 {

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

    }

    /*
    修饰符  返回值类型  方法名(...){
        //方法体
        return 返回值;
    }
    */
    public String sayHello(){
        return "Hello,word!";
    }

    public int max(int a,int b){
        return a>b?a:b;
    }
    
    //抛出异常
    public void readFile(String file) throws IOException{
        
    }

}

2.2 方法的调用

• 静态方法
• 非静态方法

package com.lanseyutou.oop;

//学生类
public class Student {

    //静态方法
    //和类一起加载的
    public static void say(){
        System.out.println("学生说话了");
    }

    //非静态方法
    //类实例化  之后才存在，所以在say中不能调用say1
    public  void say1(){
        System.out.println("学生说话了");
    }
}

package com.lanseyutou.oop;

public class Demo02 {

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

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

• 形参和实参

package com.lanseyutou.oop;

public class Demo03 {

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

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

• 值传递和引用传递

package com.lanseyutou.oop;

//值传递
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;
    }
}

/*
1
1
*/

package com.lanseyutou.oop;

//引用传递：对象，本质还是值传递
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);
    }

    public static void change(Person person){
        //perosn是一个对象:指向的 --->Perosn perosn = new Perosn();这是一个具体的人，可以改变属性!
        person.name = "蓝色芋头";
    }

}

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

/*
null
蓝色芋头
*/

• this关键字
  • 代表当前类 this.xxx = xxx(传进来的参数)

三、对象的创建分析

3.1 类与对象的关系

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

3.2 创建与初始化对象

• 使用new关键字创建对象

package com.lanseyutou.oop.Demo02;

//学生类
public class Student {

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

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

}

package com.lanseyutou.oop.Demo02;

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

    public static void main(String[] args) {

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

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


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

    }
}

/*
null
0
小明
18
*/

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

• 类中的构造器也称为构造方法，是在进行创建对象的时候必须要调用的。
  • 构造器特点:
    • 1.必须和类的名字相同
    • 2.必须没有返回类型,也不能写void
  • 作用：
    • 1.new 本质在调用构造方法
    • 2。初始化对象的值
  • 注意点：
    • 定义有参构造后，如果使用无参构造，现实的定义一个无参的构造
• 构造器必须要掌握

package com.lanseyutou.oop.Demo02;

public class Person {
    //一个类即使什么都不写，它也会存在一个方法

    //显示的定义构造器

    String name;
    int age;

    //实例化初始值
    //1.使用new关键字，必须要有构造器，本质是在调用构造器
    //2.用来初始化值
    public Person(){}

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

    //快捷键：alt+insert
}

package com.lanseyutou.oop.Demo02;

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

    public static void main(String[] args) {

        Person person = new Person();

        System.out.println(person.name);

    }
}

3.3 创建对象内存分析

package com.lanseyutou.oop.Demo03;

public class Pet {
    public String name;
    public int age;

    //无参构造

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

package com.lanseyutou.oop.Demo03;

public class Application {
    public static void main(String[] args) {
        Pet dog = new Pet();
        dog.age = 3;
        dog.name = "旺财";
        dog.shout();

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

        Pet cat = new Pet();

    }
}

3.4 类与对象的小结

1. 类与对象

类是一个模板：抽象；对象是一个具体的实例

2. 方法

定义、调用

3. 对象的引用

引用类型：除基本类型（8个）之外的类型，对象是通过引用来操作的：栈---->堆

4. 属性：字段Field 成员变量

默认初始化： 数字：0 0.0 char：u0000 boolean：fslse 引用 ：null

修饰符 属性类型 属性名 = 属性值

5. 对象的创建和使用

• 必须使用new 关键字创造对象， 构造器 Person lanseyutou = new Person();
• 对象的属性 lanseyutou.name
• 对象的方法 lanseyutou.sleep()

6. 类

• 静态的属性 属性
• 动态的行为 方法