面向对象

最新推荐文章于 2024-01-25 15:46:07 发布

Mr__Lemon

最新推荐文章于 2024-01-25 15:46:07 发布

阅读量200

点赞数

文章标签： java 面向对象

本文链接：https://blog.csdn.net/Mr__Lemon/article/details/98785803

版权

###06.01_面向对象(面向对象思想概述)(了解)

A:面向过程思想概述
- 第一步
- 第二步
B:面向对象思想概述
- 找对象(第一步,第二步)
C:举例
- 买煎饼果子
- 洗衣服
D:面向对象思想特点
- a:是一种更符合我们思想习惯的思想
- b:可以将复杂的事情简单化
- c:将我们从执行者变成了指挥者
  - 角色发生了转换
E:面向对象开发
- 就是不断的创建对象，使用对象，指挥对象做事情。
F:面向对象设计
- 其实就是在管理和维护对象之间的关系。
G:面向对象特征
- 封装(encapsulation)
- 继承(inheritance)
- 多态(polymorphism)

###06.02_面向对象(类与对象概述)(掌握)

A:我们学习编程是为了什么
- 为了把我们日常生活中实物用学习语言描述出来
B:我们如何描述现实世界事物
- 属性就是该事物的描述信息(事物身上的名词)
- 行为就是该事物能够做什么(事物身上的动词)
C:Java中最基本的单位是类,Java中用class描述事物也是如此
- 成员变量就是事物的属性
- 成员方法就是事物的行为
D:定义类其实就是定义类的成员(成员变量和成员方法)
- a:成员变量和以前定义变量是一样的，只不过位置发生了改变。在类中，方法外。
- b:成员方法和以前定义方法是一样的，只不过把static去掉，后面在详细讲解static的作用。
E:类和对象的概念
- a:类：是一组相关的属性和行为的集合
- b:对象：是该类事物的具体体现
- c:举例：
  - 类学生
  - 对象具体的某个学生就是一个对象

###06.03_面向对象(学生类的定义)(掌握)

A:学生事物
B:学生类
C:案例演示
- 属性:姓名,年龄,性别
- 行为:学习,睡觉

###06.04_面向对象(手机类的定义)(掌握)

模仿学生类，让学生自己完成
- 属性:品牌(brand)价格(price)
- 行为:打电话(call),发信息(sendMessage)玩游戏(playGame)

###06.05_面向对象(学生类的使用)(掌握)

A:文件名问题
- 在一个java文件中写两个类：一个基本的类，一个测试类。
- 建议：文件名称和测试类名称一致。
B:如何使用对象?
- 创建对象并使用
- 格式：类名对象名 = new 类名();
D:如何使用成员变量呢?
- 对象名.变量名
E:如何使用成员方法呢?
- 对象名.方法名(…)

###06.06_面向对象(手机类的使用)(掌握)

A:学生自己完成
- 模仿学生类，让学生自己完成

###06.07_面向对象(一个对象的内存图)(掌握)

A:画图演示
- 一个对象

###06.08_面向对象(二个对象的内存图)(了解)

A:画图演示
- 二个不同的对象

###06.09_面向对象(三个引用两个对象的内存图)(了解)

A:画图演示
- 三个引用，有两个对象的引用指向同一个地址

###06.10_面向对象(成员变量和局部变量的区别)(掌握)

A:在类中的位置不同
- 成员变量：在类中方法外
- 局部变量：在方法定义中或者方法声明上
B:在内存中的位置不同
- 成员变量：在堆内存(成员变量属于对象,对象进堆内存)
- 局部变量：在栈内存(局部变量属于方法,方法进栈内存)
C:生命周期不同
- 成员变量：随着对象的创建而存在，随着对象的消失而消失
- 局部变量：随着方法的调用而存在，随着方法的调用完毕而消失
D:初始化值不同
- 成员变量：有默认初始化值
- 局部变量：没有默认初始化值，必须定义，赋值，然后才能使用。
注意事项：
- 局部变量名称可以和成员变量名称一样，在方法中使用的时候，采用的是就近原则。
- 基本数据类型变量包括哪些:byte,short,int,long,float,double,boolean,char
- 引用数据类型变量包括哪些:数组,类,接口,枚举

