1.面向对象编程思想：“类”的引入
前面我们学习过数组，当需要多次遍历数组时，我们可以将遍历的代码封装到方法中，需要遍历时，就调用相应的方法即可，提高代码的复用性。
在对数组遍历的基础上继续增加需求，比如获取最值，数组逆转等，同样需要将这些功能封装到相应的方法中。这样继续封装会发现方法越来越多，于是就想能不能将这些方法继续进行封装呢？
在前面的学习过程中，我们知道“类”是可以存放方法的（虽然目前还不清楚如何去设计一个完整的类，但最起码知道，类中是可以存放多个方法的），比如：main方法，自定义的add方法，show方法，sop打印方法等。所以，我们就考虑使用“类”来封装多个方法，将来有需要再对数组做相关的操作时，不是直接去找自定义的方法，而是先找到封装了这个方法的类，然后使用这个类中的方法。这就是面向对象思想的编程方式。
从面相对象编程的角度考虑，类就是对多个方法的封装，当然，在类中除了方法，还有方法需要用到的一些变量等
- 功能的封装==>方法
- 多个方法和相关变量的封装==>类
当你在编程过程中，想实现一个功能，不是直接在main方法外边去定义方法，而是想到先去定义一个“类”的时候，你已经具备了面向对象的编程思想。
2.面向过程思想概述
之前如果想要完成一个需求，一般的步骤是：首先是搞清楚要做什么，然后再分析怎么做，最后我们再写代码实现
那么什么是面向过程开发呢？所谓的面向过程开发，其实就是面向着具体的每一个步骤和过程，把每一个步骤和过程完成，然后由这些功能方法相互调用，完成需求。
面向过程的代表语言：C语言
3.面向对象思想概述
当需求单一，或者简单时，我们一步一步去操作没问题，并且效率也挺高。可随着需求的更改，功能的增多，发现需要面对每一个步骤很麻烦了，这时就开始改进，能不能把这些步骤和功能再进行封装，封装时根据不同的功能，进行不同的封装，功能类似的，或者有关联关系的封装在一起，这样结构就清晰了很多。用的时候，找到对应的类就可以了。这就是面向对象的思想。接下来我们看看面向对象到底是什么？
假设有一个任务：写一个功能完整的Java程序，然后把这个程序部署到测试环境中
仔细分析这个任务，发现需要完成这个任务的话，应该有两个动作：
- 写程序
- 部署到测试环境
如果按照面向过程的编程思想的话，应该编写两个函数，分别用来实现上面提到的两个功能，然后依次调用这些函数，当这两个函数执行完了之后，整个任务就完成了。
如果使用面向对象的思想编程的话，就把功能分解，交给不同的“对象”去完成。
对象：可以暂时理解成具有某些功能的一个综合体
例如，上面的任务中，涉及到了两个任务，写代码和部署程序，那么就去找哪个对象具有这样的功能，直接调用它们相应的方法就可以了
整个过程如下：
首先考虑谁会写代码，谁会部署程序，然后分别去找他们
找到对象1 --> 写代码 --> 完成
找到对象2 --> 部署程序 --> 完成
--> 整个任务完成
比如，有如下三个人，每个人都有自己的功能：使用伪码体现
张三{
Public void 部署程序(){
System.out.println("部署java程序");
}
}
李四{
Public void 写代码(){
System.out.println("写java代码")
}
}
小明{
Public void 玩游戏(){
System.out.println("玩游戏")
}
}
第三个人不具有想要使用的功能，所以不会用到
另外还有一个人，负责总指挥，调度每个人执行的先后顺序等
老板{
Public static void main(String[] args){
李四.写代码();
张三.部署程序 ();
...
}
}
从以上的概述可以得出这样的结论：
面向过程：强调的是过程，每个过程及实施都要自己一步一步去实施，考虑的事情比较多
面向对象：强调的是对象，需要某些功能的时候，去找具有这样功能的对象，然后由对象去调用功能
4.面向对象思想的特点
- 是一种更符合我们思想习惯的思想
- 可以将复杂的事情简单化，不必考虑执行的每一个细节，只从宏观上把握
- 将我们从执行者变成了指挥者
5.类和对象的含义
- 对象：就是一个具体的事物，它有自己的属性和行为
比如：一只狗，它有属性：颜色，体重，品种，它有行为：跑，叫，看家等等
比如：一个手机，它有属性：颜色，价格，品牌等，它有行为：打电话，发短信等
比如：笔记本电脑，它有属性：品牌，价格，内存大小，它有行为：开机，关机，播放音乐，可以打字等等
- 类：同一种事物的抽象，将它们共同的属性和行为抽象出来，就是类
比如前面说的狗，可以抽象出来一个犬类，手机，可以抽象出一个手机类，在代码中就是用关键字class定义类
6.类与对象关系
类：是一组相关的变量和方法的集合，是一个抽象的概念。
对象：是类实例化创建出来的，是“类”这个概念的具体表现形式
7.类的定义
//学生类，现实世界中“学生”也是一个抽象概念，它是：所有的学生都有的共同点
//在Java中定义类，就是将这些共同点用class类模拟出来
class Student {
//姓名
String name;
//年龄
int age;
//地址
String address;
//所有学生都有“学习”这样的行为，在类中就是定义学习这样的方法
public void study() {
System.out.println("学习");
}
//吃饭的方法
public void eat() {
System.out.println("吃饭");
}
//睡觉的方法
public void sleep() {
System.out.println("睡觉");
}
}
类定义举例：
//手机类
//现实世界中，“手机”是一个抽象概念，
//在Java中模拟手机这个事物的话，就可以定义一个类，这个类拥有手机的属性和行为
class Phone {
//品牌
String brand;
//价格
int price;
//颜色
String color;
//打电话的方法
public void call(String name) {
System.out.println("给"+name+"打电话");
}
//发短信的方法
public void sendMessage() {
System.out.println("发短信");
}
//玩游戏的方法
public void playGame() {
System.out.println("玩游戏");
}
}
8.实例：自定义手机类，并在测试类中测试其中的变量和方法
class Phone {
//品牌
String brand;
//价格
int price;
//颜色
String color;
//打电话的方法
public void call(String name) {
System.out.println("给"+name+"打电话");
}
//发短信的方法
public void sendMessage() {
System.out.println("发短信");
}
//玩游戏的方法
public void playGame() {
System.out.println("玩游戏");
}
}
class PhoneDemo {
public static void main(String[] args) {
//创建手机对象
//类名 对象名 = new 类名();
Phone p = new Phone();
//直接输出成员变量值
System.out.println(p.brand+"---"+p.price+"---"+p.color);
//给成员变量赋值
p.brand = "华为";
p.price = 100;
p.color = "灰色";
//再次输出
System.out.println(p.brand+"---"+p.price+"---"+p.color);
//调用方法
p.call("佟湘玉");
p.sendMessage();
p.playGame();
}
}
9.实例变量和局部变量
定义：
实例变量：属于类的实例对象，没有static修饰的，目前接触到的成员变量都是实例变量
局部变量：属于方法的变量，只在方法内有效
区别：
在类中的位置不同
实例变量 在类中，并且在方法外定义
局部变量 方法内或者方法声明上（形参）定义
在内存中的位置不同
实例变量 堆内存（属于对象）
局部变量 栈内（属于方法）
生命周期不同
实例变量 随着对象的存在而存在，随着对象的消失而消失
局部变量 随着方法的调用而存在，随着方法的调用完毕而消失
初始化值不同
实例变量 有默认的初始化值（0/false/null）
局部变量 没有默认的初始化值，必须先定义，赋值，才能使用。
举例：验证局部变量的作用范围和必须初始化才能使用
10.
/*
局部变量名称可以和成员变量名称一样，在方法中使用的时候，采用的是就近原则。
*/
class Variable {
//成员变量
//int num = 10;
int num; //成员变量有默认值0/false/null
public void show() {
//int num2 = 20; //局部变量
//可能尚未初始化变量num2
//int num2; //没有默认值，只能先赋值，之后才能使用
int num2 = 20;
System.out.println(num2);
//方法内使用的变量采用就近原则：方法内没有，就去找成员变量
System.out.println(num);
}
}
class VariableDemo {
public static void main(String[] args) {
Varialbe v = new Varialbe();
System.out.println(v.num); //访问成员变量
v.show();
}
}
11.形式参数问题
- 基本类型作为形式参数：传值，实际上就是把实参的值拷贝一份给形参，形参不论怎么改动，都不会影响到实参的值
- 引用类型作为形式参数：传递的是实参所指向的实例对象或者数组，即：传递的是实参的引用（地址值），形参和实参具有相同的引用，所以，形参对引用的改动能立即从实参上看到
/*
形式参数的问题：
基本类型：形式参数的改变不影响实际参数
引用类型：形式参数的改变直接影响实际参数
*/
//形式参数是基本类型
class Demo {
public int sum(int a,int b) {
return a + b;
}
}
//形式参数是引用类型
//先自定义一个类，有一个实例方法show
class Student {
public void show() {
System.out.println("学习");
}
}
class StudentDemo {
//如果你看到了一个方法的形式参数是一个类类型(引用类型)，这里需要的是该类的对象。
public void method(Student s) {
//调用的时候，把main方法中的s的地址传递到了这里 Student s = new Student();
s.show();
}
}
class ArgsTest {
public static void main(String[] args) {
//形式参数是基本类型的调用
Demo d = new Demo();
int result = d.sum(10,20);
System.out.println("result:"+result);
System.out.println("--------------");
//形式参数是引用类型的调用
//需求：我要调用StudentDemo类中的method()方法
StudentDemo sd = new StudentDemo();
//创建学生对象
Student s = new Student();
sd.method(s); //把s的地址给到了这里
}
}
12.匿名对象
匿名对象：就是没有名字的对象，是对象的一种简化表示形式
匿名对象的两种使用情况
- 对象调用方法仅仅一次的时候，多次调用的时候，不适合用匿名对象
- 作为实际参数传递可以使用匿名对象
/*
匿名对象：就是没有名字的对象。
匿名对象的应用场景：
A:调用方法，仅仅只调用一次的时候。
注意：调用多次的时候，不适合。
这种匿名调用有什么好处吗?
有，匿名对象调用完毕就是垃圾。可以被垃圾回收器回收。
B:匿名对象可以作为实际参数传递
*/
class Student {
public void show() {
System.out.println("我爱学习");
}
}
class StudentDemo {
public void method(Student s) {
s.show();
}
}
class NoNameDemo {
public static void main(String[] args) {
//带名字的调用
Student s = new Student();
s.show();
s.show();
System.out.println("--------------");
//匿名对象
//new Student();
//匿名对象调用方法
new Student().show();
new Student().show(); //这里其实是重新创建了一个新的对象
System.out.println("--------------");
//匿名对象作为实际参数传递
StudentDemo sd = new StudentDemo();
//Student ss = new Student();
//sd.method(ss); //这里的s是一个实际参数
//匿名对象
sd.method(new Student());
//再来一个，两个都是匿名对象
new StudentDemo().method(new Student());
}
}
13.封装概述
封装概述
封装是面向对象编程的三个重要特征之一，其余两个是多态和继承。
封装指的是隐藏对象的属性和实现细节，不允许外部直接访问对象的内部信息，而是通过该类提供的方法来实现对内部信息的访问。
封装是对现实世界的模拟，在现实世界中，对象的状态信息都被隐藏在对象的内部，外界无法直接操作和访问，例如一个人的年龄，是逐年增长的，假如暴露给外界的话，有可能会被外界修改。
对一个类或者对象的良好封装，可以达到以下的效果：
好处：
- 隐藏实现细节，
- 让使用者只能通过事先预定的方法来访问数据，从而可以在这个方法内加入逻辑控制，限制对成员变量的不合理访问
- 可以进行数据检查，从而有利于保证对象信息的完整性
- 便于修改，提高代码的可维护性
为了实现良好的封装，需要从以下两个方面来考虑
- 把对象的实例变量和实现细节隐藏起来，不允许外界直接访问
- 把方法暴露出来，让方法来控制对这些成员变量进行安全的访问和操作
14.
使用一个关键字private来修饰成员变量，外界就不能对它直接访问了，想要使用它的话，就必须提供公开的方法来对它进行访问，在这个方法中，就可以加入一些逻辑判断了，例如：
/*
定义一个学生类：
成员变量：name，age
成员方法：show()方法
我们在使用这个案例的过程中，发现了一个问题：
通过对象去给成员变量赋值，可以赋值一些非法的数据。
这是不合理的。
应该是这个样子的：在赋值之前，先对数据进行判断。
判断到底在哪里做比较合适呢?
StudentDemo类是一个测试类，测试类一般只创建对象，调用方法。
所以，这个判断应该定义在Student类中。
而我们在成员变量的位置可不可以进行数据判断呢?
是不可以的，因为做数据校验，必须要依靠一些逻辑语句。
逻辑语句是应该定义在方法中的，所以，我们最终决定在Student类中提供一个方法来对数据进行校验。
按照我们前面的分析，我们给出了一个方法进行校验。
但是呢，它偏偏不调用方法来赋值，还是直接赋值了，
这样我们的方法就没有起到作用。
我就应该要求你必须使用我的方法，而不能直接调用成员变量赋值。
怎么去强制要求不能直接使用成员变量呢?
针对这种情况，Java就提供了一个关键字 private
private:私有的。可以修饰成员变量和成员方法。
注意：被private修饰的成员只能在本类中访问。
其实我讲到现在讲解的是一个封装的思想。
封装：是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。
*/
class Student {
//姓名
String name;
//年龄
private int age;
//写一个方法对数据进行校验
/*
返回值类型：void
参数列表：int a
*/
//age变量是私有的变量，在外界不能直接访问，但是类内部的方法却可以访问
//在外界通过访问这个公共方法，间接的访问到了私有的成员变量
//并且在方法内部还可以加入逻辑判断
public void setAge(int a) {
if(a < 0 || age > 150) {
System.out.println("年龄值非法");
}else {
age = a;
}
}
//show()方法,显示所有成员变量值，show()方法是公有的，所以能被外界直接访问
//由于show()方法是在类中定义的，所以本类中的所有变量都是可以被它访问的
//这样达到了间接访问的效果
public void show() {
System.out.println("姓名："+name);
System.out.println("年龄："+age);
}
}
class StudentDemo {
public static void main(String[] args) {
//创建学生对象
Student s = new Student();
s.show();//默认值
System.out.println("--------------");
//给成员变量赋值
s.name = "林青霞";
//s.age = 27;
s.setAge(27);
s.show();
System.out.println("--------------");
//给age赋值
//s.age = -27; //这个数据是不合理的
//通过方法给值
s.setAge(-27);
s.show();
System.out.println("--------------");
}
}
一旦将成员变量定义成private的，就不能直接访问了，比如：
Student s = new Student();
System.out.println(s.age);//error
15.private关键字
private关键字：
- 是一个权限修饰符。
- 可以修饰成员(成员变量和成员方法)
- 被private修饰的成员只能本类中才能访问。
private最常见的应用：
- 把成员变量用private修饰
- 提供对应的getXxx()/setXxx()方法，这样在类的外部就可以通过公有的方法对这些私有变量进行访问了
一个标准的使用案例
class Demo {
//int num = 10;
//用private修饰，只能在类中进行访问
private int num = 10;
public void show() {
System.out.println(num);
}
//私有方法，只能在类中进行调用
private void method() {
System.out.println("method");
}
public void function() {
method();
}
}
class PrivateDemo {
public static void main(String[] args) {
Demo d = new Demo();
//不能访问私有的成员变量
//System.out.println(d.num);
d.show();
//不能访问私有的成员方法
//d.method();
d.function();
}
}