Java面向对象笔记

面向对象

1.1 面向对象思想

概述

• 面向对象：当需要实现一个功能的时候，不关心具体的步骤，而是找一个已经具有该功能的人，来帮我们做这件事。

• 面向过程：当需要实现一个功能的时候，每一个具体的步骤都需要亲力亲为，详细处理每一个细节。

public static void main (String[] args){
    int [] array={10,20,30,40,50,60};
    //打印要求｛10,20,30,40,50,60｝
    System.out.print("[");//面向过程
    for(int i=0;i<array.length;i++){        
        if(i==array.length-1){
            System.out.print(array[i]+"]");
        }else{
            System.out.print(array[i]+",");
        }        
    }
   System.out.println(Arrays.toString(array));//面向对象
}

面向对象举例

• 洗衣服

  • 面向过程：把衣服脱下来–找个盆–放点洗衣粉–加点水–侵泡10分钟–揉一揉–手洗衣服–拧干–晾起来
  • 面向对象：把衣服脱下来–打开全自动洗衣机–扔衣服进洗衣机–启动–晾衣服

• 区别

  • 面向过程：强调过程详细步骤
  • 面向对象：强调对象，这里的对象就是洗衣机

特点

面向对象思想是一种更符合我们思考习惯的思想，它可以将复杂的事情简单化，并将我们从执行者变成指挥者。

面向对象的语言中，包含了三大基本特征，即封装、继承、多态。

1.2 类和对象

环顾周围，你会发现很多对象，比如桌子、椅子、同学、老师等，桌椅属于办公用品，师生都是人类。那么什么是类，什么是对象呢？

什么是类

• 类：是一组相关属性和行为的集合。可以看成是一类事物的模版，使用事物的属性特征来描述该类事物。

现实中，描述一类事物：

• 属性：就是该事物的状态信息 。
• 行为：就是该事物可以做什么。

举例：小猫

• 属性：名字、颜色、年龄、体重、身高。
• 行为：走、跑、叫、吃。

什么是对象

• 对象：是一类事物的具体体现。对象是一个类的实例（对象并不是找个女朋友），必然具备该类的属性和行为。

现实中，一类事物的一个实例：一只小猫

举例：一只小猫

• 属性：tom、yellow、2years、5kg
• 行为：溜墙根走、蹦跶着跑、撒娇的叫、大口的吃

类与对象的关系

• 类是对一类事物的描述，是抽象的

• 对象是一类事物的实例，是具体的

• 类是对象的模版，对象是类的 实体

  就好比手机是一个类，iPhone11是一个对象

1.3 类的定义

事物与类的对比

现实世界的一类事物：

​ 属性：事物的状态信息

​ 行为：事物能够做什么

Java中用class描述事物也是如此：

​ 成员变量：对应事物的属性

​ 成员方法：对应事物的行为

类的定义格式

public class ClassName{
    //成员变量
    //成员方法
}

• 定义类：就是定义类的成员，包括成员变量和成员方法。
• 成员变量：和前面定义的变量基本上一样，只不过这个变量在类的里面，方法的外面。
• 成员方法：和之前基本一样，区别在于去掉了static。

类的使用

通常情况下，一个类不能直接使用，需要根据类创建对象，才能使用。

1. 导包：也就是支出需要使用的类在什么位置（import 包名称.累名称；）

   对于和当前类属于同一个包的情况，可以省略导包语句。

2. 创建：类名 对象名=new 类名（）；

   Student student=new Student();

3. 使用：有两种情况

   使用成员变量：对象名.成员变量名

   使用成员方法：对象名.成员方法名（参数）

注意事项：如果成员变量没有进行赋值，那么将会有一个默认值，规则和数组一样。

public class Students {
    String name;
    private int age;
    public void eat(){
        System.out.println("吃饭");
    }
    public void sleep(){
        System.out.println("睡觉");
    }
    public void study(){
        System.out.println("学习");
    }
}
public class Test {
    public static void main(String[] args) {
        Students students = new Students();
        System.out.println(students.name);
        students.eat();
        students.sleep();
        students.study();
        students.name="赵丽颖";
        System.out.println(students.name);
    }
}

