day01-面向对象入门(类和对象)

知识点1-类和对象

知识点–1. 面向对象和面向过程编程思想

**

讲解

**

编程思想其实就是编程思路,我们开发中2种经典的编程思想就是面向过程编程思想和面向对象编程思想.

面向过程编程思想

  • 强调的是过程,必须清楚每一个步骤,然后按照步骤一步一步去实现
  • 强调的是对象, 通过调用对象的行为来实现功能,而不是自己一步一步的去操作实现。

举例对比2种编程思想

  • 洗衣服:

    • 面向过程:把衣服脱下来–>找一个盆–>放点洗衣粉–>加点水–>浸泡10分钟–>揉一揉–>清洗衣服–>拧干–>晾起来
    • 面向对象: 把衣服脱下来–>给女朋友去洗
  • 吃饭

    • 面向过程: 买菜—>洗菜—>炒菜—>吃
    • 面向对象: 找个饭店–>10块钱
  • java程序:需求:打印数组中所有的元素,打印格式为: [元素1,元素2,元素3,元素,…,元素n]

import java.util.Arrays;

public class Test {
    public static void main(String[] args) {
        //面向过程
        //定义一个数组
        int[] arr={10,20,30,40,50,60};
        System.out.print("[");
        for (int i = 0; i < arr.length; i++) {
            if(i==arr.length-1){
                System.out.print(arr[i]);
            }else{
                System.out.print(arr[i]+",");
            }
        }
        System.out.println("]");
        System.out.println("========================");
        //面向对象
       //api中jdk提供了一个Arrays类,该类的toString方法可以帮助我们按照这种格式打印数组中的元素
        System.out.println(Arrays.toString(arr));
    }

}

小结

  • 面向过程:是一种编程思想
  • 面向对象:是一种编程思想
  • 区别:
    • 面向过程:注重的是步骤,必须清楚每一个步骤,按照步骤一步一步去实现
    • 面向对象::注重的是对象,无须清楚每一个步骤,只需要使用对象调用行为来完成需求

知识点–2. 类的概述

讲解

类的概述

  • 类是用来描述一类具有共同属性和行为事物的统称。所以其实类在客观世界里是不存在的,是抽象的,只是用来描述数据信息的。
  • 人类: 描述信息
  • 手机类: 描述信息
  • 学生类: 描述信息
  • 狗类: 描述信息

类的组成

  • 属性: 就是该事物的状态信息。
  • 行为: 就是该事物能够做什么。

举例

  • 手机类
    • 属性:品牌、价格…。
    • 行为:打电话、发短信…。

小结

  • 类是用来描述一群具有共同属性和行为事物的统称,类是抽象的,看不见,摸不着的,用来描述数据信息的
  • 类的组成:
    • 属性
    • 行为

知识点–3. 对象的概述

讲解

对象的概念

  • 对象是类的一个实例(并不是你的女朋友哈),具体存在的,看得见摸得着的,并且具备该类事物的属性和行为
    - 对象的属性:对象的属性具有特定的值
    - 对象的行为:对象可以操作的行为
  • 人类: 描述信息 抽象
    • 李四
    • 张三
  • 手机类: 描述信息
    • 你手上的那台华为手机
  • 学生类: 描述信息
    • 106期的张三
  • 狗类: 描述信息
    • 张三家的那条狗

举例

  • 对象: 你手上拿的这台手机
    • 属性:华为、1999…。 对象的属性具体的值,类中的属性没有具体的值
    • 行为:使用打电话功能,使用发短信功能。对象可以使用行为
  • 例如:
  • 自行车---------->类
  • 摩拜单车------->类
  • 你早上骑得那辆摩拜单车---->对象

小结

  • 对象是类的实例,具体存在的,看得见摸得着的
  • 对象的属性是有具体的值
  • 对象的行为其实就是可以使用的功能\行为

知识点–4. 类和对象的关系

讲解

