面向过程：当需要实现一个功能的时候，每一个具体步骤都需要亲力亲为，详细处理每一个细节。
面向对象：当需要实现一个功能的时候，不关心具体的步骤，而是找一个已经具有该功能的人，来帮我做事儿。
面向对象的语言中，包含了三大基本特征：封装、继承、多态。
封装性在Java当中的体现：
1.方法就是一种封装
2.关键字private也是一种封装
封装就是将一些细节隐藏起来，对于外界不可见。
public class Demo01PrintArray {
public static void main(String[] args) {
int[] array = {10,20,30,40,50};
//要求打印格式为：[10,20,30,40,50]
//使用面向过程,每一个步骤细节都要亲力亲为
System.out.println("[");
for (int i = 0; i < array.length; i++) {
if(i == array.length - 1){//如果是最后一个元素
System.out.println("]");
}else{//如果不是最后一个元素
System.out.print(array[i] + ",");
}
}
System.out.println("========");
//使用面向对象
//找一个jdk给我们提供好的Arrays类
//其中有一个toString方法，直接就能把数组变成想要的格式的字符串
System.out.println(Arrays.toString(array));
}
}
定义一个类，用来模拟“学生”事务，其中就有两个部分组成。
1.属性（是什么）：
姓名
年龄
2.行为（能做什么）：
吃饭
睡觉
学习
对应到Java的类当中：
成员变量（属性）：
String name;//姓名
int age;//年龄
成员方法（行为）：
public void eat(){}//吃饭
public void sleep(){}//睡觉
public void study(){}//学习
注意事项：
1.成员变量是直接定义在类当中的，在方法外边
2.成员方法不要写static关键字
public class Student {
//成员变量
String name;//姓名
int age;//年龄
//成员方法
public void eat(){
System.out.println("吃饭饭！");
}
public void sleep(){
System.out.println("睡觉觉！");
}
public void study(){
System.out.println("学习！");
}
}
通常情况下，一个类并不能直接使用，需要根据类创建一个对象，才能使用。
1.导包：也就是指出需要使用的类，在什么位置。
import 包名称.类名称；
import cn.day03.demo01.Student;
对于当前属于同一个包的情况，可以省略导包语句不写。
2.创建格式：
类名称 对象名 = new 类名称（）；
Student stu = new Student();
3.使用，分为两种情况：
使用成员变量：对象名.成员变量名
使用成员方法：对象名.成员方法名(参数);
（也就是，想用谁，就用对象名点儿谁）
注意事项：
如果成员变量没有赋值，那么将会有一个默认值，规则和数组一样。
public class Demo02Student {
public static void main(String[] args) {
//1.导包
//我需要使用Student类，和我自己Demo02Student位于同一个包下，所以省略导包语句不写
//2.创建格式
//类名称 对象名 = new 类名称（）；
//根据Student类，创建了一个名为stu的对象
Student stu = new Student();
//3.使用其中的成员变量，格式
//对象名.成员变量名
System.out.println(stu.name);
System.out.println(stu.age);
System.out.println("========");
//改变对象当中的成员变量数值内容
//将右侧的字符串赋值给stu对象当中的name成员变量
stu.name = "渣渣辉";
stu.age = 36;
System.out.println(stu.name);
System.out.println(stu.age);
System.out.println("========");
//4.使用对象方法，格式
//对象名.成员方法名();
stu.eat();
stu.study();
stu.sleep();
}
}
局部变量和成员变量不同：
1.定义的位置不一样【重点】
局部变量：定义在方法内部
成员变量：定义在方法外部，直接写在类当中
2.作用范围不一样【重点】
局部变量：只有方法当中才可以使用，出了方法就不能再用
成员变量：整个类全部都可以通用
3.默认值不一样【重点】
局部变量：没有默认值，如果想要使用，必须手动赋值
成员变量：如果没有赋值，会有默认值，规则和数组一样
4.内存的位置不一样
局部变量：位于栈内存
成员变量：位于堆内存
5.生命周期不一样
局部变量：随着方法进栈而诞生，随着方法出栈而消失
成员变量：随着对象创建而诞生，随着对象被垃圾回收而消失
问题描述：定义Person的年龄时，无法阻止不合理的数值进来
解决方法：用private关键字将需要保护的成员变量进行修饰
一旦使用了private进行修饰，本类当中仍然可以随意访问；但是超出了本类范围就不能直接访问。
间接访问private成员变量，就是定义一对Getter/Setter方法
必须叫setXXX或者getXXX命名规则。
对于Getter来说，不能有参数，返回值类型和成员变量对应；
对于Setter来说，不能有返回值，参数类型和成员变量对应。
对于基本类型当中的boolean值，Getter方法一定要写成isXXX的形式，而setXXX规则不变。
public class Person {
String name;
private int age;
public void show(){
System.out.println("我叫" + name +"年龄" +age);
}
//这个成员方法专门用于向age设置数据
public void setAge(int num){
if(num < 120 && num>=0){//如果数据合理
age = num;
}else{//如果数据不合理
System.out.println("数据不合理！");
}
}
//这个成员方法专门私语获取age的数据
public int getAge(){
return age;
}
}
public class Demo02Person {
public static void main(String[] args) {
Person person = new Person();
person.show();
person.name = "koss";
person.setAge(20);
person.show();
}
}
当方法的局部变量和类的成员变量重名时，根据“就近原则”，优先使用局部变量。
如果需要访问本类当中的成员变量，需要使用格式：
this.成员变量名
“通过谁调用的方法，谁就是this。”
构造方法是专门用来创建对象的方法，当我们通过关键字new来创建对象时，其实就是调用构造方法。
格式：
public 类方法（参数类型 参数名称）{
方法体
}
注意事项：
1.构造方法的名称必须和所在的类名称完全一样，就连大小也要一样
2.构造方法不要写返回值类型，练void都不写
3.构造方法不能return一个返回值
4.如果没有编写任何构造方法，那么编译器会默认赠送一个构造方法，没有参数、方法体，什么事情都不做
public Student(){}
5.一旦编写了至少一个构造方法，那么编译器将不再赠送
6.构造方法也可以进行重载的
重载：方法名称相同，参数列表不同
一个标准的类通常要拥有下面四个组成部分：
1.所有成员变量都要使用private关键字修饰
2.为每个成员变量编写一对Getter/Setter方法
3.编写一个无参数的构造方法
4.编写一个全参数的构造方法
这种标准类也叫Java Bean