对象也可以当作参数进行传递，只不过是传递对象的地址值。

局部变量和成员变量

1. 定义的位置不一样

   成员变量：类里面，方法外面

   局部变量：方法里面

2. 作用范围不一样

   成员变量：整个类都可以使用

   局部变量：只有方法中才可以使用，出了方法就不能用了

3. 默认值不一样

   成员变量：如果没有赋值，会有初始值

   局部变量：没有默认值，如果想要使用，必须手动赋值

4. 内存的位置不一样

   局部变量位于栈内存

   成员变量位于堆内存

5. 生命周期不一样

   局部变量：随着方法进栈而诞生，随着方法出栈而消失

   成员变量：随着对象创建而诞生，随着对象的垃圾回收而消失

1.4 面向对象的三大特性

封装性

• 封装性在Java中的体现：
  • 方法就是一种封装
  • 关键字private也是一种封装
• 封装就是将一些细节信息隐藏起来，对外界不可见
  • 如下就将一个获取数组最大值的方法封装在getMax方法中

public static void main(String [] args){
    int[] array = {2,15,63,28,64,75,22};
    int max = getMax(array);
    System.out.println(max);
}

public static int getMax(int[] array){
    int max=array[0];
    for(int i=1;i<array.length;i++){
        if(array[i]>max){
            max=array[i];
        }
    }
    return max;
}

---

• private

  在我们定义一个类的时候，有时我们需要保护我们的成员变量不被用户篡改，就需要用关键字private修饰。

  一旦使用了private关键字对成员变量进行修饰，那么该成员变量在本类中任然可以继续使用，但是出了这个类就不能再直接访问了。

• 使用成员方法setAge，专门向age变量设置数据，因为是设置数据，所以这个方法有参数没有返回值。

• 使用成员方法getAge，专门读取私有变量，因为是读取，所以这个方法没有参数，但是有返回值。

public class Person{
    String name;
    private int age;
    public void show(){
        System.out.println("我叫："+name+"，年龄："+age);
    }
    public void setAge(int number){
        if(number<100&&number>0){
        	age = number;            
        }else{
            System.out.println("数据不合理");
        }
    }
    public int getAge(){
        return age ;
    }
}

public static void main(String[] args) {
        Person person = new Person();
        person.show();
        person.name="迪丽热巴";
        person.setAge(15);
        person.show();
}

特例：private修饰的布尔变量，它的访问方法是set…和is…

---

• this

  当方法的局部变量和类的成员变量重名时，根据就近原则，优先使用局部变量。

  如果需要访问本类中的成员变量，就需要使用this.成员变量名

通过谁调用的方法，谁就是this

1.5 构造方法

构造方法是专门用来创建对象的方法，当我们通过关键字new来创造对象的时候，其实就是在调用构造方法。

格式：

​ public 类名称 (参数类型 参数名称){

​ 方法体;

​ }

注意事项：

1. 构造方法的名称必须和类名称完全一致，包括大小写。
2. 构造方法不要写返回值类型，就连void都不要写。
3. 构造方法不能return一个具体的返回值。
4. 如果自己不写构造方法，那么编译器就会默认赠送一个空的构造方法。没有参数也没有方法体。
5. 如果自己编写了至少一个构造方法，那么编译器将不再赠送。
6. 构造方法也是可以重载的。

一个标准的类

• 组成部分：
  • 所有的成员变量都要用private关键字修饰
  • 为每一个成员变量编写一对儿get/set方法
  • 编写一个无参构造方法
  • 编写一个全参构造方法

public class Students {
    private String name;
    private int age;
    public void eat(){        
        System.out.println("吃饭");
    }
    public void sleep(){
        System.out.println("睡觉");
    }
    public void study(){
        System.out.println("学习");
    }

    public Students() {
    }

    public Students(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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