Java语言学习day 06 - 面向对象01

1.面向对象概述

1.1 软件开发方式

• 面向过程: 我该怎么一步一步做.先什么后干什么.

  面向过程缺点: 系统软件适应性差, 可拓展性差, 维护性差.

• 面向对象: 我该让谁去做什么.把功能合理的分配给不同对象.

  面向对象三大特征: 封装、继承、多态.

  面向对象更符合我们常规的思维方式, 用于开发大型项目.

• 抽象: 从已经存在的多个事物中取出我们关注的特性, 行为, 产生一个新事物的思维过程.

1.2 成员变量和局部变量

1.2.1 变量的分类

• 成员变量: 定义在内中, 在方法的外面.也可以叫字段.

• 局部变量: 除了成员变量, 其他都是局部变量. 局部变量存在于方法的内部、代码块中(if、while、for的{ }中)、方法的形形参.

1.2.2 变量的初始值

• 成员变量: 默认有初始值

• 局部变量: 默认没有初始值, 所以定义的时候必须初始化赋值才能使用.

1.2.3 变量的作用域

不同的{ }表示不同的作用域, 判断变量的作用域, 关键看变量所在的{ } .

• 成员变量: 在定义的类中都有效.
• 局部变量: 从开始定义的地方开始, 只在自己所在的{ }有效.

1.2.4 变量的生命周期

• 成员变量: 属于对象的, 对象在堆内存中, 所以成员变量存储在堆内存中, 随着对象的结束也销毁了.
• 局部变量: 存储在栈内存中, 随着方法的结束也销毁了.

1.3类和对象的关系

• 类(class): 对一类事物的抽象描述.
• 对象(object): 现实生活中该类事物的实例化, 也叫实例.

注意: 在实际开发中, 必须先有类, 才能使用new去创建对象.

1.4类的定义

• 类是拥有相同特性(状态)和行为(功能)的多个对象的抽象.

• 使用成员变量来表示状态.

• 使用成员方法来表示行为.

• 语法格式:

public class 类名{
    //成员变量是属于对象的, 所以应该是先有对象, 才能有成员变量
    //成员变量
    [修饰符] 数据类型 变量名1;
    [修饰符] 数据类型 变量名2;
    [修饰符] 数据类型 变量名n;
    
    //成员方法
    [修饰符] 返回值类型 方法名称(参数){
        方法体
    }
}

注意:

• 面向对象设计中, 描述对象和测试类分开编写.
• 在描述对象的类中, 不需要写main 方法, 在测试类中去编写main方法.
• 现阶段, 成员变量和成员方法暂时都先不使用修饰符, 修饰符是可选的.

//需求：描述猫类
public class Cat {
    /*
    步骤：
    （1）猫有名字、年龄等状态
    （2）说话的功能
     */
    //成员变量
    String name;//猫的名字
    int age;//猫的年龄

    //成员方法
    //猫说话的功能
    void say() {
        System.out.println(name + age);
    }
}

1.5对象的操作

1.5.1对象的基本操作

• 创建对象: 类名 对象名 = new 类名( );

  • 匿名对象new 类名( ); 只能使用一次.

• 调用对象的方法: 对象名.方法名( );

• 为字段(成员变量)设置值: 对象名.字段名 = 值;

• 获取字段的值: 数据类型 变量 = 对象名.字段名;

//需求：作为Cat类和对象的测试类
public class CatDemo {
    /*
    步骤：
    （1）创建Cat对象c
    （2）使用c对象调用说话方法
    （3）给对象成员变量设置值
    （4）再使用c对象调用说话方法，观察成员变量的值的改变
    （5）获取c对象的成员变量
     */
    public static void main(String[] args) {
        //创建Cat对象c
        Cat c = new Cat();
        //使用c对象调用说话方法
        c.say();
        //给对象成员变量设置值
        c.name = "猫";
        c.age = 10;
        //再使用c对象调用说话方法，观察成员变量的值的改变
        c.say();
        //通过对象获取c对象的成员变量
        String n = c.name;
        int a = c.age;
        System.out.println(n);
        System.out.println(a);
        //匿名对象
        new Cat().say();
    }
}

1.5.2对象的内存分析图

1.6构造器

• 构造器: 也叫构造方法, 作用是用来创建对象和给对象初始化操作.
• 构造器的语法:

[public] 类名(参数){
    //方法体
}

• 特点: 1.构造器名称和类名相同.
  2. 不能定义返回类型.
  3. 构造器不能用return语句.

1.6.1默认构造器

如果一个类中没有手动添加构造器, 那么会创建一个默认的构造器.

默认构造器的特点: 无参数、无方法体.

1.6.2通过构造器设置初始值

//需求：描述猫类
public class Cat1 {
    /*
    步骤：
    （1）猫有名字、年龄等状态
    （2）无参构造器
    （3）带参数构造器初始化名字和年龄两个字段
    （4）说话的功能
     */
    //猫有名字、年龄等状态
    //成员变量
    String name;
    int age;
    //无参构造器
    public Cat1() {
    }
    //带参数构造器初始化名字和年龄两个字段
    public Cat1(String name, int age) {
        //就近原则：方法自己有，用自己的，没有用成员变量
        //所以这里需要加this来让等号左边的name指向成员变量的name
        this.name = name;
        this.age = age;
    }
    //说话的功能
    void say() {
        System.out.println("我是" + name + ",今年" + age + "岁");
    }
}