###06.11_面向对象(方法的形式参数是类名的时候如何调用)(掌握)

A:方法的参数是类名public void print(Student s){}//print(new Student());
- 如果你看到了一个方法的形式参数是一个类类型(引用类型)，这里其实需要的是该类的对象。

###06.12_面向对象(匿名对象的概述和应用)(掌握)

A:什么是匿名对象
- 没有名字的对象
B:匿名对象应用场景
- a:调用方法，仅仅只调用一次的时候。
  - 那么，这种匿名调用有什么好处吗?
    - 节省代码
  - 注意：调用多次的时候，不适合。匿名对象调用完毕就是垃圾。可以被垃圾回收器回收。
- b:匿名对象可以作为实际参数传递
C:案例演示
- 匿名对象应用场景

###06.13_面向对象(封装的概述)(掌握)

A:封装概述
- 是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。
B:封装好处
- 隐藏实现细节，提供公共的访问方式
- 提高了代码的复用性
- 提高安全性。
C:封装原则
- 将不需要对外提供的内容都隐藏起来。
- 把属性隐藏，提供公共方法对其访问。

###06.14_面向对象(private关键字的概述和特点)(掌握)

A:人类赋值年龄的问题
B:private关键字特点
- a:是一个权限修饰符
- b:可以修饰成员变量和成员方法
- c:被其修饰的成员只能在本类中被访问
C:案例演示
- 封装和private的应用：
- A:把成员变量用private修饰
- B:提供对应的getXxx()和setXxx()方法
- private仅仅是封装的一种体现形式,不能说封装就是私有

###06.15_面向对象(this关键字的概述和应用)(掌握)

A:this关键字特点
- 代表当前对象的引用
B:案例演示
- this的应用场景
- 用来区分成员变量和局部变量重名

###06.16_面向对象(手机类代码及其测试)(掌握)

A:学生练习

请把手机类写成一个标准类，然后创建对象测试功能。

  class Demo2_Phone {
  	public static void main(String[] args) {
  		Phone p1 = new Phone();
  		p1.setBrand("三星");
  		p1.setPrice(5288);
  
  		System.out.println(p1.getBrand() + "..." + p1.getPrice());
  		p1.call();
  		p1.sendMessage();
  		p1.playGame();
  	}
  }
  /*
  手机类
  	属性:品牌brand,价格price
  	行为:打电话call,发短信sendMessage,玩游戏,playGame
  */
  class Phone {								//java bean
  	private String brand;					//品牌
  	private int price;						//价格
  
  	public void setBrand(String brand) {	//设置品牌
  		this.brand = brand;
  	}
  
  	public String getBrand() {				//获取品牌
  		return this.brand;					//this.可以省略,你不加系统会默认给你加
  	}
  
  	public void setPrice(int price) {		//设置价格
  		this.price = price;
  	}
  
  	public int getPrice() {					//获取价格
  		return price;
  	}
  
  	public void call() {					//打电话
  		System.out.println("打电话");
  	}
  
  	public void sendMessage() {				//发短信
  		System.out.println("发短信");
  	}
  
  	public void playGame() {				//玩游戏
  		System.out.println("玩游戏");
  	}
  }

###07.01_面向对象(构造方法Constructor概述和格式)(掌握)

A:构造方法概述和作用
- 给对象的数据(属性)进行初始化
B:构造方法格式特点
- a:方法名与类名相同(大小也要与类名一致)
- b:没有返回值类型，连void都没有
- c:没有具体的返回值return;

###07.02_面向对象(构造方法的重载及注意事项)(掌握)

A:案例演示
- 构造方法的重载
- 重载:方法名相同,与返回值类型无关(构造方法没有返回值),只看参数列表
B:构造方法注意事项
- a:如果我们没有给出构造方法，系统将自动提供一个无参构造方法。
- b:如果我们给出了构造方法，系统将不再提供默认的无参构造方法。
  - 注意：这个时候，如果我们还想使用无参构造方法，就必须自己给出。建议永远自己给出无参构造方法

