JAVA——面向对象2.0

面向对象2.0

1.构造方法[鸡肋]

1.1 作用

	用于再开发过程中创建对象使用，创建对象目前的格式
	new 类名（有可能使用到的参数）；
	
	类名（有可能使用到的参数）；这就是构造方法 Constructor
	
	初始化当前创建对象中的成员变量数据！！！

1.2格式

格式：
    public 类名（所需初始化参数列表）｛
    	初始化语句
    ｝
细节：
    1.构造方法的名字必须是类名，并且其他方法的名字不能是类名
    2.构造方法没有返回值类型声明
    3.初始化参数列表和正常的方法列表操作使用一致
    4.初始化语句，大多数都是一些赋值语句

1.3貌似我们昨天没有写构造方法，但是我们用了

首相
	在Eclipse项目所在文件夹中，bin目录是存放当前JAVA程序对应的所以的.class二进制文件（字节码文件）.该文件保存了java文件对应的所有内容
	这里可以通过反编译工具看到一些特定的现象【了解】

java编译器行为
	在代码中任何没有【显示】自行声明构造方法，java编译器会在编译代码的过程中辅助程序员完成一个无参数的构造方法，供程序员使用
	

1.4根据需求完成所需构造方法

格式：
    public 类名（所需初始化参数列表）｛
    	初始化语句
    ｝
需求：
	1.完成对于姓名在创建对象初始化的构造方法、
	2.完成对于姓名，年龄创建对象初始化的构造方法
	3.完成对于姓名，年龄，性别创建对象初始化的构造方法
	
注意：
	如果在代码中程序员自行完成了构造方法，Java编译器不再提供自动生成的无参数构造方法。
	
	【强制要求】
	以后代码中无论什么时候都要给用户提供一个无参数方法。

package com.qfedu.a.constructor;

class Dog {
   String name;
   int age;
   char gander;
   
   
   //无参数构造方法
   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;
   	gander = g;
   }

   
   public void eat(String food) {
   	System.out.println("吃"+food);
   	}
   // 睡醒行为描述

   public void sleep() {
   	System.out.println("狗狗晚秋");
   }
   public void game() {
   	System.out.println("狗狗作息规律");	
   
   }
}

public class Demo1 {
   public static void main(String[] args) {
   	/*
   	 * 这里调用的是一个无参数构造方法
   	 * 但是该方法在Dog类内是没有定义的
   	 * 
   	 * 以后使用比较多的情况大多数都是
   	 */
   	
   	Dog dog = new Dog();
   	System.out.println("Name :" + dog.name);
   	System.out.println("Age :" + dog.age);
   	System.out.println("Gender :" + dog.gander);
   	
   	System.out.println("-------------------");
   	
   	Dog dog2 = new Dog("骚姐");
   	System.out.println("Name :" + dog2.name);
   	System.out.println("Age :" + dog2.age);
   	System.out.println("Gender :" + dog2.gander);
       
   	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.gander);
   	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.gander);
       
       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.类对象内存分析圈【重点】

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-WJZz7Mqi-1588084666709)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20200428193133789.png)]

3.this关键字【鸡肋】

3.1this关键字【重点】

this关键字表示对象本身
	1.调用当前方法的对象
	2.通过构造方法
	
this表示一个对象！！！ 当前对象

3.2目前this关键字解决问题

package com.qfedu.b_this;
class Person {
	String name;
	int age;
	
	public Person(String name) {
		/*
		 * 以下操作是没有用的，这是自娱自乐
		 * 这里存在一个【就近原则】问题，如果出现和成员变量
		 * 同名的局部变量，采用就近原则
		 * name = name;
		 * 
		 * 这里需要赋值操作的
		 */
		
		this.name = name;
	}
	
	public Person(String name,int age) {
		this.name = name;
		this.age = age;
	}
	


	public Person() {
	System.out.println("Constructor: " + this);
	
	}
	public void test() {
		System.out.println("test: " + this);
	}
}

public class Demo1 {
	public static void main(String[] args) {
		Person person = new Person();
		
		System.out.print("test: " + person);
	}
}

4.封装【重点，规范】

4.1面向对象三大特征

封装
	最基本的思想
继承
	子承父业，你长得真像你父母
多态
	【最难的是多态，最简单的也是多态】

4.2 封装，不单单是对于类的封装

归纳总结！！！！
	循环封装过程！
	方法封装功能
	类封装数据
	框架封装模块
	
一段代码使用了三遍，做成一个循环
一个循环使用了三遍，做成一个方法
一个方法使用了三遍，做成了一个工具类
一个工具类使用了三遍，做成了一个文档
一个文档使用了三遍，做成了一篇博客

4.3java中规范化封装【JavaBean规范】

