12. 面向对象3.0

12. 面向对象3.0

12.1 多类合作

12.1.1 PC类

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

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

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

12.1.2 屏幕类代码实现

/**
 * 屏幕类
 * 
 * @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;
	}	
}

12.1.3键盘类代码实现

/**
 * 键盘类
 * 
 * @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;
	}
}

12.1.4 PC类代码实现【重】

/*
 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());
	}

}

12.1.5 main方法

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();
	}
}

12.2 多类合作总结

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

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

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

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

12.3 匿名对象

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

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

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

12.3.1 代码演示

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();
	}
}

12.3.2 总结

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

12.4 继承【重点】

12.4.1 java中继承如何完成

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

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();
	}
}

12.4.2 继承总结

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

【有其父才有其子】
	子类对象创建过程中，在使用构造方法时，会默认调用父类的【无参数构造方法】。
	父类的构造方法，不是在创建父类的对象，只是在初始化父类的成员变量空间