###07.03_面向对象(给成员变量赋值的两种方式的区别)

A:setXxx()方法
- 修改属性值
B:构造方法
- 给对象中属性进行初始化

###07.04_面向对象(学生类的代码及测试)(掌握)

A:案例演示
- 学生类：
  - 成员变量：
    - name，age
  - 构造方法：
    - 无参，带两个参
  - 成员方法：
    - getXxx()/setXxx()
    - show()：输出该类的所有成员变量值
B:给成员变量赋值：
- a:setXxx()方法
- b:构造方法
C:输出成员变量值的方式：
- a:通过getXxx()分别获取然后拼接
- b:通过调用show()方法搞定

###07.05_面向对象(手机类的代码及测试)(掌握)

A:案例演示
- 模仿学生类，完成手机类代码

###07.06_面向对象(创建一个对象的步骤)(掌握)

A:画图演示
- 画图说明一个对象的创建过程做了哪些事情?
- Student s = new Student();
- 1,Student.class加载进内存
- 2,声明一个Student类型引用s
- 3,在堆内存创建对象,
- 4,给对象中属性默认初始化值
- 5,属性进行显示初始化
- 6,构造方法进栈,对对象中的属性赋值,构造方法弹栈
- 7,将对象的地址值赋值给s

###07.07_面向对象(长方形案例练习)(掌握)

A:案例演示Rectangle
- 需求：
  - 定义一个长方形类,定义求周长和面积的方法，
  - 然后定义一个测试类进行测试。

###07.08_面向对象(员工类案例练习)(掌握)

A:案例演示
- 需求：定义一个员工类Employee
- 自己分析出几个成员，然后给出成员变量
  - 姓名name,工号id,工资salary
- 构造方法，
  - 空参和有参的
- getXxx()setXxx()方法，
- 以及一个显示所有成员信息的方法。并测试。
  - work

###07.09_面向对象(static关键字及内存图)(了解)

A:案例演示
- 通过一个案例引入static关键字。
- 人类：Person。每个人都有国籍，中国。
B:画图演示
- 带有static的内存图

###07.10_面向对象(static关键字的特点)(掌握)

A:static关键字的特点
- a:随着类的加载而加载
- b:优先于对象存在
- c:被类的所有对象共享
  - 举例：咱们班级的学生应该共用同一个班级编号。
  - 其实这个特点也是在告诉我们什么时候使用静态?
    - 如果某个成员变量是被所有对象共享的，那么它就应该定义为静态的。
  - 举例：
    - 饮水机(用静态修饰)
    - 水杯(不能用静态修饰)
    - 共性用静态,特性用非静态
- d:可以通过类名调用
  - 其实它本身也可以通过对象名调用。
  - 推荐使用类名调用。
  - 静态修饰的内容一般我们称其为：与类相关的，类成员
B:案例演示
- static关键字的特点

###07.11_面向对象(static的注意事项)(掌握)

A:static的注意事项
- a:在静态方法中是没有this关键字的
  - 如何理解呢?
    - 静态是随着类的加载而加载，this是随着对象的创建而存在。
    - 静态比对象先存在。
- b:静态方法只能访问静态的成员变量和静态的成员方法
  - 静态方法：
    - 成员变量：只能访问静态变量
    - 成员方法：只能访问静态成员方法
  - 非静态方法：
    - 成员变量：可以是静态的，也可以是非静态的
    - 成员方法：可是是静态的成员方法，也可以是非静态的成员方法。
  - 简单记：
    - 静态只能访问静态。
B:案例演示
- static的注意事项

###07.12_面向对象(静态变量和成员变量的区别)(掌握)

静态变量也叫类变量成员变量也叫对象变量
A:所属不同
- 静态变量属于类，所以也称为为类变量
- 成员变量属于对象，所以也称为实例变量(对象变量)
B:内存中位置不同
- 静态变量存储于方法区的静态区
- 成员变量存储于堆内存
C:内存出现时间不同
- 静态变量随着类的加载而加载，随着类的消失而消失
- 成员变量随着对象的创建而存在，随着对象的消失而消失
D:调用不同
- 静态变量可以通过类名调用，也可以通过对象调用
- 成员变量只能通过对象名调用

