Java面向对象

一、类和对象概述

1.1 面向对象思想

面向过程👇

面向对象👇

类👇

对象

1.2 类中的内容

• 类名

  • 类的名称

• 属性

  • 对象具备的特征

  • 品种、姓名、年龄、地址...

• 方法

  • 对象具备的行为

  • 吃饭、睡觉、学习、工作...

• 构造器

  • 对象创建过程中完成属性的初始化

二、创建类

2.1 过程

1、确定类名【名词提炼法】
    狗子--Dog
    猫咪--Cat
    学生--Student
2、创建一个新的Java文件
    文件名和类名保持一致
3、定义属性
    声明变量【一般不用赋值】
    int age;
    String name;
4、定义方法
    目前先不用使用static
    public void eat(String food){}

2.2 入门案例

Dog

package com.shine.obj;
​
/**
 *  类名
 *      Dog
 *  属性--特种
 *      品种
 *      名字
 *      年龄
 *      性别
 *  方法--行为
 *      吃饭
 *      睡觉
 *      玩耍
 */
public class Dog {
    // 属性--声明变量【一般不赋值,像方法中声明的形参一样】
    String breed;
    String name;
    int age;
    String sex;
    
    // 方法--不用全部添加static
    public void eat(String food) {
        System.out.println("狗子喜欢吃" + food);
    }
    
    public void sleep() {
        System.out.println("狗子的作息时间和主人相同");
    }
    
    public void play() {
        System.out.println("狗子能陪伴主人玩耍");
    }
}

Cat

package com.shine.obj;
​
/**
 *  类名
 *      Cat
 *  属性
 *      品种
 *      名字
 *      毛色
 *      性别
 *      产地
 *
 *  方法
 *      吃饭
 *      抓老鼠
 */
public class Cat {
    // 属性--特征
    String breed;
    String name;
    int age;
    String color;
    String address;
    
    // 方法--行为
    public void eat(String food) {
        System.out.println("猫咪喜欢吃" + food);
    }
    
    public void catchMouse() {
        System.out.println("猫咪喜欢抓老鼠吃");
    }
}

三、对象

3.1 概述

• 类是抽象的

• 类中总结了对象应该具有的属性和行为

• 这些属性和行为没有具体的数据

  • 属性只有声明，没有赋值【虽然有默认值】

  • 方法没有被调用，方法的形参也没有赋值

• 如果需要使用属性和方法，需要创建此类的对象

• 没有对象--》new一个

3.2 创建对象

Car car = new Car();
Random r = new Random();
Scanner sc = new Scanner(System.in);

package com.shine.obj;
​
public class TestDog {
    public static void main(String[] args) {
        /**
         *  创建对象的过程
         *      1、创建类
         *          1.1 类名
         *          1.2 属性
         *          1.3 方法
         *      2、创建对象
         *          2.1 new 对象
         *          2.2 访问属性【读===写】 对象.属性
         *          2.3 调用方法            对象.方法(参数)
         */
        
        // 创建对象
        Dog dog = new Dog();
​
        // 访问属性【读--写】
        
        // 读取属性:对象.属性
        System.out.println(dog.breed);  // 目前没有给属性赋值,有默认值【参考数组】,意义不大
        System.out.println(dog.name);
        System.out.println(dog.age);
        System.out.println(dog.sex);
        
        // 修改属性:对象.属性 = 数据
        dog.breed = "黑贝";
        dog.name = "道哥";
        dog.age = 3;
        dog.sex = "雄性";
        
        // 再次读取属性
        System.out.println(dog.breed);  // 目前已经给属性赋值
        System.out.println(dog.name);
        System.out.println(dog.age);
        System.out.println(dog.sex);
        
        // 调用方法:dog.方法名(参数)
        dog.eat("骨头");
        dog.sleep();
        dog.play();
    }
}

3.3 访问属性和方法

访问属性

读取数据
对象.属性
String name = 对象.name;
​
修改数据
对象.属性 = 数据;
对象.name = "道哥";

访问方法

对象.方法名(参数);
对象.eat("骨头");

3.4 创建类和对象

创建类Student

package com.shine.obj;
​
/**
 *  类名
 *      Student
 *  
 *  属性
 *      学号
 *      姓名
 *      年龄
 *      性别
 *      专业
 *      学校
 *  
 *  方法
 *      学习
 *      吃饭
 *      玩游戏
 */
public class Student {
    // 属性
    String stuId;
    String name;
    int age;
    String gender;
    String subject;
    String school;
    
    // 方法
    public void study(String skill) {
        System.out.println(name + "正在学习" + skill);
    }
    
    public void eat(String food) {
        System.out.println(name + "喜欢吃" + food);
    }
    
    public void playGame(String game) {
        System.out.println(name + "喜欢玩" + game);
    }
}

创建对象并使用

package com.shine.obj;