类和对象的关系

  • 类是对一类具有共同属性和行为的事物的统称,是抽象的
  • 对象是一类事物的具体实例,看得见,摸的着的,真实存在的实体,是具体的
  • 类是对象的抽象,对象是类的实体
    ![在这里插入图片描述](https://img-blog.csdnimg.cn/0641627384bf4cb8986482cee4f7a126.png

小结

  • 类是对象的抽象,对象是类的实体
  • 类看成是对象的数据类型: (类是用来描述对象)

知识点–5. 类的定义【应用】

讲解

复习类的组成
类的组成是由属性和行动两部分组成

  • 属性:该类事物的状态信息,在类中通过成员变量来体现(类中方法外的变量)
  • 该类事物有什么功能,在类中通过成员方法来体现(和前面的方法相比去掉static关键字即可)

类的定义步骤

  1. 定义类
  2. 编写类的成员变量
  3. 编写类的成员方法

类的定义格式

public class 类名 {// 定义一个类
// 类里面:属性(成员变量),行为(成员方法)
    // 定义成员变量
    数据类型 变量名1;
    数据类型 变量名2;
    ...
    // 定义成员方法
    方法;  去掉static  
 }    

举例

  • 定义一个手机类,类名为(Phone),类的属性有:品牌(brand),价格(price),类的行为:打电话(call),发短信(sendMessage)
public class Phone {//定义一个手机类
    //定义属性(成员变量)
    String brand;
    double price;

    //定义行为(成员方法)
    public void call(String phoneNum) {
        System.out.println("打电话给"+phoneNum);
    }

    public void sendMessage(String phoneNum,String message) {
        System.out.println("发"+message+"给"+phoneNum);
    }


}

小结

  • 定义类的格式
public class 类名{//定义一个类
	//类里面:属性(成员变量)  行为(成员方法)
	//定义成员变量
	数据类型  变量名1;
	数据类型  变量名2;
	...
	//定义成员方法
	方法(去掉static)
}

知识点–6. 对象的创建和使用

讲解

对象的创建

  • 创建对象的格式:
    • 类名 对象名 = new 类名();
    • 类其实就是对象的数据类型,类是引用数据类型
    • 例: Phone p1 = new Phone (); 创建了一个手机对象(Phone类的对象)

对象的使用

  • 调用成员的格式:

    • 访问成员变量
      • 获取成员变量的值: 对象名.成员变量名
      • 给成员变量赋值: 对象名.成员变量名=值;
  • 访问成员方法

    • 对象名.成员方法();

案例演示

public class Phone {//定义一个手机类
    //定义属性(成员变量)
    String brand;
    double price;

    //定义行为(成员方法)
    public void call(String phoneNum) {
        System.out.println("打电话给"+phoneNum);
    }

    public void sendMessage(String phoneNum,String message) {
        System.out.println("发"+message+"给"+phoneNum);
    }


}

public class Test01 {
    public static void main(String[] args) {
        /*
        * 对象的创建(重点)
        *   格式: 类名 对象名 =new 类名();
        *
        * 对象的使用:
        *   访问成员变量:对象名.成员变量名
        *
        *   成员变量有默认值:
        *       整数类型:默认值是0
        *       小数类型:默认值是0.0
        *       布尔类型:默认值是false
        *       字符类型:默认值是不可见字符
        *       引用类型:默认值是null
        *
        *   访问成员方法(重点):
        *       无返回值的方法:对象名.方法名(实参);----->直接调用
        *       有返回值的方法:对象名.方法名(实参);----->直接调用
        *                      数据类型 变量名=对象名.方法名(实参);------>赋值调用(开发中常用)
        * */
        //创建手机对象
        Phone p1 = new Phone();

        //访问成员变量
        System.out.println(p1.brand);
        System.out.println(p1.price);

        //给成员变量赋值
        p1.brand="苹果";
        p1.price=5999.9;

        //取值
        System.out.println(p1.brand);
        System.out.println(p1.price);

        System.out.println("===================================");
        //访问成员方法
        p1.call("10010");
        p1.sendMessage("10010","cxll");
    }
}

小结

对象的创建(重点):
	 格式: 类名 对象名 = new 类名();
对象的使用: 
	 访问成员变量: 对象名.成员变量名
	 访问成员方法(重点):
	 无返回值的方法: 对象名.方法名(实参);                ------>直接调用
	  有返回值的方法:
                 对象名.方法名(实参);                 ------>直接调用
                 数据类型 变量名 = 对象名.方法名(实参); ------>赋值调用       开发中

	成员变量有默认值:
                整数类型: 默认值是0
                小数类型: 默认值是0.0
                布尔类型: 默认值是false
                字符类型: 默认值是不可见字符
                引用类型: 默认值是null

实操–7. 学生对象-练习

需求

  • 首先定义一个学生类,然后定义一个学生测试类,在学生测试类中通过对象完成成员变量和成员方法的使用

分析

  • 定义学生类
    • 成员变量:姓名,年龄…
    • 成员方法:学习,做作业…
  • 测试类
    • 创建main方法,在main 方法中创建学生对象
    • 使用学生对象访问成员变量和访问成员方法
package com.bb;

public class Student {
    String name;
    int age;


    public void study() {
        System.out.println("正在学习..");
    }

    public void doHomework() {
        System.out.println("正在做作业...");
    }


}

package com.bb;

public class StudentTest {
    public static void main(String[] args) {
        Student s1 = new Student();

        //给成员变量赋值
        s1.name="香茗";
        s1.age=18;
        System.out.println(s1.name);
        System.out.println(s1.age);

        //使用对象访问成员方法
        s1.study();
        s1.doHomework();
    }
}

知识点–8. 单个对象内存图

小结

  • 只要创建对象,就会在堆区开辟一块空间
  • 只要调用方法,就会在栈区开辟一块空间,用来执行该方法

知识点–9. 多个对象内存图【理解】

小结

  • 多个对象在堆内存中,都有不同的内存划分,成员变量存储在各自的内存区域中,成员方法多个对象共用的一份
  • 凡是new就会重新在堆区开辟一块新空间
  • 对象和对象之间的关系是相互独立的

知识点–10. 多个变量指向相同对象内存图【理解】

小结

  • 多个对象的引用指向同一个内存空间(变量所记录的地址值是一样的)
  • 只要有任何一个对象修改了内存中的数据,随后,无论使用哪一个对象进行数据获取,都是修改后的数据。

知识点–11. 成员变量和局部变量的区别【理解】

讲解

  • 类中位置不同:成员变量(类中方法外)局部变量(方法内部或方法声明上)
  • 内存中位置不同:成员变量(堆内存) 局部变量(栈内存)
  • 生命周期不同:成员变量(随着对象的存在而存在,随着对象的消失而消失) 局部变量(随着方法的调用而存在,随着方法的调用完毕而消失)
  • 初始化值不同:成员变量(有默认初始值) 局部变量(没有默认初始化值,必须先定义,赋值才能使用)

知识点–2. 封装

知识点–2.1 private关键字

讲解

private的含义

  • 概述: private是一个权限修饰符,代表最小权限。
  • 特点:
    • 可以修饰成员变量和方法
    • 被private修饰后的成员变量和成员方法,只在本类中使用

private的使用格式

// private关键字修饰成员变量
private 数据类型 变量名 ;

// private关键字修饰成员方法
private 返回值类型 方法名(参数列表){
    代码
}
package com.bb;

public class Student1 {
    String name;
    private int age;

    public void study() {
        System.out.println("正在学习java....");
    }

    private void doHome() {
        System.out.println("正在当天写布置的java代码");
    }
}

package com.bb;

public class Test01 {

    public static void main(String[] args) {
        Student1 s1 = new Student1();
        s1.name = "哈哈";
        s1.study();


    }
}

小结

  • private的含义: private是一个权限修饰符,表示最小的权限
    • private的使用: 修饰成员变量和成员方法

      • 修饰成员变量的格式: private 数据类型 变量名;
      • 修饰成员方法的格式: private 返回值类型 方法名(参数列表){…}
  • 特点: 被private修饰的成员变量或者成员方法,只能在本类中访问

知识点–2.2 对属性封装的步骤

讲解

为什么要对属性进行封装

public class Student {
    // 成员变量
     String name;// 姓名
     int age;// 年龄

}

public class Test {
    public static void main(String[] args) {
		 // 创建对象
        Student stu = new Student();

		// 给属性赋值
        stu.name = "冰冰";
        //通过对象名直接访问成员变量的方式对属性进行赋值,会存在数据安全隐患
        //怎么解决?-->解决办法:对类中的属性进行封装(隐藏),让外界不能直接通过对象名访问
        stu.age = -18;// 数据是不合法的
        System.out.println(stu.name);// 冰冰
        System.out.println(stu.age);// -18
}
  • 通过对象名直接访问成员变量的方式来对属性赋值,会存在数据安全隐患,应该怎么解决呢?
  • 解决方式: 不让外界直接访问成员变量(也就是要对属性进行封装)

对属性封装的步骤

1.使用private修饰成员变量

public class Student {
    // 成员变量
    private String name;// 姓名
    private int age;// 年龄
}

2.对需要访问的成员变量,提供对应的getXxx方法(获取属性的值) 、setXxx 方法(给属性赋值)。

知识点–2.3 set和get方法

讲解

set和get方法的介绍

  • 由于属性使用了private关键字修饰,在其他类中无法直接访问,所以得提供**公共的访问方法,**我们把这张方法叫做set和get方法
    • get方法: 提供“get变量名()”方法,用于获取成员变量的值,方法用public修饰
    • set方法: 提供“set变量名(参数)”方法,用于设置成员变量的值,方法用public修饰

set和get方法的书写

package com.bb;

public class Student2 {
    //成员变量
    private String name;
    private int age;

    //成员方法
    public void setName(String n) {
        name = n;
    }

    public void setAge(int a) {
        if (a < 0 || a > 145) {
            age = 0;
        } else {
            age = a;
        }
    }

    public String getName() {
        return name;

    }

    public int getAge() {
        return age;
    }
}

package com.bb;

public class Test02 {
    public static void main(String[] args) {
        /*
         *  为什么对属性进行封装
         *       通过对象名直接访问成员变量的方式来对属性赋值,会存在数据安全隐患
         *
         *  对属性进行封装
         *       1.使用private关键字修饰成员变量(属性)
         *       2.提供公共的成员方法用来给属性赋值和取值(set\get方法)
         * */
        //创建对象
        Student2 s1 = new Student2();
        //赋值
        s1.setName("超人");
        s1.setAge(2000);//数据不合法
        //取值
        System.out.println(s1.getName());
        System.out.println(s1.getAge());


    }
}

知识点–2.4 this关键字

讲解

问题

我们发现setXxx方法中的形参名字并不符合见名知意的规定,那么如果修改与成员变量名一致,是否就见名知意了呢?代码如下:

public class Student {
  private String name;
  private int age;

  public void setName(String name) {
    name = name;
  }

  public void setAge(int age) {
    age = age;
  }
}

经过修改和测试,我们发现新的问题,成员变量赋值失败了。也就是说,在修改了setXxx() 的形参变量名后,方法并没有给成员变量赋值!这是由于形参变量名与成员变量名重名,导致成员变量名被隐藏,方法中的变量名,无法访问到成员变量,从而赋值失败。所以,我们只能使用this关键字,来解决这个重名问题。

this的含义和使用

  • this含义: this代表当前调用方法的引用,哪个对象调用this所在的方法,this就代表哪一个对象
  • this关键字其主要作用是区分同名的局部变量和成员变量
    • 方法的形参如果与成员变量同名,不带this修饰的变量指的是形参,而不是成员变量
    • 方法的形参如果与成员变量同名,不带this修饰的变量指的是形参,而不是成员变量
  • this的使用格式:
    this.成员变量名
  • 使用 this 修饰方法中的变量,解决成员变量被隐藏的问题,代码如下:
package com.bb;

public class Student2 {
    //成员变量
    private String name;
    private int age;

    //成员方法
    public void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
        if (age < 0 || age > 145) {
            this.age = 0;
        } else {
            this.age = age;
        }
    }

    public String getName() {
        return name;

    }

    public int getAge() {
        return age;
    }
}

在这里插入代码片

小贴士:方法中只有一个变量名时,默认也是使用 this 修饰,可以省略不写。

小结

this关键字:
	1.作用: 用来区分同名的成员变量和局部变量
	2.格式: this.成员变量名
	3.this含义:代表当前对象
	  当前对象: 谁调用this所在的方法,谁就是当前对象

知识点–2.5 this内存原理

讲解

知识点–2.6 封装概述

讲解

封装概述

  • 是面向对象三大特征之一(封装,继承,多态)
  • 是面向对象编程语言对客观世界的模拟,客观世界里成员变量都是隐藏在对象内部的,外界是无法直接操作

封装原则

  • 将类的某些信息隐藏在类内部,不允许外部程序直接访问,而是通过该类提供的方法来实现对隐藏信息的操作和访问
  • 例如:成员变量使用private修饰,提供对应的getXxx()/setXxx()方法

封装好处

  • 通过方法来控制成员变量的操作,提高了代码的安全性
  • 把代码用方法进行封装,提高了代码的复用性

知识点–3. 构造方法

知识点–3.1 构造方法概述

讲解

构造方法的概述

  • 构造方法是一种特殊的方法,主要是完成对象的创建和对象数据的初始化

构造方法的定义

  • 格式
	//空参构造方法
	修饰符  类名(){
	}
    //有参构造方法
    修饰符  类名(参数列表){
     	//方法体
    }

  • 特点:
    • 构造方法的写法上,方法名与它所在的类名相同
    • 构造方法没有返回值,所以不需要返回值类型,甚至不需要void
  • 示例代码
package com.bb;

public class Student3 {
    //成员变量
    private String name;
    private int  age;

    //构造方法
    //空参构造方法
    public Student3(){
        System.out.println("空参构造方法");
    }

    //有参构造方法
    public Student3(String name,int age){
        this.name =name;
        this.age=age;
    }

    //成员方法
    public void show(){
        System.out.println(name+","+age);
    }
}

package com.bb;

public class Test03 {
    public static void main(String[] args) {
        /*
        * 构造方法的概述
        *       概述:构造方法是一种比较特殊的方法
        *       作用:主要用来创建队象,并给对象的属性初始化
        *       特点:
        *           1.构造方法没有返回值,连void都不能写
        *           2.构造方法的方法名必须和类名一致
        *           3.通过new来调用构造方法
        *
        * 构造方法的定义
        *       空参构造:
        *               public  类名(){
        *               }
        *       有参构造:
        *               public 类名(形参){
        *                   给属性赋值
        *               }
        * */

        //调用空参构造方法,创建对象
        Student3 s3 = new Student3();
        s3.show();

        //调用有参构造方法,创建对象
        Student3 s33 = new Student3("哈哈", 19);
        s33.show();

    }

}

小结

 构造方法的概述
        - 构造方法是一种特殊的方法,主要是完成对象的创建和给对象的属性进行初始化
        
构造方法的定义
        - 格式:
            空参构造方法
                修饰符 类名(){

                }

            有参构造方法
                修饰符 类名(参数){
                    方法体(给属性赋值)
                }
          - 特点:
            1.构造方法的方法名和类名一致
            2.构造没有返回值,void都没有

  调用构造方法: 通过new来调用

知识点–3.2 构造方法的注意事项

讲解

  • 构造方法的创建
    • 如果没有定义构造方法,系统将给出一个默认的无参数构造方法
    • 如果定义了构造方法,系统将不再提供默认的构造方法
  • 构造方法可以重载,既可以定义参数,也可以不定义参数。
  • 示例代码
package com.bb;

public class Student4 {
    private String name;
    private int age;

    //构造方法
    //空参构造方法
    public Student4() {

    }

    //有参构造方法
    public Student4(String name) {
        this.name = name;
    }

    public Student4(int age) {
        this.age = age;
    }

    //满参构造方法
    public Student4(String name, int age) {
        this.name = name;
        this.age = age;
    }

    //set/get方法
    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
        this.age = age;
    }


}