###07.13_面向对象(main方法的格式详细解释)(了解)

A:格式
- public static void main(String[] args) {}
B:针对格式的解释
- public 被jvm调用，访问权限足够大。
- static 被jvm调用，不用创建对象，直接类名访问
- void被jvm调用，不需要给jvm返回值
- main 一个通用的名称，虽然不是关键字，但是被jvm识别
- String[] args 以前用于接收键盘录入的
C:演示案例
- 通过args接收键盘例如数据

###07.14_面向对象(工具类中使用静态)(了解)

A:制作一个工具类
- ArrayTool
- 1,获取最大值
- 2,数组的遍历
- 3,数组的反转

###07.15_面向对象(说明书的制作过程)(了解)

A:对工具类加入文档注释
B:通过javadoc命令生成说明书
- @author(提取作者内容)
- @version(提取版本内容)
- javadoc -d 指定的文件目录 -author -version ArrayTool.java
- @param 参数名称//形式参数的变量名称
- @return 函数运行完返回的数据

###07.16_面向对象(如何使用JDK提供的帮助文档)(了解)

A:找到文档，打开文档
B:点击显示，找到索引，出现输入框
C:你应该知道你找谁?举例：Scanner
D:看这个类的结构(需不需要导包)
- 成员变量字段
- 构造方法构造方法
- 成员方法方法

###07.17_面向对象(学习Math类的随机数功能)(了解)

打开JDK提供的帮助文档学习
A:Math类概述
- 类包含用于执行基本数学运算的方法
B:Math类特点
- 由于Math类在java.lang包下，所以不需要导包。
- 因为它的成员全部是静态的,所以私有了构造方法
C:获取随机数的方法
- public static double random():返回带正号的 double 值，该值大于等于 0.0 且小于 1.0。
D:我要获取一个1-100之间的随机数，肿么办?
- int number = (int)(Math.random()*100)+1;

###07.18_面向对象(猜数字小游戏案例)(了解)

A:案例演示
- 需求：猜数字小游戏(数据在1-100之间)
- 程序运行起来，自动生成一个1-100的随机数，然后期待用户从键盘上输入一个整形数，
- 进行比较，如果偏大或偏小，则给你提示，让你再次输入，一直猜到正确的数字，循环结束。

###08.01_面向对象(代码块的概述和分类)(了解)(面试的时候会问,开发不用或者很少用)

A:代码块概述
- 在Java中，使用{}括起来的代码被称为代码块。
B:代码块分类
- 根据其位置和声明的不同，可以分为局部代码块，构造代码块，静态代码块，同步代码块(多线程讲解)。
C:常见代码块的应用
- a:局部代码块
  - 在方法中出现；限定变量生命周期，及早释放，提高内存利用率
- b:构造代码块 (初始化块)
  - 在类中方法外出现；多个构造方法方法中相同的代码存放到一起，每次调用构造都执行，并且在构造方法前执行
- c:静态代码块
  - 在类中方法外出现，并加上static修饰；用于给类进行初始化，在加载的时候就执行，并且只执行一次。
  - 一般用于加载驱动

###08.02_面向对象(代码块的面试题)(掌握)

A:看程序写结果

  class Student {
  	static {
  		System.out.println("Student 静态代码块");
  	}
  	
  	{
  		System.out.println("Student 构造代码块");
  	}
  	
  	public Student() {
  		System.out.println("Student 构造方法");
  	}
  }

  class Demo2_Student {
  	static {
  		System.out.println("Demo2_Student静态代码块");
  	}
  	
  	public static void main(String[] args) {
  		System.out.println("我是main方法");
  		
  		Student s1 = new Student();
  		Student s2 = new Student();
  	}
  }
  
  "Demo2_Student静态代码块"
  "我是main方法"
  "Student 静态代码块"
  "Student 构造代码块"
  "Student 构造方法"
  "Student 构造代码块"
  "Student 构造方法"

###08.03_面向对象(继承案例演示)(掌握)

