**

**

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

面向过程编程思想

• 强调的是过程，每一步都要清楚，然后一步一步实现
• 强调对象， 通过调用对象的行为来实现功能，而不是一步一步地实现。

比较两种编程思想

• 洗衣服:

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

• 吃饭

  • 面向过程: 买菜—>洗菜—>炒菜—>吃
  • 面向对象: 找个饭店–>10块钱

• java程序：要求：打印数组中的所有元素，打印格式为： [元素1，元素2，元素3，元素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));
    }

}

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

类的概述

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

类的组成

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

举例

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

小结

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

对象的概念

类和对象的关系

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

小结

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

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

• 属性:该类事物的状态信息,在类中通过成员变量来体现（类中方法外的变量）
• 该类事物有什么功能,在类中通过成员方法来体现（和前面的方法相比去掉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)
}

对象的创建

• 创建对象的格式：
  • 类名 对象名 = 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

需求

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

分析

• 定义学生类
  • 成员变量：姓名，年龄…
  • 成员方法：学习，做作业…
• 测试类
  • 创建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();
    }
}

小结

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

小结

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

小结

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

讲解

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

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修饰的成员变量或者成员方法,只能在本类中访问

为什么要对属性进行封装

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 方法(给属性赋值)。

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());


    }
}

问题

我们发现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所在的方法,谁就是当前对象

略

封装概述

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

封装原则

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

封装好处

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

构造方法的概述

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

构造方法的定义

• 格式

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

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