package com.bb;

public class Test4 {
    /*
     * 构造方法的注意事项:
     *     1.定义构造方法,方法名一定要和类名一致
     *     2.定义构造方法,一定没有返回值类型,连void都不能写
     *     3.如果一个类没有定义构造方法,系统会默认生成一个空参构造方法
     *     4.如果一个类定义了构造方法,系统就不会默认生成一个空参构造方法
     *     5.构造方法是可以重载的
     *     6.构造方法只能给属性赋值一次,而set方法可以反复给属性赋值
     *
     * */
    public static void main(String[] args) {
        //通过调用空参构造方法,创建Student对象
        Student4 s4 = new Student4();
        s4.setName("nini");
        s4.setAge(18);
        System.out.println(s4.getName() + "," + s4.getAge());

        //通过调用满参构造方法,创建Student对象
        Student4 ss4 = new Student4("meimei", 17);
        System.out.println(ss4.getName()+","+ss4.getAge());

    }


}

小结

构造方法的注意事项:
	-构造方法的创建
      - 如果没有定义构造方法,系统将给出一个默认的无参数构造方法
      - 如果定义了构造方法,系统将不再提供默认的构造方法
    - 构造方法可以重载,既可以定义参数,也可以不定义参数。
    - 定义构造方法的时候,不要写返回值,void都不能有
    - 定义构造方法的时候,构造方法名和类名一定要一致