A:继承(extends)
- 让类与类之间产生关系,子父类关系
B:继承案例演示：
- 动物类,猫类,狗类
- 定义两个属性(颜色,腿的个数)两个功能(吃饭，睡觉)
C:案例演示
- 使用继承前
D:案例演示
- 使用继承后
E:继承格式
- class 子类名 extends 父类名 { 属性；方法；}

###08.04_面向对象(继承的好处和弊端)(掌握)

A:继承的好处
- a:提高了代码的复用性
- b:提高了代码的维护性
- c:让类与类之间产生了关系，是多态的前提
B:继承的弊端
- 类的耦合性增强了。
- 开发的原则：高内聚，低耦合。
- 耦合：类与类的关系
- 内聚：就是自己完成某件事情的能力

###08.05_面向对象(Java中类的继承特点)(掌握)

A:Java中类的继承特点
- a:Java只支持单继承，不支持多继承。(一个儿子只能有一个爹)
  - 有些语言是支持多继承，格式：extends 类1,类2,…
- b:Java支持多层继承(继承体系)
B:案例演示
- Java中类的继承特点
  - 如果想用这个体系的所有功能用最底层的类创建对象
  - 如果想看这个体系的共性功能,看最顶层的类

###08.06_面向对象(继承的注意事项和什么时候使用继承)(掌握)

A:继承的注意事项
- a:子类只能继承父类所有非私有的成员(成员方法和成员变量)
- b:子类不能继承父类的构造方法，但是可以通过super(马上讲)关键字去访问父类构造方法。
- c:不要为了部分功能而去继承
- 项目经理姓名工号工资奖金
- 程序员姓名工号工资
B:什么时候使用继承
- 继承其实体现的是一种关系：“is a”。
  Person
  Student
  Teacher
  水果
  苹果
  香蕉
  橘子
采用假设法。
如果有两个类A,B。只有他们符合A是B的一种，或者B是A的一种，就可以考虑使用继承。

###08.07_面向对象(继承中成员变量的关系)(掌握)

A:案例演示
- a:不同名的变量
- b:同名的变量
  ###08.08_面向对象(this和super的区别和应用)(掌握)
A:this和super都代表什么【this.成员 super.成员】
- this:代表当前对象的引用,谁来调用我,我就代表谁
- super:代表当前对象父类部分的引用
B:this和super的使用区别
- a:调用成员变量
  - this.成员变量调用本类的成员变量,也可以调用父类的成员变量
  - super.成员变量调用父类的成员变量
- b:调用构造方法
  - this(…) 调用本类的构造方法
  - super(…) 调用父类的构造方法
- c:调用成员方法
  - this.成员方法调用本类的成员方法,也可以调用父类的方法
  - super.成员方法调用父类的成员方法
C: this() super()必须在代码段的第一行； this() super() 有且只能有一个出现。

###08.09_面向对象(继承中构造方法的关系)(掌握)

A:案例演示
- 子类中所有的构造方法默认都会访问父类中空参数的构造方法
B:为什么呢?
- 因为子类会继承父类中的数据，可能还会使用父类的数据。
- 所以，子类初始化之前，一定要先完成父类数据的初始化。
- 其实：
  - 每一个构造方法的第一条语句默认都是：super() Object类最顶层的父类。

###08.10_面向对象(继承中构造方法的注意事项)(掌握)

A:案例演示
- 父类没有无参构造方法,子类怎么办?
- super解决
- this解决
B:注意事项
- super(…)或者this(….)必须出现在构造方法的第一条语句上

###08.11_面向对象(继承中的面试题)(掌握)