//需求：作为Cat1类和对象的测试类
public class CatDemo1 {
    /*
    步骤：
    （1）使用无参数构造器创建对象c1并初始化c1的成员变量
    （2）使用带参构造器创建对象c2同时初始化成员变量，并调用说话方法
     */
    public static void main(String[] args) {
        //使用无参数构造器创建对象c1并初始化c1的成员变量
        Cat1 c1 = new Cat1();
        c1.name = "猫";
        c1.age = 10;
        c1.say();
        //使用带参构造器创建对象c2同时初始化成员变量，并调用说话方法
        Cat1 c2 = new Cat1("猫2", 15);
        c2.say();
    }
}

注意: 当你手机创建了其他的构造器, 默认的构造器就不存在了, 如果需要使用要手动添加.

特点: 构造器之间的关系是重载关系.

2.封装思想

封装: 把对象的字段和方法存在一个独立的模块中.封装可以把信息隐藏, 尽可能隐藏对象的数据和功能实现的细节.

封装的好处: 1.保证数据的安全性, 防止使用者随意修改.

2. 提高组件的重用性, 把公共功能放到一个类中, 谁需要谁就可以直接调用.

2.1访问修饰符

访问修饰符: 决定了有没有权限访问某个资源.

• private: 表示当前类私有的, 类访问权限, 只能在本类中操作, 离开本类之后就不能直接访问.
• 不写( 缺省) : 表示当前包私有, 包访问权限, 定义和调用只能在同一个包中, 才能访问.
• protected: 表示子类访问权限, 同包中的可以访问, 即使不同包但是有继承关系也可以访问.
• public: 表示公共的, 可以在当前项目中任何地方访问.

所有的字段都使用private修饰, 所以的方法用public修饰.

2.2 封装使用

2.2.1 JavaBean规范

规范:1. 类必须使用public修饰

  2. 必须保证有公共无参构造器, 手动提供了有参构造器, 也要手动提供无参构造器.

  3. 字段使用private修饰, 每个字段提供一堆getter和setter方法.

类:

//需求：定义一个符合JavaBean规范的学生类
public class Student {
    /*
    作业要求：
    （1）学生有姓名、年龄两个字段
    （2）符合JavaBean规范
     */
    private String name;//学生姓名
    private int age;//学生年龄
    //无参构造器
    public Student() {
    }
    //有参构造器
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    //get set方法
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        //年龄是否符合常理
        if (age < 0) {
            System.out.println("输入年龄错误");
            return;
        }
        this.age = age;
    }
}

测试类:

//需求：作为Student类和对象的测试类
public class StudentDemo {
    /*
    步骤：
    （1）创建学生对象
    （2）使用setter方法设置值
    （3）获取对象成员变量的值
    （4）通过有参数构造器创建对象并使用setter方法修改值
     */
    public static void main(String[] args) {
        //创建学生对象
        Student s = new Student();
        //使用setter方法设置值
        s.setName("周");
        s.setAge(11);
        //获取对象成员变量的值
        String name = s.getName();
        int age = s.getAge();
        System.out.println("姓名:" + name + ",年龄:" + age);
        //通过有参数构造器创建对象并使用setter方法修改值
        Student s1 = new Student("周2", 17);
        s1.setName("周3");
        s1.setAge(55);
        name = s1.getName();
        age = s1.getAge();
        System.out.println("姓名:" + name + ",年龄:" + age);
    }
}

3. 总结

3.1 面向过程和面向对象的区别?

面向过程: 事情先做什么再做什么.

面向对象: 我该让谁去做什么. 面向对象更符合我们的常规思维.

3.2 什么是抽象?

抽象: 在已经存在的多个事物中, 抽取我们关注的特性, 行为, 产生一个新的事物的过程.

3.3 成员变量和局部变量的区别?

1. 初始值

   成员变量初始值取决与他的数据类型.

   局部变量没有初始值.

2. 作用域

   成员变量的作用域是在定义的类中都可以用

   局部变量的作用域是在定义它的{ }内使用

3. 生命周期

   成员变量: 随着对象销毁一起销毁.

   局部变量: 随着定义的方法销毁一起销毁

4. 数据的存储位置

   成员变量: 存储在堆内存中.

   局部变量: 存储在栈内存中.

3.4 什么是类?什么是对象?

类: 是对某一个事物的抽象描述.

对象: 把类在现实生活中实例化.

3.5 定义类的语法?

语法:

public class 类名{
    //成员变量
    [修饰符] 数据类型 变量名;
    
    //成员方法
    [修饰符] 返回值类型 方法名称(参数){
        //方法体
    }
}

3.6 创建对象的语法?

类名 对象名 = new 类名( );

3.7 属于对象的成员有哪些?

成员对象包括: 成员变量, 成员方法

3.8 构造器的作用和语法

构造器作用: 创建对象,给对象赋值初始化.

构造器语法:

//构造器
[public] 类名(参数){
    //方法体
}

3.9 如何理解封装思想?

封装可以让数据变得更加安全, 使用者不能随意修改数据. 提高组件的重用性, 把公共功能放到一个地方, 使用者要使用时就直接调用.

3.10 public和private修饰符的区别?

public: 公共的可以被类内部、同一个包、子类、任何地方访问.

private: 私有的只能被类内部访问.

3.11 JavaBean规范有哪些?

类名使用public修饰

必须保证有公共无参构造器, 如果手动定义了有参构造器, 那么也需要手动构造无参构造器.

字段必须使用private修饰. 并给他定义get set方法.