知识点–3.3 标准类制作

讲解

标准类的组成
JavaBean 是 Java语言编写类的一种标准规范。符合JavaBean 的类,要求类必须是公共的,属性使用private修饰,并且具有无参数的构造方法,提供用来操作成员变量的set 和get 方法。

public class  ClassName{
	//成员变量  private
	//构造方法
	//空参构造方法(必须)
	//满参构造方法(建议)
	//getXxx()
	//setXxx()
	//成员方法

}

案例演示

  • 需求:定义标准学生类,要求分别使用空参和有参构造方法创建对象,空参创建的对象通过setXxx赋值,有参创建的对象直接赋值,并通过show方法展示数据。
  • 示例代码:
package com.bb;

public class Student5 {
    //需求:定义标准学生类,要求分别使用空参和有参构造方法创建对象,空参创建的对象通过setXxx赋值,有参创建的对象直接赋值,并通过show方法展示数据。
    //成员变量
    private String name;
    private int  age;

    //空参构造方法--->快捷键: alt+insert--->Constructor
    public Student5(){

    }

    //满参构造方法
    public Student5(String name,int age){
        this.name =name;
        this.age=age;
    }

    //set\get方法---快捷键:alt+insert--->Getter and Setter
    public String getName(){
        return name;
    }
    public void setName(String name){
        this.name=name;
    }
    public int getAge(){
        return age;
    }

    public void setAge(){
        this.age =age;
    }
 
    //成员方法
    public void show(){
        System.out.println(name+","+age);
    }

}

知识点–4. API

API的概念

  1. 什么是API
    API (Application Programming Interface) :应用程序编程接口。 Java API是一本程序员的字典 ,是JDK中提供给我们使用的类的说明文档。这些类将底层的代码实现封装了起来,我们不需要关心这些类是如何实现的,只需要学习这些类如何使用即可。所以我们可以通过查询API的方式,来学习Java提供的类,并得知如何使用它们。
    • API其实就是jdk中核心类库的说明文档
    • 对于jdk中的核心类库只需要知道如何使用,无须关心他是如何实现的

API的使用步骤

  1. 打开API帮助文档。
  2. 点击显示,找到索引,看到输入框。
  3. 你要找谁?在输入框里输入,然后回车。
  4. 看包。java.lang下的类不需要导包,其他需要。
  5. 看类的解释和说明。
  6. 看构造方法。
  7. 看成员方法。
  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值