A:案例演示

  看程序写结果1
  class Fu{
  	public int num = 10;
  	public Fu(){
  		System.out.println("fu");
  	}
  }
  class Zi extends Fu{
  	public int num = 20;
  	public Zi(){
  		System.out.println("zi");
  	}
  	public void show(){
  		int num = 30;
  		System.out.println(num);
  		System.out.println(this.num);
  		System.out.println(super.num);
  	}
  }
  class Test1_Extends {
  	public static void main(String[] args) {
  		Zi z = new Zi();
  		z.show();
  	}
  }

  看程序写结果2
  class Fu {
  	static {
  		System.out.println("静态代码块Fu");
  	}

  	{
  		System.out.println("构造代码块Fu");
  	}

  	public Fu() {
  		System.out.println("构造方法Fu");
  	}
  }

  class Zi extends Fu {
  	static {
  		System.out.println("静态代码块Zi");
  	}

  	{
  		System.out.println("构造代码块Zi");
  	}

  	public Zi() {
  		System.out.println("构造方法Zi");
  	}
  }

  Zi z = new Zi(); 请执行结果。

###08.12_面向对象(继承中成员方法关系)(掌握)

A:案例演示
- a:不同名的方法
- b:同名的方法

###08.13_面向对象(方法重写概述及其应用)(掌握)

A:什么是方法重写
- 重写:子父类出现了一模一样的方法(注意:返回值类型可以是子父类,这个我们学完面向对象讲)
B:方法重写的应用：
- 当子类需要父类的功能，而功能主体子类有自己特有内容时，可以重写父类中的方法。这样，即沿袭了父类的功能，又定义了子类特有的内容。
C:案例演示
- a:定义一个手机类。

###08.14_面向对象(方法重写的注意事项)(掌握)

A:方法重写注意事项
- a:父类中私有方法不能被重写
  - 因为父类私有方法子类根本就无法继承
- b:子类重写父类方法时，访问权限不能更低
  - 最好就一致
- c:父类静态方法，子类也必须通过静态方法进行重写
  - 其实这个算不上方法重写，但是现象确实如此，至于为什么算不上方法重写，多态中我会讲解(静态只能覆盖静态)
- 子类重写父类方法的时候，最好声明一模一样。
B:案例演示
- 方法重写注意事项

###08.15_面向对象(方法重写的面试题)(掌握)

A:方法重写的面试题
- Override和Overload的区别? Overload能改变返回值类型吗?
- overload可以改变返回值类型,只看参数列表
- 方法重写：子类中出现了和父类中方法声明一模一样的方法。与返回值类型有关,返回值是一致(或者是子父类)的
- 方法重载：本类中出现的方法名一样，参数列表不同的方法。与返回值类型无关。
- 子类对象调用方法的时候：
  - 先找子类本身，再找父类。

###08.16_面向对象(使用继承前的学生和老师案例)(掌握)

A:案例演示
- 使用继承前的学生和老师案例
- 属性:姓名,年龄
- 行为:吃饭
- 老师有特有的方法:讲课
- 学生有特有的方法:学习

###08.17_面向对象(使用继承后的学生和老师案例)(掌握)

A:案例演示
- 使用继承后的学生和老师案例

###08.18_面向对象(猫狗案例分析,实现及测试)(掌握)

A:猫狗案例分析
B:案例演示
- 猫狗案例继承版
- 属性:毛的颜色,腿的个数
- 行为:吃饭
- 猫特有行为:抓老鼠catchMouse
- 狗特有行为:看家lookHome

###08.19_面向对象(final关键字修饰类,方法以及变量的特点)(掌握)

A:final概述
B:final修饰特点
- 修饰类，类不能被继承
- 修饰变量，变量就变成了常量，只能被赋值一次
- 修饰方法，方法不能被重写
C:案例演示
- final修饰特点

###08.20_面向对象(final关键字修饰局部变量)(掌握)

A:案例演示
- 方法内部或者方法声明上都演示一下(了解)
- 基本类型，是值不能被改变
- 引用类型，是地址值不能被改变,对象中的属性可以改变

###08.21_面向对象(final修饰变量的初始化时机)(掌握)

A:final修饰变量的初始化时机
- 显示初始化
- 在对象构造完毕前即可

###09.01_面向对象(多态的概述及其代码体现)

A:多态(polymorphic)概述
- 事物存在的多种形态
- 编译时多态【重载】，运行时多态
B:多态前提
- a:要有继承关系。
- b:要有方法重写。
- c:要有父类引用指向子类对象。
C:案例演示
- 代码体现多态

###09.02_面向对象(多态中的成员访问特点之成员变量)

