java第十四天-面向对象3.0

面向对象3.0

1. 多类合作

1.1 PC类

屏幕
	屏幕可以看做是一个类
	成员变量:
		品牌
		尺寸

键盘
	键盘也可以看做是一个磊
	成员变量:
		品牌
		按键个数

PC电脑类
	成员变量:
		屏幕类对象
		键盘类对象
	成员方法：
		换屏幕
		换键盘
		电脑展示配置

1.2 屏幕类代码实现

package com.qfedu.a.computer;

/**
 * 屏幕类
 * 
 * @author Anonymous
 *
 */
public class Screen {
	// 成员变量  Field
	private String name;
	private float size;
	
	// 构造方法 Constructor
	public Screen() {}

	public Screen(String name, float size) {
		super();
		this.name = name;
		this.size = size;
	}

	// setter 和 getter 方法
	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public float getSize() {
		return size;
	}

	public void setSize(float size) {
		this.size = size;
	}	
}

1.3 键盘类代码实现

package com.qfedu.a.computer;

/**
 * 键盘类
 * 
 * @author Anonymous
 *
 */
public class Keyboard {
	// 成员变量 Field
	private String name;
	private int keyCount;
	
	// 构造方法 Constructor
	public Keyboard() {}

	public Keyboard(String name, int keyCount) {
		this.name = name;
		this.keyCount = keyCount;
	}

	// setter 和 getter 方法 Method
	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getKeyCount() {
		return keyCount;
	}

	public void setKeyCount(int keyCount) {
		this.keyCount = keyCount;
	}
}

1.4 PC类代码实现【重点】

package com.qfedu.a.computer;

/*
 PC电脑类
	成员变量:
		屏幕类对象
		键盘类对象
	成员方法：
		换屏幕
		换键盘
 */
public class PC {
	
	// 成员变量 Field
	/**
	 * Screen自定义屏幕类对象，作为PC类的成员变量
	 */
	private Screen screen;
	
	/**
	 * Keyborad自定义键盘类对象，作为PC类的成员变量
	 */
	private Keyboard keyboard;
	
	
	// 构造方法 Constructor
	public PC() {}

	/**
	 * PC类有参数构造方法，需要的参数是Screen类对象，和Keyboard类对象
	 * 
	 * @param screen   Screen屏幕类对象
	 * @param keyboard Keyboard键盘类对象
	 */
	public PC(Screen screen, Keyboard keyboard) {
		this.screen = screen;
		this.keyboard = keyboard;
	}
	
	/**
	 * 设置Screen屏幕类对象成员变量的方法，需要的是一个Screen类对象作为方法的参数
	 * 
	 * @param screen Screen类对象
	 */
	public void setScreen(Screen screen) {
		this.screen = screen;
	}

	/**
	 * 获取屏幕类对象
	 * 
	 * @return Screen类对象
	 */
	public Screen getScreen() {
		return screen;
	}
	
	/**
	 * 设置Keyboard键盘类对象成员变量的方法，需要的参数是一个Keyboard键盘类对象
	 * 
	 * @param keyboard Keyboard键盘类对象
	 */
	public void setKeyboard(Keyboard keyboard) {
		this.keyboard = keyboard;
	}
	
	/**
	 * 获取一个键盘类对象
	 * 
	 * @return Keyboard键盘类对象
	 */
	public Keyboard getKeyboard() {
		return keyboard;
	}
	
	/*
	 * PC类成员方法，用于展示电脑配置 电脑运行鲁大师！！！查看电脑配置
	 * 
	 * 在整个方法中，获取数据都是通过类对象的方式来获取的，全部是按照面向对象思想来完成的 在代码中要注意方法的调用者是谁！！！
	 * 代码中存在的两个getName方法是完成不同的！！！
	 */
	public void show() {
		System.out.println("屏幕品牌:" + screen.getName() + " 屏幕尺寸:" + screen.getSize());
		System.out.println("键盘品牌:" + keyboard.getName() + " 键盘按键个数:" + keyboard.getKeyCount());
	}

}