要求
	1.所有的成员变量全部私有化【private修饰】
	2.要求至少完成一个无参数构造方法，其他无所谓
	3.要求给予所有的成员变量对应的setter和getter方法

4.3.1权限修饰符

private
	私有化内容，使用private修饰成员变量，成员方法和构造方法，有且只能类内使用，类外没有操作权限
	使用private修饰的内容只能在class所处大括号以内使用
public 
	公开内容，制药存在对应的类对象，都可以通过类对象调用类内的public修饰的成员变量和成员方法

4.3.2解决私有化成员变量赋值和取之操作问题

privare私有化修饰的成员变量，类外不能通过类对象操作，取之，赋值

JavaBean规范规定了
	setter ==> 赋值操作
	格式：
		public void set成员变量名(对应成员变量数据类型参数) {
			赋值操作
		}
	getter ==> 取值操作
		public 对应成员变量数据类型返回值 get成员变量名字（）｛
			return 成员变量；
		｝
		
注意
	1.方法格式固定，setter和getter方法操作过程不能修改
	2.方法需要符合命名规范，小驼峰命名法
	3.boolean类型数据较特殊
        boolean类型的成员变量getter方法要求is开头

4.3.3可以使用快捷方式完成代码

package come.qfedu.c;

/*
 * 以后开发中一个【实体类】如何封装如何书写
 * 实体类：
 * 			真是存在的一个数据，人，狗，英雄
 */
class LOLHero {
	private String name;
	private float hp;
	private float mp;
	private boolean gender;
	
	
	public LOLHero() {}
	
	public boolean isGender() {
		return gender;
	}
/*
 * boolean类型成员变量
 */
	public void setGender(boolean gender) {
		this.gender = gender;
	}

	public LOLHero(String name, float hp, float mp) {
		super();
		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;
	}
	
	
}
public class Demo2 {

}

4.3.4关于JavaBean规范的总结

JavaBean规范指定的要求
	1.要求Java中的所有实体类成员变量全部私有化，最少提供一个无参数构造方法，对应成员变量实现setter和getter方法
	2.JavaBean规范，是为了后期开发汇总更好的代码适配度，提高代码运行的统一性，能够满足框架的使用
	3.JavaBean规范只能是一个规范，而且是作为一个基础规范，操作都是可以使用快捷键来完成的！！！

5.多类合作【重点】

汽车
	可以看作是一个类
	成员变量：
	名字
	颜色
	轮胎个数
	
	成员方法：
		飙车
			飙车有要求，轮胎个数必须4个
	
修理厂
	可以看作是一个类
		地址
		联系方式
		
	成员方法：
		修理汽车的方法【重点】
			该方法是需要一个汽车类的对象
	

5.2汽车类代码实现

package come.qfedu.d;
/*
 * 汽车
	可以看作是一个类
	成员变量：
	名字
	颜色
	轮胎个数
	
	成员方法：
		飙车
			飙车有要求，轮胎个数必须4个
*/


public class Car {
	private String name;
	private String color;
	private int wheelCount;
	
	
	public Car() {}
			
	public Car(String name, String color, int wheelCount) {
		super();
		this.name = name;
		this.color = color;
		this.wheelCount = wheelCount;
		
		
	}
	/** 
	 * 飙车方法,如果轮胎个数不为4，提示需要找修理厂
	 * 
	 */
	public void race() {
		if (4 == wheelCount) {
			System.out.println("开着" + color + "颜色" + name + "在秋名山以400k/m飙车");
		} 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;
	}
	
	
	
}

5.3修理厂代码实现

package come.qfedu.d;

/*
 * 修理厂
	可以看作是一个类
		地址
		联系方式
		
	成员方法：
		修理汽车的方法【重点】
			该方法是需要一个汽车类的对象

*/


public class Factory {
	//成员变量 Field
	private String name;
	private String address;
	private String tel;
	
	public Factory() {}

	public Factory(String name, String address, String tel) {
		super();
		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("轮胎有问题，及时修理");
			car.setWheelCount(4);
			Thread.sleep(1000);
	
		System.out.println("10k人民币");
		
		} 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;
	}
	
}

主方法

package come.qfedu.d;

public class Demo {
	public static void main(String[] args) throws 
InterruptedException {
		
		Car car = new Car("令克03+", "黑色", 4);
		
		for (int i = 0; i < 10; i++) {
			car.race();
			Thread.sleep(500);
		
		}
		Thread.sleep(1000);
		
		System.out.println("轮胎BOOOM！！！");
		
		car.setWheelCount(3);
		
		Thread.sleep(1000);
		
		car.race();
		Factory factory = new Factory();
		
		factory.setName("海航中路60号");
		factory.setAddress("骚磊汽修");
		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);
		}
	}
}