面向对象2.0
【要点】
public 修饰的类要和文件名一致
封装的意义
构造方法创建
this关键字
JavaBean规范
类之间合作
1. 构造方法【鸡肋】
1.1 作用
用于在开发过程中创建对象使用，创建对象目前的格式
new 类名(有可能使用到的参数);
类名(有可能使用到的参数); 这就是构造方法 Constructor
构造防范可以初始化当前创建对象中的成员变量数据！！！
1.2 格式
格式:
public 类名(所需初始化参数列表) {
初始化语句;
}
细节:
1. 构造方法的名字必须是类名，并且其他方法的名字不能是类名
2. 构造方法没有返回值类型声明
3. 初始化参数列表和正常的方法列表操作使用一致
4. 初始化语句，大多数是都是一些赋值语句
1.3 貌似我们昨天没有写构造方法，但是我们用了[了解]
首先
在Eclipse项目所在文件夹中，bin目录是存放当前Java程序对应的所有的.class 二进制文件(字节码文件)，该文件保存了Java文件对应的所有内容
这里可以通过反编译工具看到一些特定的现象 [了解]
javap -c -l -private XXX.class
Java编译器行为
在代码中任何没有【显式】自行声明构造方法，Java编译器会在编译代码的过程中辅助程序员完成一个【无参数的构造方法】，供程序员使用
1.4 根据需求完成所需构造方法
格式:
public 类名(所需初始化参数列表) {
初始化语句;
}
需求:
1. 完成对于姓名在创建对像时初始化的构造方法
2. 完成对于姓名，年龄创建对象时初始化的构造方法
2. 完成对于姓名，年龄，性别创建对象时初始化的构造方法
注意:
如果在代码中程序员自行完成了构造方法，Java编译器不再提供自动生成的无参数构造方法。
【强制要求】
以后代码中无论什么时候都要给用户提供一个无参数构造方法使用
package com.qfedu.a.constructor;
class Dog {
// 成员变量 Field
String name;
int age;
char gender;
// 无参数构造方法
public Dog() {}
// 完成对于姓名在创建对像时初始化的构造方法
public Dog(String n) {
// 成员变量可以在类内其他中直接使用【80%正确】
name = n;
}
// 完成对于姓名，年龄创建对象时初始化的构造方法
public Dog(String n, int a) {
name = n;
age = a;
}
// 完成对于姓名，年龄，性别创建对象时初始化的构造方法
public Dog(String n, int a, char g) {
name = n;
age = a;
gender = g;
}
// 成员方法 Method
public void eat() {
System.out.println("狗狗吃狗粮");
}
public void game() {
System.out.println("狗狗玩球");
}
public void sleep() {
System.out.println("狗狗作息非常规律");
}
}
public class Demo1 {
public static void main(String[] args) {
/*
* 这里调用的是一个无参数构造构造方法
* 但是该方法在Dog类内是没有定义的！！！
*
* 以后使用比较多的情况大多数都是无参数构造方法
*
* The constructor Dog() is undefined
* 构造方法Dog()未定义
*/
// 无参数构造方法
Dog dog = new Dog();
System.out.println("Name:" + dog.name);
System.out.println("Age:" + dog.age);
System.out.println("Gender:" + dog.gender);
System.out.println("-------------------------------");
Dog dog2 = new Dog("骚杰");
System.out.println("Name:" + dog2.name);
System.out.println("Age:" + dog2.age);
System.out.println("Gender:" + dog2.gender);
System.out.println("-------------------------------");
Dog dog3 = new Dog("骚杰", 66);
System.out.println("Name:" + dog3.name);
System.out.println("Age:" + dog3.age);
System.out.println("Gender:" + dog3.gender);
System.out.println("-------------------------------");
Dog dog4 = new Dog("测试", 66 , '男');
System.out.println("Name:" + dog4.name);
System.out.println("Age:" + dog4.age);
System.out.println("Gender:" + dog4.gender);
System.out.println("-------------------------------");
}
}
1.5 总结
1. 构造方法
功能是用于初始化创建对象的成员变量数据
构造方法是一个方法，参数使用方式和方法一致
2. 构造方法选择
Java编译器会根据构造方法中的【参数类型，个数，顺序】来做选择，如果没有指定的构造方法，报错！！！
3. 无论什么时候一定要给当前类提供一个无参数构造方法。
4. 【以下代码报错】
Dog(String name);
Dog(String color);
调用:
String color = "red";
Dog dog = new Dog(color);
在Java代码中不允许出现相同数据类型，个数，顺序的构造方法，和参数名没有关系，Java编译器选择过程中，有且只针对数据类型，个数，顺序选择，参数名真的无所谓。
2. 类对象内存分析图【重点】
3. this关键字【鸡肋】
3.1 this关键字【重点】
this关键字表示对象本身
1. 调用当前方法的类对象
2. 通过构造方法创建的类对象
this表示一个对象！！！当前对象！！！
3.2 目前this关键字解决的问题
可以在方法中使用this关键字区分操作的是成员变量还是局部变量
this指向的变量未成员变量
package com.qfedu.b_this;
class Person {
String name;
int age;
public Person() {
// this关键字表示通过new + 构造方法创建的类对象本身
System.out.println("Constructor: " + this);
}
public Person(String name) {
/*
* 以下操作是没有用的，这是自娱自乐！！！
* 这里存在一个【就近原则】问题，如果出现和成员变量
* 同名的局部变量，采用就近原则
*/
// name = name;
/*
* 这里需要赋值操作的是当前类对象中的name成员变量
* this.成员变量名字 表示使用的就是当前类对象的成员变量，而不是方法的参数
*/
this.name = name;
}
public Person(String name, int age) {
/*
* 使用this关键字区分成员变量和局部变量
*/
this.name = name;
this.age = age;
}
public void test() {
// 表示调用当前方法的类对象
System.out.println("test: " + this);
}
}
public class Demo1 {
public static void main(String[] args) {
Person person = new Person();
System.out.println("main: " + person);
person.test();
}
}
4. 封装【重点，规范】
4.1 面向对象三大特征
封装
最基本的思想
继承
子承父业，你长得真的像你父母
多态
猫，狗，都是动物
U盘，键盘，鼠标，都是USB设备
【最难的是多态，最简单的也是多态】
4.2 封装，不单单是对于类的封装
封装：
归纳总结
提高重用度
降低使用难度，使用更方便
循环封装过程
方法封装功能
类封装数据
框架封装模块
一段代码使用了三遍，做成一个循环
一个循环使用了三遍，做成一个方法
一个方法使用了三遍，做成一个工具类
一个工具类使用了三遍，做成一个文档
一个文档使用了三遍，做成一篇博客
4.3 Java中规范化封装【JavaBean规范】
要求:
1. 所有的成员变量全部私有化【private修饰】
2. 要求至少完成一个无参数构造方法，其他无所谓
3. 要求给予所有的成员变量对应的setter和getter方法
4.3.1 权限修饰符
private
私有化内容，使用private修饰的成员变量，成员方法和构造方法，有且只能类内使用，类外没有操作权限。
使用private修饰的内容有且只能在class所处大括号以内使用
public
公开内容，只要存在对应的类对象，都可以通过类对象调用类内的public修饰的成员变量和成员方法
4.3.2 解决私有化成员变量赋值和取值操作问题
private私有化修饰的成员变量，类外不能通过类对象操作，取值，赋值。
JavaBean规范规定了
setter ==> 赋值操作
格式:
public void set成员变量名(对应成员变量数据类型参数) {
赋值操作;
}
getter ==> 取值操作
public 对应成员变量数据类型返回值 get成员变量名字() {
return 成员变量;
}
注意
1. 方法格式固定，setter和getter方法操作过程不能修改
2. 方法需要符合命名规范，小驼峰命名法
3. boolean类型数据较特殊
boolean类型的成员变量getter方法要求是is开头
4.3.3 可以使用快捷方式快速完成代码
package com.qfedu.c;
/*
* 以后开发中一个【实体类】如何封装如何书写
* 实体类：
* 真实存在的一个数据，人，狗，英雄
*/
class LOLHero {
private String name;
private float hp;
private float mp;
// 根据个人需求完成对应构造方法，setter和getter方法
// Shift + Alt + S
public LOLHero() {}
public LOLHero(String name, float hp, float mp) {
this.name = name;
this.hp = hp;
this.mp = mp;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public float getHp() {
return hp;
}
public void setHp(float hp) {
this.hp = hp;
}
public float getMp() {
return mp;
}
public void setMp(float mp) {
this.mp = mp;
}
}
4.3.4 关于JavaBean规范的总结
JavaBean规范制定的要求
1. 要求Java中的所有实体类成员变量全部私有化，最少提供一个无参数构造方法，对应成员变量实现setter和getter方法
2. JavaBean规范，是为了后期开发汇总更好的代码适配度，提高代码运行的统一性，能够满足框架的使用
3. JavaBean规范只是一个规范，而且是作为一个基础规范，操作都是可以使用快捷键来完成的！！！
5. 多类合作【重点】
5.1 汽车类和修理厂类分析
汽车
可以看做是一个类
成员变量:
名字
颜色
轮胎个数
成员方法:
飙车
飙车有要求，轮胎个数必须是4个
修理厂
可以看做是一个类
成员变量:
名字
地址
联系方式
成员方法:
修理汽车的方法【重点】
该方法是需要一个汽车类的对象
5.2 汽车类代码实现
package com.qfedu.d;
/*
汽车
可以看做是一个类
成员变量:
名字
颜色
轮胎个数
成员方法:
飙车
飙车有要求，轮胎个数必须是4个
*/
public class Car {
// 成员变量 Field
private String name;
private String color;
private int wheelCount;
// 构造方法 Constructor
public Car() {}
public Car(String name, String color, int wheelCount) {
this.name = name;
this.color = color;
this.wheelCount = wheelCount;
}
/**
* 飙车方法, 如果轮胎个数不为4，提示需要找修理厂
*/
public void race() {
if (4 == wheelCount) {
System.out.println("开着" + color + "的" + name + "在秋名山320KM/H飙车");
} else {
System.out.println("轮胎GG思密达，快去修理厂~~~~");
}
}
// setter 和 getter 方法 Method
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
public int getWheelCount() {
return wheelCount;
}
public void setWheelCount(int wheelCount) {
this.wheelCount = wheelCount;
}
}
5.3 修理厂类代码实现
package com.qfedu.d;
/*
修理厂
可以看做是一个类
成员变量:
名字
地址
联系方式
成员方法:
修理汽车的方法【重点】
该方法是需要一个汽车类的对象
*/
public class Factory {
// 成员变量 Field
private String name;
private String address;
private String tel;
// 构造方法 Constructor
public Factory() {}
public Factory(String name, String address, String tel) {
this.name = name;
this.address = address;
this.tel = tel;
}
/*
* 修理汽车的方法分析
* 权限修饰符
* public
* 返回值类型
* void
* 方法名
* repair
* 形式参数列表【重点】
* 1. 这里需要一个汽车作为参数
* 2. 而且是必要参数
* 3. 这里需要的是一个汽车类的对象
* (Car car) 这里是一个汽车类对象
* 方法声明:
* public void repair(Car car);
*/
/**
* 修理汽车的方法，这里需要的参数是一个汽车Car类的对象
*
* @param car Car汽车类对象
* @throws InterruptedException
*/
public void repair(Car car) throws InterruptedException {
// 修理轮胎 通过car类对象获取对应的轮胎个数
if (car.getWheelCount() < 4) {
System.out.println("轮胎有问题，需要修理");
// 修改当前汽车对象的轮胎个数，赋值为4
car.setWheelCount(4);
// 报错，Ctrl + 1 选择第一个回车
Thread.sleep(1000);
System.out.println("10W块RMB");
} else {
System.out.println("你脑子瓦特了~~~~");
}
}
// setter和getter方法 Method
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
public String getTel() {
return tel;
}
public void setTel(String tel) {
this.tel = tel;
}
}
5.4 主方法
package com.qfedu.d;
public class Demo {
public static void main(String[] args) throws InterruptedException {
/*
* 同package内可以直接使用对应的Class 类
*/
Car car = new Car("领克03+", "黑色", 4);
for (int i = 0; i < 10; i++) {
car.race();
/*
* 让程序暂停0.5S，存在一个红色的报错，这里Ctrl + 1
* 快速修复，选择第一个，不要问为什么
*/
Thread.sleep(500);
}
Thread.sleep(1000);
System.out.println("轮胎boom~~~~~");
// 轮胎爆炸一个
car.setWheelCount(3);
Thread.sleep(1000);
car.race();
// 现在需要一个修理厂对象
Factory factory = new Factory();
factory.setAddress("海航中路60号");
factory.setName("骚磊汽修");
factory.setTel("138后面随便");
/*
* 这里需要通过Factory类对象，调用repair方法，修理汽车Car类的对象
* 方法参数是一个Car类的对象
*/
factory.repair(car);
for (int i = 0; i < 10; i++) {
car.race();
/*
* 让程序暂停0.5S，存在一个红色的报错，这里Ctrl + 1
* 快速修复，选择第一个，不要问为什么
*/
Thread.sleep(500);
}
}
}