1.5 main方法

package com.qfedu.a.computer;

/*

 */
public class Demo {
	public static void main(String[] args) {
		// 先进货，既然需要组装电脑，需要键盘和屏幕
		// Screen 是一个类型  screen是一个屏幕类对象
		Screen screen = new Screen("三星", 15.6F);
		Keyboard keyboard = new Keyboard("双飞燕", 104);
		
		// 组装电脑 使用屏幕类对象和键盘类对象作为参数，创建PC类对象
		PC pc = new PC(screen, keyboard);
		
		// PC类show方法，展示电脑配置
		pc.show();
		
		System.out.println("------------------------------");
		
		// 屏幕不好使，换一个屏幕
		// 进货一个新的屏幕
		Screen screen2 = new Screen("BOE", 24F);
		// 调用PC的setScreen，更换屏幕
		pc.setScreen(screen2);
		
		// 展示电脑配置
		pc.show();
		System.out.println("------------------------------");
		// 键盘不好使，换一个键盘
		// 进货一个新的键盘
		Keyboard keyboard2 = new Keyboard("阿米洛", 87);
		
		// 调用PC的setKeyboard方法，更换键盘
		pc.setKeyboard(keyboard2);
		
		// 展示电脑配置
		pc.show();
	}
}

2. 多类合作总结

1. 类和对象的操作模式
	类是数据类型定义
	对象是目前操作成员方法，操作成员变量的核心

2. 这两组代码在main方法中基本上全部是一个面向对象思想
	a. 自定义数据类型，自定义类对象，作为方法参数。
	b. 通过类对象来操作代码方式，所有的内容都是和对象相关

3. 代码需要阅读，一定要阅读！！！
	不要断章取义！！！
	. 就是的

4. 代码中要什么你给什么

3. 匿名对象

3.1 匿名对象概述

Person person = new Person("骚杰", 66, '男');

Person 类名
person 对象名
new Person(...) 像内存的堆区申请空间，创建一个Person类对象使用的内存空间

匿名对象
	没有名字的对象，没有对象名的对象
格式：
	new 构造方法(所需参数)
用途
	1. 提高开发效率，隐形眼镜日抛，一次性筷子
	匿名对象当前行使用之后，如果没有其他引用数据类型的变量保存其地址，直接销毁
	2. 简化代码结构
	3. 通过匿名对象直接调用成员方法
	4. 使用匿名对象作为方法的参数

3.2 代码演示

package com.qfedu.b.anonymous;

class Dog {
	// 成员变量 Field
	String name;
	
	// 成员方法 Method
	public void sleep() {
		System.out.println("小狗睡觉~~~");
	}
}

public class Demo1 {
	public static void main(String[] args) {
		// 常见模式
		Dog dog = new Dog();
		dog.sleep();
		
		System.out.println("---------------------");
		
		// 使用匿名对象直接调用成员方法
		// 通过匿名对象调用方法之后，当前匿名对象销毁
		new Dog().sleep();
		
		
		// 只要有new关键字，重新创建对象，不存在同一个对象
		System.out.println(new Dog());
		System.out.println(new Dog());
		
		System.out.println("---------------------");
		
		// 匿名对象不推荐使用成员变量，因为肉包子打狗，有去无回
		// 以下代码中是三个完全不同的Dog类对象，给其中任何一个赋值都是无法取出的
		new Dog().name = "骚杰";
		new Dog();
		System.out.println(new Dog().name);
		
		System.out.println("---------------------");
		
		Dog dog2 = new Dog();
		useDog(dog2);
		
		// 匿名对象直接作为方法的参数，【常用】
		useDog(new Dog());
		
		// 下面这一行代码，你们要保证不要问我！！！我只做演示，后面一定会讲 缓冲字节输入流
		// BufferedInputStream bufferedInputStream = new BufferedInputStream(new FileInputStream(new File("C:/aaa/1.txt")));
		
	}
	
	/**
	 * 该方法需要的参数是一个Dog类对象
	 * 
	 * @param dog Dog类对象
	 */
	public static void useDog(Dog dog) {
		dog.sleep();
	}
}