public class TestStudent {
    public static void main(String[] args) {
        /**
         *  1、创建类
         *      1.1 类名
         *      1.2 属性
         *      1.3 方法
         *      
         *  2、创建测试类
         *      TestStudent
         *      
         *  3、创建对象并使用
         *      3.1 new对象
         *      3.2 属性赋值
         *      3.3 调用属性和方法
         */
        
        // 创建对象
        Student stu = new Student();
        
        // 属性赋值
        stu.stuId = "10010";
        stu.name = "林冲";
        stu.age = 22;
        stu.gender = "男性";
        stu.subject = "武术";
        stu.school = "东京文武学院";
        
        // 访问属性
        System.out.println(stu.stuId);
        System.out.println(stu.name);
        System.out.println(stu.age);
        System.out.println(stu.gender);
        System.out.println(stu.subject);
        System.out.println(stu.school);
        
        // 调用方法
        stu.study("降龙十八掌");
        stu.eat("二斤熟牛肉");
        stu.playGame("高衙内");
        
    }
}

3.5 实例变量

• 属性 == 实例变量 == 实例属性 == 成员变量

• 实例变量是定义在类中方法外的变量，是对象的组成部分之一

• 实例变量有默认值，无序赋值即可使用【默认值和数组相同，没有意义】

• 如果创建了多个对象，每个对象都拥有自己的实例变量，互相隔离

选项	局部变量	实例变量
定义位置	方法中	类中方法外
默认值	无	有,同数组元素默认值
作用范围	从定义位置开始到方法结束	整个类中都能使用
存储位置	栈	堆
生命周期	同方法	同对象

• 如果局部变量和实例变量重名，优先使用局部变量【就近原则】

3.6 实例方法

• 定义在类中方法外的方法 && 没有static修饰的方法

四、构造器

4.1 概述

• 构造器也称为构造方法

• 是类中一个特殊的方法

  • 方法名和类名完全相同

  • 没有返回值，也没有返回值类型

  • 在创建对象的过程中自动调用，不能通过.的方式调用

4.2 无参构造器

• 如果没有在类中手动书写任何构造方法，JVM赠送一个无参数的构造方法

• 如果已显示定义了构造方法，JVM不再赠送

4.3 有参数的构造器

• 为了给类中的属性赋值

• 如果发生实例变量和局部变量重名的情况：

  • 可以使用this.属性明确表示调用实例变量

4.4 构造器案例

People类

package com.shine.constructor;

/**
 *  类名
 *      People
 *  属性
 *      种类
 *      姓名
 *      年龄
 *      性别
 *      地址
 *      备注信息
 *  方法
 *      展示
 */
public class People {
    // 属性
    String breed;
    String name;
    int age;
    String gender;
    String address;
    String info;
    
    // 创建构造器
    public People() {}
    
    /**
     *  有参数的构造器,完成对象属性的赋值
     * @param breed
     * @param name
     * @param age
     * @param gender
     * @param address
     * @param info
     */
    public People(String breed, String name, int age, String gender, String address, String info) {
        this.breed = breed;
        this.name = name;
        this.age = age;
        this.gender = gender;
        this.address = address;
        this.info = info;
    }

    // 方法
    public void show() {
        System.out.println("People [breed=" + breed + ", name=" + name + ", age=" + age + ", gender=" + gender + ", address="
                + address + ", info=" + info + "]");
    }
}

测试

package com.shine.constructor;

public class TestPeople {
    public static void main(String[] args) {
        // 创建对象
        People p = new People();
        p.show();
        p.breed = "黄色人种";
        p.name = "金三顺";
        p.age = 22;
        p.gender = "女性";
        p.address = "汉城";
        p.info = "温柔美丽贤惠大方";
        
        p.show();
        
        People pp = new People("黄色人种", "山本一郎", 22, "男性", "我本山中人", "门口有条河");
        pp.show();
    }
}

4.5 构造器赋值过程

4.6 构造方法重载

五、this关键字

5.1 概述

• 在构造器中可能遇到实例属变量和局部变量重名的情况

  • 默认优先使用局部变量，实例变量失效

  • 可以使用this.属性的方式来明确就是调用实例变量

5.2 this关键字的用法

调用属性【重点】

• 为了区分局部变量和实例变量

this.属性

调用方法

this.方法(参数);

调用其他构造器

• 能调用类中其他的构造方法

• 必须放在构造方法第一行

• 为了节省代码

this(参数)

案例代码【掌握】

package com.shine.this666;
​
/**
 *  类名
 *      Car
 *  属性
 *      品牌
 *      型号
 *      价格
 *      颜色
 *  方法
 *      展示
 */
public class Car {
    // 属性
    String brand;
    String model;
    double price;
    String color;
    
    public Car() {}
​
    public Car(String brand, String model) {
        super();
        this.brand = brand;
        this.model = model;
    }
​
    public Car(double price, String color) {
        super();
        this.price = price;
        this.color = color;
    }
​
    public Car(String brand, String model, double price, String color) {
        // this.属性表示调用实例变量
//      this.brand = brand;
//      this.model = model;
        // this(参数)表示调用其本类中的其它构造方法
        // 构造器的调用必须放在其他构造器的第一行
        this(brand, model);
        // this(price, color);
        this.price = price;
        this.color = color;
        
        // this.方法表示调用实例方法
        this.show();
    }
​
    // 方法
    public void show() {
        System.out.println("Car [brand=" + brand + ", model=" + model + ", price=" + price + ", color=" + color + "]");
    }
    
}