1. 构造方法【鸡肋】
1.1 作用
用于在开发过程中创建对象使用，创建对象目前的格式
new 类名(可能用到的参数);
类名(有可能用到的参数)；这就是构造方法 Constructor
初始化当前创建对象中的成员变量数据！！
1.2 格式
格式：
public 类名（所需初始化参数列表） {
初始化语句；
}
细节：
1.构造方法的名字必须是类名，并且其他方法的名字不能是类名
2.构造方法没有返回值类型声明
3.初始化参数列表和正常的方法列表操作使用一致
4.初始化语句，大多数是一些赋值语句
1.3 貌似我们昨天没有写构造方法，但我们用了【了解】
首先
在Eclipse的项目所在文件夹中，bin目录是存放当前java程序对应的所有.class 二进制文件（字节码文件），赶文件保存了java文件对应的所有内容
这里可以通过返编译工具看到一些特定的现象【了解】
Java -c -1 -private XXX.class
Java编译器行为
在代码中任何没有【显式】自行声明构造方法，java编译器会在编译代码的过程中辅助程序程序员完成一个无参数的构造方法，供程序员使用
1.4 根据需求完成所需构造方法
格式：
public 类名（所需初始化参数列表）{
初始化语句；
}
需求：
1.完成对于姓名在创建对象时初始化的构造方法
2.完成对于姓名，年龄创建对象时初始化的构造方法
3.完成对于姓名，年龄，性别创建对象时初始化的构造方法
注意：
如果在代码中程序员自行完成了构造方法，java编译器不再自动生成无参构造方法。
【强制要求】
以后代码无论在什么时候都要给用户提供一个无参数构造方法使用
package com.qianfeng.a.Object;
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;
}
//成员方法
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类内是没有定义的
*
* 以后用的比较多的情况大多数都是无参构造方法
*
* The constructor Dog() is undefind
*/
//无参构造方法
Dog dog = new Dog();
System.out.println(dog.name);
System.out.println(dog.age);
System.out.println(dog.gender);
System.out.println("------------------");
Dog dog1 = new Dog("聂亮");
System.out.println(dog1.name);
System.out.println(dog1.age);
System.out.println(dog1.gender);
System.out.println("------------------");
Dog dog2 = new Dog("聂亮", 22);
System.out.println(dog2.name);
System.out.println(dog2.age);
System.out.println(dog2.gender);
System.out.println("------------------");
Dog dog3 = new Dog("聂亮", 22, '男');
System.out.println(dog3.name);
System.out.println(dog3.age);
System.out.println(dog3.gender);
}
}
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.1 目前this关键字解决的问题
可以在方法中使用this关键字区分操作的是成员变量还是局部变量
package com.qianfeng.a.constructor;
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.name = name;
this.age = age;
}
public void test() {
//表示调用当前方法的类对象
System.out.println("test:" + this);
}
}
public class Demo3 {
public static void main(String[] args) {
Person person = new Person();
System.out.println("main:" + person);
person.test();
// PFSP private final static Person
}
}
4. 封装【重点，规范】
4.1 面向对象三大特征
封装
最基本的思想
继承
子承父业
多态
猫，狗，都是动物
U盘，键盘，鼠标，都是USb设备
【最难的是多态，最简单的也是多态】
4.2 封装，不单单是对于类的封装
归纳总结！！！
循环封装过程
方法封装过程
类封装数据
框架封装模块
一段代码使用了3遍，做成一个循环
一个循环使用了3遍，做成一个方法
一个方法使用了3遍，做成一个工具类
一个工具类使用了3遍，做成一个文档
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.qianfeng.a.constructor;
/*
* 以后开发中一个【实体类】如何封装如何书写
* 实体类：
* 真实存在的一个数据，人，狗，英雄
*/
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规范只是一个规范，而且是作为一个基础规范，操作都是可以使用快捷键来完成的！！
4. 多类合作【重点】
5.1 汽车类和修理厂类分析
汽车
可以看作是一个类
成员变量：
名字
颜色
轮胎个数
成员方法：
飙车
飙车要有要求，轮胎个数必须为4
修理厂
可以看作是一个类
成员变量：
名字
地址
联系方式
成员方法：
修理汽车的方法【重点】
该方法是需要一个汽车类的对象
5.2 汽车类代码实现
package com.qianfeng.b;
/*
* 汽车
* 可以看作是一个类
* 成员变量：
* 名字
* 颜色
* 轮胎个数
*
* 成员方法：
* 飙车
* 飙尘有要求，轮胎个数必须为4
*/
public class Car {
//成员变量 Field
private String name;
private String color;
private int wheelCount;
//构造方法
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 + "骊山弯道飙车时速280KM/H");
} else {
System.out.println("缺少轮胎，快去修理厂！");
}
}
//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.qianfeng.b;
/*
* 修理厂
* 可以看作是一个类
* 成员变量：
* 名字
* 地址
* 电话
*
* 成员方法：
* 修理汽车的方法【重点】
* 该方法是需要一个汽车类对象
*/
public class Factory {
//成员变量
String name;
String address;
String tel;
//构造方法
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 {
if (car.getWheelCount() < 4) {
System.out.println("缺少轮胎，需要修理");
//修改当前汽车对象的轮胎个数，赋值为4
car.setWheelCount(4);
//报错，com + 1 选择第一个回车
Thread.sleep(1000);
System.out.println("¥100000");
} 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.qianfeng.b;
public class Demo {
public static void main(String[] args) throws
InterruptedException{
/*
* 同包package内可以直接使用对应的class类
*/
Car car = new Car("特斯拉", "黑色", 4);
for (int i = 0; i < 10; i++) {
car.race();
/*
* 让程序暂停0.5s，存在一个红色的报错。这里Ctrl + 1
* 快速修复，选择第一个
*/
Thread.sleep(500);
}
Thread.sleep(1000);
System.out.println("轮胎爆一个");
//轮胎爆一个
car.setWheelCount(3);
Thread.sleep(1000);
car.race();
//现在需要一个修理厂对象
Factory factory = new Factory();
factory.setAddress("劳动路转盘");
factory.setName("狂人修车");
factory.setTel("18629433943");
/*
* 这里需要通过Factory类对象，调用repair方法，修理汽车Car类对象
*/
factory.repair(car);
for (int i = 0; i < 10; i++) {
car.race();
Thread.sleep(500);
}
}
}