3.3 总结

1. 匿名对象是为了提供开发效率，节约内存使用，同时让代码更加贴近于真实操作
2. 匿名对象常用方式
	第一个是直接使用匿名对象调用成员方法
	第二个是直接使用匿名对象作为方法的参数
3. 匿名对象【禁止】使用成员变量

4. 继承【重点】

4.1 生活中的继承

财产继承
	王多鱼
	子承父业

样貌继承
	你长的真像你父母

家族继承
	祖传秘方

4.2 代码中比较好理解的继承

游戏
	英雄联盟中的所有英雄
	血量，蓝量，攻击力，法术强度，魔抗，护甲，攻击速度，CD......
	
	每一个英雄都会有以上的属性，但是各自使用的方式，技能，模型是不一样的
	
	PUBG
	很多建筑都是类似的？
	拼图楼，学区房，假车库，烂尾楼，二层小楼
	
	楼宇之间有很多相似之处，都是基于一种模型实现的
	
	PUBG人物
	人物物理模型是一样的，速度，跳跃...
	
	装束不一样~~~

4.3 小总结

	继承在开发中是一种抽象的归纳总结思想，剥离通用的属性，通用的方法，简化之后的开发压力。只需要在继承之后，满足个性化的实现即可。
	通过继承可以优化代码，在JavaWEB开发中，继承大多数情况下，都是用来提高方法的复用度

4.4 Java中继承如何完成

关键字:
	extends 
格式:
	class A extends B {
		
	}
	A类是B类的一个子类
	B类是A类的唯一父类
	【Java是一门单继承语言，一个类有且只能继承一个父类】

4.5 继承代码演示

package com.qfedu.c_extends;

class Father {
	public int height;
	
	private int testPrivate;
	
	public void game() {
		System.out.println("钓鱼，象棋~~~");
	}
	
	private void privateMethod() {
		System.out.println("私有化方法");
	}
}

/*
 * Son类是Father类的一个子类
 * Father类是Son类的唯一父类
 */
class Son extends Father {
	public int age;
	
	public void study() {
		System.out.println("子类学习方法！！！好好学习，天天向上！");
	}
}

public class Demo1 {
	public static void main(String[] args) {
		// 创建一个Father类对象
		Father father = new Father();
		
		// 通过Father类对象，使用father类内的成员变量和成员方法
		father.height = 170;
		father.game();
		System.out.println(father.height);
		
		System.out.println("------------------------------------");
		
		// 创建一个Son类对象
		Son son = new Son();
		
		// 使用Son类对象，调用Son类自己的成员变量和成员方法
		son.age = 16;
		son.study();
		System.out.println(son.age);
		
		// 使用Son类的对象，调用通过继承得到的父类【内容】
		// 可以使用Father类内height 成员变量，height成员变量是使用public修饰的
		son.height = 172;
		// 可以使用Father类内的game 成员方法，game成员方法使用public修饰
		son.game();
		
		// private修饰的成员变量，和成员方法不能继承给子类使用
		// The field Father.testPrivate is not visible
		// son.testPrivate = 10;
		// The method privateMethod() from the type Father is not visible
		// son.privateMethod();
	}
}

4.6 继承小总结

1. A类使用extends关键字继承B类
	A类是B类的一个子类，B类是A类的唯一父类
2. 继承之后，子类可以通过继承得到父类中非私有化成员变量，和非私有化成员方法
3. 继承之后，子类不可以通过继承得到父类中的私有化成员变量，和私有化成员方法。
	private修饰的内容有且只能在类内使用！！！

4.7 有其父才有其子【难点】

思考一个问题:
	没有你父母，哪里来的你？？？？

继承情况下，我们会发现一个很特殊的问题【明天画图解决】
	子类对象创建过程中，在使用构造方法时，会默认调用父类的【无参数构造方法】。
	父类的构造方法，不是在创建父类的对象，只是在初始化父类的成员变量空间

今天需要你记住的点
	是从生活逻辑，理解【有其父才有其子】