Day 13 面向对象
1. 构造方法
1.1 作用
用于在后期开发中创建对象使用，初始化当前创建对象中的成员变量的数据
创建对象的格式：
new 类名(有可能使用的参数);
类名(有可能使用的参数); 这就是构造方法 Constructor
1.2 格式
格式：
public 类名(所需初始化参数列表) {
初始化语句;
}
注意：
1. 构造方法的方法名必须是类名，在创建类里的其他方法的方法名不能是类名
2. 构造方法没有返回值类型声明
3. 所需初始化参数列表和正常的方法的参数列表操作使用一致
4. 初始化语句大多是一些赋值语句
1.3 根据需求完成所需构造方法
需求：
1. 完成一个对于姓名在所创建对象初始化的构造方法
2. 完成一个对于姓名、年龄在所创建对象初始化的构造方法
3. 完成一个对于姓名、年龄、性别在所创建对象初始化的构造方法
特别注意：【强制要求】
在代码构造方法中，【无论如何要给用户一个无参数构造方法使用】
this关键字：
this表示对象本身！当前对象！
1. 调用当前方法的类对象
2. 可以在方法中使用this关键字区分操作的是成员变量还是局部变量
// 完成一个对于姓名在所创建对象初始化的构造方法
class Dog {
// 成员变量Field
String name;
// 无参数构造方法
public Dog() {}
/*
* this 表示通过 new + 构造方法 创建的类对象本身
* this.name 中的name是Dog类下的成员变量，不是构造方法中的形参public Dog(String name)
*/
public Dog(String name) {
this.name = name;
}
}
// 完成一个对于姓名、年龄在所创建对象初始化的构造方法
class Dog {
// 成员变量Field
String name;
int age;
// 无参数构造方法
public Dog() {}
/*
* this 表示通过 new + 构造方法 创建的类对象本身
* this.name 中的name是Dog类下的成员变量，不是构造方法中的形参public Dog(String name)
*/
public Dog(String name, int age) {
this.name = name;
this.age = age;
}
}
// 完成一个对于姓名、年龄、性别在所创建对象初始化的构造方法
class Dog {
// 成员变量Field
String name;
int age;
char gender;
// 无参数构造方法
public Dog() {}
/*
* this 表示通过 new + 构造方法 创建的类对象本身
* this.name 中的name是Dog类下的成员变量，不是构造方法中的形参public Dog(String name)
*/
public Dog(String name, int age, char gender) {
this.name = name;
this.age = age;
this.gender = gender;
}
}class Dog {
// 成员变量Field
String name;
int age;
char gender;
// 无参数构造方法
public Dog() {}
/*
* this 表示通过 new + 构造方法 创建的类对象本身
* this.name 中的name是Dog类下的成员变量，不是构造方法中的形参public Dog(String name)
*/
public Dog(String name) {
this.name = name;
}
public Dog(String name, int age) {
this.name = name;
this.age = age;
}
public Dog(String name, int age, char gender) {
this.name = name;
this.age = age;
this.gender = gender;
}
// 成员方法
public void eat() {
System.out.println("吃狗粮");
}
public void sleep() {
System.out.println("作息规律");
}
public void game() {
System.out.println("玩球");
}
}
public class Demo1 {
public static void main(String[] args) {
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 dog1 = new Dog("骚凯");
System.out.println("Name: " + dog1.name);
System.out.println("Age: " + dog1.age);
System.out.println("Gender: " + dog1.gender);
System.out.println("---------------------------");
Dog dog2 = new Dog("骚凯", 4);
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("骚凯", 4, '男');
System.out.println("Name: " + dog3.name);
System.out.println("Age: " + dog3.age);
System.out.println("Gender: " + dog3.gender);
System.out.println("---------------------------");
dog.eat();
dog1.sleep();
dog2.game();
}
}1.4 总结
1. 构造方法
用于初始化创建对象的成员变量的数据
构造方法也是一个方法，参数操作使用和方法一致
2. 构造方法选择
Java编译器会自动根据构造方法中的【参数类型, 个数, 顺序】来做选择，如果没有指定的构造方法，报错！！！
3. 【无论如何要给用户一个无参数构造方法使用】
// 无参数构造方法
public Dog() {}
4. 以下代码报错
public Dog(String name) {
this.name = name;
}
public Dog(String color) {
this.color = color;
}
调用：
Dog dog = new Dog("白色");
在Java中不允许出现相同数据类型、个数、顺序的构造方法，和参数名没有关系，Java编译器在选择过程中，有且只针对数据类型、个数、顺序选择，参数名真的无所谓
2. 类对象内存分析图
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-QiLdk6B6-1591111490903)(Day 13 面向对象.assets/类对象空间内存分析.png)]
3. 封装【重点】
3.1 面向对象的三大特征
封装
基本思想
继承
子承父业
多态
3.2 封装
归纳总结
循环封装过程
方法封装功能
类封装数据
框架封装模块
3.3 Java中规范化封装【JavaBean规范】
要求：
1. 所有的成员变量全部私有化【private 修饰】
2. 要求至少有一个无参数构造方法
3. 要求给予所有的成员变量对应的setter和getter方法
3.3.1 权限修饰符
private
私有化内容，使用private修饰的成员变量、方法和构造方法，只能在类中使用，类外没有操作权限
使用private修饰的内容只能在class大括号以内使用
public
公开内容，只要存在对应的类对象，都可以使用对象调用类中的public修饰的成员变量、方法
3.3.2 解决私有化成员变量赋值和取值问题
private私有化修饰的成员变量，类外不能通过类对象进行操作
JavaBean规范
setter 赋值操作
格式：
public void set成员变量名(对应成员变量名数据类型) {
赋值操作；
}
getter 取值操作
格式：
public 对应成员变量数据类型返回值 get成员变量名() {
return 成员变量;
}
注意：
1. 方法格式固定，setter和getter操作过程无法更改
2. 方法要符合命名规范，小驼峰命名法
3. boolean类型数据比较特殊： getter方法要求为is开头
public boolean is成员变量名() {
return 成员变量;
}
3.3.3 在Eclipse中可以使用快捷键快速完成代码
/*
* 以后的开发中一个【实体类】如何封装如何书写
* 实体类：
* 真实存在的一个数据，人，狗，英雄
*/
class LOLHero {
private String name;
private float hp;
private float mp;
private boolean gender;
/*
* 根据个人需求完成对应构造方法，setter和getter方法
* shift + alt + s 快捷键使用
*/
// 无参构造方法Constructor
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;
}
// boolean类型的成员变量的getter方法是is开头
public boolean isGender() {
return gender;
}
public void setGender(boolean gender) {
this.gender = gender;
}
}3.3.4 关于JavaBean规范的总结
1. 要求Java中的所有实体类成员变量全部私有化，最少提供一个无参数构造方法，对应成员变量实现setter和getter方法
2. JavaBean规范，是为了后期开发汇总更好的代码适配度，提高代码运行的统一性，能够满足框架的使用
3. JavaBean规范只是一个规范，而且是作为一个基础规范，操作都是可以使用快捷键来完成的
4. 多类合作
汽车
可以看做是一个类
成员变量:
名字
颜色
轮胎个数
成员方法:
飙车
飙车有要求，轮胎个数必须是4个
修理厂
可以看做是一个类
成员变量:
名字
地址
联系方式
成员方法:
修理汽车的方法【重点】
该方法是需要一个汽车类的对象
4.1 汽车代码实现
public class Car {
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;
}
/*
* 飙车方法
*/
// 成员方法
public void race() {
if (4 == wheelCount) {
System.out.println("开着" + color + "的" + name + "开着320KM/H在秋名山飙车");
} else {
System.out.println("轮胎GG思密达，快去修理厂~~~");
}
}
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;
}
}4.2 修理厂代码实现
public class Factory {
private String name;
private String address;
private String tel;
public Factory() {}
public Factory(String name, String address, String tel) {
this.name = name;
this.address = address;
this.tel = tel;
}
/**
* 修理汽车的方法，这里需要的参数是一个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("10WRMB");
} else {
System.out.println("你脑子瓦特了~~~");
}
}
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;
}
}
4.3 主方法
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.setName("高价汽修");
factory.setAddress("秋名山下秋名路");
factory.setTel("随便打大声喊出“秋名山车神”就可以了");
/*
* 这里通过Factory类对象调用repair方法，修理Car类的对象
* 方法参数是Car类的对象
*/
factory.repair(car);
for (int i = 0; i < 10; i++) {
car.race();
Thread.sleep(500);
}
}
}
扫一扫
269
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
