多类合作
1PC类
屏幕
屏幕可以看做是一个类
成员变量:
品牌
尺寸
键盘
键盘也可以看做是一个类
成员变量:
品牌
按键个数
PC电脑类
成员变量:
屏幕类对象
键盘类对象
成员方法:
换屏幕
换键盘
电脑展示配置
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;
}
}
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;
}
}
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());
}
}
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();
}
}
6.多类合作总结
1. 类和对象的操作模式
类是数据类型定义
对象是目前操作成员方法,操作成员变量的核心
2. 这两组代码在main方法中基本上全部是一个面向对象思想
a. 自定义数据类型,自定义类对象,作为方法参数。
b. 通过类对象来操作代码方式,所有的内容都是和对象相关
3. 代码需要阅读,一定要阅读!!!
不要断章取义!!!
. 就是的
4. 代码中要什么你给什么
匿名对象
1.匿名对象概述
Person person = new Person("骚杰", 66, '男');
Person 类名
person 对象名
new Person(...) 像内存的堆区申请空间,创建一个Person类对象使用的内存空间
匿名对象
没有名字的对象,没有对象名的对象
格式:
new 构造方法(所需参数)
用途
1. 提高开发效率,隐形眼镜日抛,一次性筷子
匿名对象当前行使用之后,如果没有其他引用数据类型的变量保存其地址,直接销毁
2. 简化代码结构
3. 通过匿名对象直接调用成员方法
4. 使用匿名对象作为方法的参数
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.总结
1. 匿名对象是为了提供开发效率,节约内存使用,同时让代码更加贴近于真实操作
2. 匿名对象常用方式
第一个是直接使用匿名对象调用成员方法
第二个是直接使用匿名对象作为方法的参数
3. 匿名对象【禁止】使用成员变量
继承
1.生活中的继承
财产继承
王多鱼
子承父业
样貌继承
你长的真像你父母
家族继承
祖传秘方
2.代码中比较好理解的继承
游戏
英雄联盟中的所有英雄
血量,蓝量,攻击力,法术强度,魔抗,护甲,攻击速度,CD......
每一个英雄都会有以上的属性,但是各自使用的方式,技能,模型是不一样的
PUBG
很多建筑都是类似的?
拼图楼,学区房,假车库,烂尾楼,二层小楼
楼宇之间有很多相似之处,都是基于一种模型实现的
PUBG人物
人物物理模型是一样的,速度,跳跃...
装束不一样~~~
3.小总结
继承在开发中是一种抽象的归纳总结思想,剥离通用的属性,通用的方法,简化之后的开发压力。只需要在继承之后,满足个性化的实现即可。
通过继承可以优化代码,在JavaWEB开发中,继承大多数情况下,都是用来提高方法的复用度
4.Java中继承如何完成
关键字:
extends
格式:
class A extends B {
}
A类是B类的一个子类
B类是A类的唯一父类
【Java是一门单继承语言,一个类有且只能继承一个父类】
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();
}
}
6.继承小总结
1. A类使用extends关键字继承B类
A类是B类的一个子类,B类是A类的唯一父类
2. 继承之后,子类可以通过继承得到父类中非私有化成员变量,和非私有化成员方法
3. 继承之后,子类不可以通过继承得到父类中的私有化成员变量,和私有化成员方法。
private修饰的内容有且只能在类内使用!!!
7.有其父才有其子【难点】
思考一个问题:
没有你父母,哪里来的你????
继承情况下,我们会发现一个很特殊的问题【明天画图解决】
子类对象创建过程中,在使用构造方法时,会默认调用父类的【无参数构造方法】。
父类的构造方法,不是在创建父类的对象,只是在初始化父类的成员变量空间
今天需要你记住的点
是从生活逻辑,理解【有其父才有其子】