成员变量
- 编译看左边(父类)，运行看左边(父类)。

###09.03_面向对象(多态中的成员访问特点之成员方法)

成员方法
- 编译看左边(父类)，运行看右边(子类)。
- 编译时观察左边对象所属类中有没有对应的方法，如果没有，编译出错！
- 运行时观察左边对象引用指向哪个对象，如果执行子对象，则调用子类中方法。

###09.04_面向对象(多态中的成员访问特点之静态成员方法)

静态方法
- 编译看左边(父类)，运行看左边(父类)。
- (静态和类相关，算不上重写，所以，访问还是左边的)
- 只有非静态的成员方法,编译看左边,运行看右边

###09.05_面向对象(超人的故事)

A:案例分析
- 通过该案例帮助学生理解多态的现象

###09.06_面向对象(多态中向上转型和向下转型)

A:案例演示
- 详细讲解多态中向上转型和向下转型
  Person p = new SuperMan();向上转型
  SuperMan sm = (SuperMan)p;向下转型
引用名 instanceof 类名

###09.07_面向对象(多态的好处和弊端)

A:多态的好处
- a:提高了代码的维护性(继承保证)
- b:提高了代码的扩展性(由多态保证，传参父类引用)
B:案例演示
- 多态的好处
- 可以当作形式参数,可以接收任意子类对象
C:多态的弊端
- 不能使用子类的特有属性和行为。
- 解决方案: 向下转型之后去调用。
D:案例演示
method(Animal a)
method(Cat c)

###09.08_面向对象(多态中的题目分析题)

A:看下面程序是否有问题，如果没有，说出结果

  class Fu {
  	public void show() {
  		System.out.println("fu show");
  	}
  }

  class Zi extends Fu {
  	public void show() {
  		System.out.println("zi show");
  	}

  	public void method() {
  		System.out.println("zi method");
  	}
  }

  class Test1Demo {
  	public static void main(String[] args) {
  		Fu f = new Zi();
  		f.method();
  		f.show();
  	}
  }

B:看下面程序是否有问题，如果没有，说出结果

  class A {
  	public void show() {
  		show2();
  	}
  	public void show2() {
  		System.out.println("我");
  	}
  }
  class B extends A {
  	public void show() {
  		show2();
  	}
  	public void show2() {
  		System.out.println("爱");
  	}
  }
  class C extends B {
  	public void show() {
  		super.show();
  	}
  	public void show2() {
  		System.out.println("你");
  	}
  }
  public class Test2DuoTai {
  	public static void main(String[] args) {
  		A a = new B();
  		a.show();
  		
  		B b = new C();
  		b.show();
  	}
  }

###09.09_面向对象(抽象类的概述及其特点)

A:抽象类概述
- 抽象就是看不懂的，不确定的意思；
B:抽象类特点
- a:抽象类和抽象方法必须用abstract关键字修饰
  - abstract class 类名 {}
  - public abstract void eat();
- b:抽象类不一定有抽象方法，有抽象方法的类一定是抽象类或者是接口
- c:抽象类不能实例化，那么抽象类如何实例化呢?
  - 按照多态的方式，由具体的子类实例化。其实这也是多态的一种，抽象类多态。
- d:抽象类的子类
  - 要么是抽象类
  - 要么重写抽象类中的所有抽象方法
C:案例演示
- 抽象类特点

###09.10_面向对象(抽象类的成员特点)

A:抽象类的成员特点
- a:成员变量：既可以是变量，也可以是常量。abstract是否可以修饰成员变量?不能修饰成员变量
- b:构造方法：有。
  - 用于子类访问父类数据的初始化。
- c:成员方法：既可以是抽象的，也可以是非抽象的。
B:案例演示
- 抽象类的成员特点
C:抽象类的成员方法特性：
- a:抽象方法强制要求子类做的事情。
- b:非抽象方法子类继承的事情，提高代码复用性。

###09.11_面向对象(葵花宝典)

案例演示
- 抽象类的作用

###09.12_面向对象(抽象类练习猫狗案例)

A:案例演示
- 具体事物：猫，狗
- 共性：姓名，年龄，吃饭
- 猫的特性:抓老鼠
- 狗的特性:看家

