面向对象（一）
回顾
JVM JRE JDK
环境变量配置 JAVA_HOME
HelloWorld小案例
注释、关键字和标识符
数据类型 4类8种
常量
变量
运算符
流程控制：顺序结构、分支结构、循环结构
方法：具有特定功能的代码段 方法的重载
数组：引用数据类型
一、面向对象
1.思想介绍
1.面向对象：编程使用的一种编程思路，编程思想。
2.面向对象和面向过程的比较：都是编程思想，面向对象是基于面向过程的。
面向过程【执行者】：更强调解决问题的基本步骤，更强调问题的解决方式，更强调的是方法。
面向对象【指挥者】：更强调解决问题的主体，更强调谁来解决这个问题，更强调的是数据，更强调的是对象，更强调的谁拥数据和操作数据的权力。
剪头发：
面向过程：准备剪刀、准备镜子、包裹一层布、动手开始剪
面向对象：找理发师、理发师剪头发
洗衣服：
面向过程：准备盆子、放洗衣粉、放衣服、搓一搓、揉一揉、涮一涮、晾出来
面向对象：找一个洗衣机、按扭启动
3.面向对象好处：
更符合人类的思考习惯，凡事喜欢找对象，找工具，找人，而不是去找方法。
复杂问题简单化。
由执行者变成了指挥者。
4.面向对象的特征
封装、继承、多态
2.类和对象
1.类：类型，对具体事物的一个抽象认识，是抽象出来的结果，其实就是一个概念。
2.抽象：抽取事物中，像的相同的相似的内容出来，在人脑中形成一个概念。
3.对象：事物的具体体现。
4.类和对象的关系：汽车图纸–一辆辆汽车 模型—飞机
类的说明：
类就是一组相关属性和行为定义的集合。
属性：对于事物的特征的描述，一般是名词或者形容词
Java语言中，就是一个成员变量，和以前定义的方式一样，只不过位置发生改变。
局部变量：定义在方法中。
成员变量：定义在类中方法外。
行为：对于事物功能的描述，一般都是一个动词。
Java语言中，就是一个成员方法，和以前定义的方法格式基本一致，只不过修饰符发生变化。
以前修饰符：public static,现在将static去掉。
举列：狗
属性：毛、眼睛、姓名、年龄
行为：吃、叫、看家护院
举例：人
属性：姓名、年龄、性别、身高、体重…
行为：学习、睡觉、工作…
说明：
在一个源文件中，可以定义多个类，一旦编译该文件，就会将所有的类型进行编译，生成多个字节码文件。
自定义类编译后，也会生成一个.class字节码文件
对象的创建和使用：
对象的创建格式：
类名 对象名 = new 类名();
格式解释：
类名：要创建的对象所属的类型，例如：Person Scanner
对象名：标识符
=：将对象的地址，赋值给对象名
new:在堆内存中开一段空间，用于存储该类型的数据
类名:和前面的声明保持一致
():表示调用一个方法，构造方法。
访问属性
对象名.属性名 = 属性值;(修改)
对象名.属性;(访问)
访问方法
对象名.方法名();
public class Demo02 {
public static void main(String[] args) {
Car c1 = new Car();
c1.brand = "BMW";
c1.color = "黑色";
c1.num = 4;
c1.run();
c1.stop();
Car c2 = new Car();
c2.brand = "永久牌";
c2.color = "black";
c2.num = 2;
c2.run();
c2.stop();
Car c3 = new Car();
c3.brand = "爱玛";
c3.color = "pink";
c3.num = 3;
c3.run();
c3.stop();
}
}
class Car{
String brand;
String color;
int num;
public void stop() {
System.out.println(brand+"..."+color+"..."+num+"...正在紧急地刹车");
}
}
3.练习
定义一个汽车类，有颜色、品牌、轮胎个数跑、刹车
在测试类中、创建汽车对象、修改成员变量的值、调用行为方法。
public class Demo02 {
public static void main(String[] args) {
Car c1 = new Car();
c1.brand = "BMW";
c1.color = "黑色";
c1.num = 4;
c1.run();
c1.stop();
Car c2 = new Car();
c2.brand = "永久牌";
c2.color = "black";
c2.num = 2;
c2.run();
c2.stop();
Car c3 = new Car();
c3.brand = "爱玛";
c3.color = "pink";
c3.num = 3;
c3.run();
c3.stop();
}
}
class Car{
String brand;
String color;
int num;
里面
public void stop() {
System.out.println(brand+"..."+color+"..."+num+"...正在紧急地刹车");
}
}
4.创建对象的内存理解
创建对象的步骤：
1.将要创建对象所属的类型加载到方法区，形成Car.class
2.在栈内存中创建一个Car类型的引用，将来用于存储堆内存中的地址
3.在堆内存中，给各个成员变量分配内存空间
4.给对象的成员变量进行默认的初始化赋值
5.将对象的地址，赋值给栈内存中的引用
内存图示说明：
1.第一次使用某个类型的时候，会将该类的字节码加载到方法区，第二次使用的时候，不需要重复加载。
2.在创建对象中，默认隐含一个字节码文件的地址，将来可通过对象找到创建自己的字节码
3.哪个对象调用方法，方法的栈帧中，就默认隐含了该对象的地址
4.每次使用new关键字，都会堆内存中开辟一块新的空间
5.成员变量和局部变量的比较(面试题)
1.成员变量：定义在类中的成员位置的变量，就是成员变量;局部变量：定义在方法中的变量，就是局部变量。
2.不同点：
代码层面：定义位置不同
局部变量：定义在方法中，或者方法声明的参数
成员变量：定义在类中方法外
内存层面：空间不同
局部变量：属于方法，和方法的位置相同，在栈内存中。
成员变量：属于对象，和对象的位置相同，在堆内存中。
内存层面：生命周期不同
局部变量：随着方法的调用而存在，随着方法的结束而消失
成员变量：随着对象的创建而存在，随着对象的消失而消失(栈内存没有任何引用指向该对象，会变成垃圾对象，会被GC进行自动回收)
初始化状态不同：
局部变量：没有默认的初始化，必须先手动赋值，才能使用
成员变量：有默认的初始化值
引用数据类型：null
基本数据类型：int–0 double–0.0 boolean–false
/*
* 成员变量和局部变量的区别
* */
public class Demo03 {
public static void main(String[] args) {
// TODO Auto-generated method stub
}
}
class Demo{
//成员变量
String name;
//局部变量
public void method(int i) {
int j = 20;
}
}
6.方法的形参和返回值是引用数据类型
1.方法的形式参数是引用数据类型
方法的形式参数，既可以是基本数据类型，也可以是引用数据类型
引用数据类型：数组、类、接口、枚举…
当方法的形参是引用数据类型时，其实在调用的时候，需要传递一个对象的内存地址，在方法的内部 可以通这个内存地址，访问方法外创建的对象。
在多个方法中，有不同的引用，记录着相同的对象的内存地址，多个引用指向同一个对象。
/*
* 形参是引用数据类型
* */
public class Demo04 {
public static void main(String[] args) {
Phone p = new Phone();
p.brand = "apple";
p.price = 2000;
usePhone(p);
updatePhone(p);
usePhone(p);
}
public static void usePhone(Phone p) {
p.show();
}
public static void updatePhone(Phone p) {
p.brand = "华为";
p.price = 3000;
}
}
class Phone{
String brand;
int price;
public void show() {
System.out.println(brand+"..."+price+"...非常好用！");
}
}
2.方法的返回值类型是引用数据类型
方法的返回值类型，既可以是基本数据类型，也可以是引用数据类型
如果方法的返回值类型是引用数据类型，那么return语句中，一定返回该类型的一个对象。
/*
* 方法的返回值类型是引用数据类型
* */
public class Demo05 {
public static void main(String[] args) {
Mobile m = makePhone();
m.show();
int sum = getSum(5,6);
}
public static Mobile makePhone() {
Mobile m = new Mobile();
m.brand = "华为";
m.price = 4000;
return m;
}
public static int getSum(int x,int y) {
return x+y;
}
}
class Mobile{
String brand;
int price;
public void show() {
System.out.println(brand+"..."+price+"...非常好用！");
}
}
7.匿名对象
1.匿名对象：没有名字的对象。
2.定义格式： new 类名();
3.应用场景
1.如果某个对象在创建之后，其方法只调用一次，那么就可以使用匿名对象来调用，这种写法会节省一些内存空间，可以及时回收。
2.可以作为某个方法的实际参数传递。
3.可以作为某个方法的返回值。
4.注意事项
匿名对象可以给成员变量赋值，但是这个没有任何意义。因为匿名对象一旦被赋值，匿名对象就变成了垃圾对象，很快就会被回收掉，即使没有回收，我们也无法找到该对象。
/*
* 匿名对象
* */
public class Demo06 {
public static void main(String[] args) {
//new Dog().kanMen();
//new Dog().kanMen();
/*Dog d = new Dog();
useDog(d);*/
//useDog(new Dog());
//Dog d = returnDog();
new Dog().name = "旺财";
}
public static void useDog(Dog d) {//Dog d = new Dog();
d.kanMen();
}
public static Dog returnDog() {
return new Dog();
}
}
class Dog{
String name;
public void kanMen() {
System.out.println("正在看门...");
}
}
二、封装
1.封装的概述
1.封装：隐藏事物的属性和实现细节，对外提供公共的访问方式。
2.封装的好处：
提高了安全性
隐藏了事物的实现细节
提高了代码的复用性
3.封装的原则
隐藏事物的属性
隐藏事物的实现细节
对外提供公共的访问方式
2.private关键字
1.private:关键字、私有的、私密的
2.可以修饰的内容
修饰成员变量
修饰成员方法
修饰构造方法
修饰内部类
3.修饰之后的效果
被修饰的成员，只能在本类中被访问，在其它类中不能被访问。
4.private只是封装的其中的一个体现形式，封闭还可以使用其它的方式来完成。
/*
* private
* */
public class Demo01 {
public static void main(String[] args) {
Person p = new Person();
p.age = 20;
}
}
class Person{
private String name;
int age;
public void eat() {
System.out.println(name+"正在吃饭");
}
}
3.Getter和Setter
1.当属性被私有化之后，外界无法直接访问，所以需要公共的访问方式，让外界可以间接的访问属性，对于当前类，就可以控制外界访访问属性的方式。（让你怎么访问，你就怎么访问）。
2.一般提供get,set方法。get获取属性值，set设置属性值。
3.setXxx getXxx setName() getName()
```java
```javascript
```java
/*
* setter getter
* */
public class Demo02 {
public static void main(String[] args) {
Person p = new Person();
p.setName("张三");
System.out.println(p.getName());
}
}
class Person{
private String name;
private int age;
public void setName(String str) {
name = str;
}
public String getName() {
return name;
}
}
4.变量的访问原则和this关键字
1.变量访问的就近原则：
当在访问某个变量名称的时候，会先寻找最近的访变量名的定义，如果寻找到了，就使用该变量，如果没有找到，才会从更远的地方去寻找。
当局部变量和成员变量同名的时候，一定是先使用局部位置定义的变量，如果没有，才会使用成员位置定义的变量。
2.this关键字
表示当前类型当前对象的引用
哪个来调用this所在的方法，this就代表哪个对象
作用：用于区分成员变量和局部变量。使用this.属性名的一定是成员变量，没有使用this的时候，根据就近原则。
/*
* this关键字 变量的访问原则
* */
public class Demo03 {
public static void main(String[] args) {
Person p = new Person();
p.setName("张三");
System.out.println(p.getName());
Person p1 = new Person();
p1.setName("李四");
System.out.println(p1.getName());
}
}
class Person{
private String name;
private int age;
//alt+shift+s-->generate getters and setters
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;
}
}
/*
* this关键字
* */
public class Demo04 {
public static void main(String[] args) {
Demo d = new Demo();
d.method();
Demo d1 = new Demo();
d1.method();
}
}
class Demo{
int i = 5;
public void method() {
int i = 10;
System.out.println(i+"..."+this.i);
}
}
三、总结
面向对象：
面向对象【指挥者】和面向过程【执行者】
类和对象
类—抽象的认知 对象—具体的事物
类和对象的关系：模型和具体事物
创建对象
类名 对象名 = new 类名();
对象在内存的理解*****
对象的创建步骤、内存说明
引用数据作为方法的参数和返回值：本质传递的地址
匿名对象：节省内存，容易被回收
封装：
概念 好处
private关键字
Getter和Setter
变量的就近原则
this:代表当前对象，谁调用谁就是当前对象。
四、作业
1、什么是面向对象？
1）是一种编程思想
2）和面向过程的区别
3）面向对象的好处
4）面向对象的特征
5）举例子
2、面向对象的三大思想特征是什么？
3、什么是类，什么是对象？
4、如何使用类中的成员变量和成员方法？
5、成员变量和局部变量的区别有哪些？
6、什么是匿名对象？什么时候使用？
7、什么是封装？封装的好处、原则分别是什么？
8、this的作用是什么？
9、根据如下需求，完成代码(按照标准格式写：属性私有，提供get、Set方法)，然后在测试类中测试。
需求一：
手机类Phone
属性:品牌brand,价格price
行为:打电话call,发短信sendMessage,玩游戏,playGame
需求二：
人类Person
属性:姓名name,年龄age,性别gender
行为:学习study,睡觉sleep
需求三：
动物类Animal
属性:姓名name,年龄age
行为:吃饭eat
需求四：
狗类Dog
属性:姓名name,年龄age
行为:吃饭eat，看家lookHome
需求五：
猫类Cat
属性:姓名name,年龄age
行为:吃饭eat，抓老鼠catchMouse
需求六：
学生类Student
属性:语文成绩chinese，数学成绩math，英语成绩english
行为:求总成绩的方法getSum()
需求七：
长方形类
属性：
行为：求取长方形的周长和面积55