###09.13_面向对象(抽象类练习老师案例)

A:案例演示
- 具体事物：基础班老师，就业班老师
- 共性：姓名，年龄，讲课。
- 具体事物:基础班学生,就业班学生
- 共性:姓名,年龄,学习

###09.14_面向对象(抽象类练习员工案例)

A:案例演示
- 假如我们在开发一个系统时需要对程序员类进行设计，程序员包含3个属性：姓名、工号以及工资。
- 经理，除了含有程序员的属性外，另为还有一个奖金属性。
- 请使用继承的思想设计出程序员类和经理类。要求类中提供必要的方法进行属性访问。

###09.15_面向对象(抽象类中的面试题)

A:面试题1
- 一个抽象类如果没有抽象方法，可不可以定义为抽象类? 如果可以，有什么意义?
- 可以
- 这么做目的只有一个,就是不让创建本类对象,交给子类完成。
B:面试题2
- abstract不能和哪些关键字共存
- 修饰方法，不能和哪些修饰符一起使用
- static private final

###09.16_面向对象(接口的概述及其特点)

A:接口概述
- 从狭义的角度讲就是指java中的interface
- 从广义的角度讲对外提供规则的都是接口
- 接口是Java单继承的补充
B:接口特点
- a:接口用关键字interface表示
  - interface 接口名 {}
- b:类实现接口用implements表示
  - class 类名 implements 接口名 {}
- c:接口不能实例化
  - 那么，接口如何实例化呢?
  - 按照多态的方式来实例化。
- d:接口的子类
  - a:可以是抽象类。但是意义不大。
  - b:可以是具体类。要重写接口中的所有抽象方法。(推荐方案)
C:案例演示
- 接口特点

###09.17_面向对象(接口的成员特点)

A:接口成员特点
- 成员变量；只能是常量，并且是静态的并公共的。
  * 默认修饰符：public static final
  * 建议：自己手动给出。
- 构造方法：接口没有构造方法。
- 成员方法：只能是抽象方法。
  * 默认修饰符：public abstract
  * 建议：自己手动给出。
B:案例演示
- 接口成员特点

###09.18_面向对象(类与类,类与接口,接口与接口的关系)

A:类与类,类与接口,接口与接口的关系
- a:类与类：
  - 继承关系,只能单继承,可以多层继承。
- b:类与接口：
  - 实现关系,可以单实现,也可以多实现。
  - 并且还可以在继承一个类的同时实现多个接口。
- c:接口与接口：
  - 继承关系,可以单继承,也可以多继承。
B:案例演示
- 类与类,类与接口,接口与接口的关系

###09.19_面向对象(抽象类和接口的区别)

A:成员区别
- 抽象类：
  - 成员变量：可以变量，也可以常量
  - 构造方法：有
  - 成员方法：可以抽象，也可以非抽象
- 接口：
  - 成员变量：只可以常量
  - 成员方法：只可以抽象
B:关系区别
- 类与类
  - 继承，单继承
- 类与接口
  - 实现，单实现，多实现
- 接口与接口
  - 继承，单继承，多继承
C:设计理念区别
- 抽象类被继承体现的是：”is a”的关系。抽象类中定义的是该继承体系的共性功能。
- 接口被实现体现的是：”like a”的关系。接口中定义的是该继承体系的扩展功能。

###09.20_面向对象(猫狗案例加入跳高功能分析及其代码实现)

A:案例演示
- 动物类：姓名，年龄，吃饭，睡觉。
- 猫和狗
- 动物培训接口：跳高

Mr__Lemon

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
面向对象

###06.01_面向对象(面向对象思想概述)(了解)A:面向过程思想概述第一步第二步B:面向对象思想概述找对象(第一步,第二步)C:举例买煎饼果子洗衣服D:面向对象思想特点a:是一种更符合我们思想习惯的思想b:可以将复杂的事情简单化c:将我们从执行者变成了指挥者角色发生了转换E:面向对象开发就是不断的创建对象，使用对象，指挥对象做事...
复制链接

扫一扫