面向对象

zoukankan html css js c++ java

面向对象
文章目录
06.01_面向对象(面向对象思想概述)(了解)
06.02_面向对象(类与对象概述)(掌握)
06.03_面向对象(学生类的定义)(掌握)
06.04_面向对象(手机类的定义)(掌握)
06.05_面向对象(学生类的使用)(掌握)
06.06_面向对象(手机类的使用)(掌握)
06.07_面向对象(一个对象的内存图)(掌握)
06.08_面向对象(二个对象的内存图)(了解)
06.10_面向对象(成员变量和局部变量的区别)(掌握)
06.11_面向对象(方法的形式参数是类名的时候如何调用)(掌握)
06.12_面向对象(匿名对象的概述和应用)(掌握)
06.13_面向对象(封装的概述)(掌握)
06.14_面向对象(private关键字的概述和特点)(掌握)
06.15_面向对象(this关键字的概述和应用)(掌握)
06.16_面向对象(手机类代码及其测试)(掌握)
06.17_day06总结
09.13_面向对象(抽象类练习老师案例)
09.14_面向对象(抽象类练习员工案例)
09.15_面向对象(抽象类中的面试题)
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关键字特点
  
  代表当前对象的引用（代表本来对象的引用/指代）
  
  this的本质是一个对象
  
  在每一个普通方法里，都有一个this，谁调用这个方法，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("玩游戏");
	}
}
```
06.17_day06总结
- 理解面向对象思想的由来：基于面向过程
  
  思想特点
- 类和对象
  
  对象是现实生活中的事物；
  
  类是Java语言中抽象的概念：属性和行为的集合；
  
  属性：对象的外在描述信息（学生的姓名、年龄等）
  
  对应类中的成员变量：定义在方法外、类中
  
  行为：对象能做什么（学生能学习、能吃饭、能睡觉）
  
  对应类中的成员方法：去掉static
- 类的定义和使用（重点掌握）：
  
  类的使用：
  
  创建对象： Student s = new Student();
  
  调用属性： s.name = “凤姐”;…
  
  调用方法： s.study();
- 成员变量和局部变量的区别：
  
  定义位置不同：
  
  成员变量：类中，方法外
  
  局部变量：方法中，或方法的声明上，即参数
  
  存储位置不同：
  
  成员变量：堆内存
  
  局部变量：栈内存
  
  生命周期不同：
  
  成员变量：随着对象的存在而存在
  
  局部变量：随着方法调用而存在，调用完毕而消失
  
  初始化值不同：
  
  成员变量：有（为什么？）
  
  局部变量：没有
  
  成员变量和局部变量重名：就近原则
- 匿名对象：就是没有名字的对象
  
  用法：
  
  只调用一次
  
  作为实际参数传递给方法
- 封装
  
  概念：隐藏对象的属性（private）和实现细节，仅对外提供公共的访问方式（get/set）
  
  private:只能在本类中访问（封装不仅仅体现在private上）
  
  this：是本类对象的引用。
  
  重点：this本质是对象（super），this用在方法中，代表调用该方法的对象
  
  用法：区分成员变量和局部变量
  
  Phone类的标准代码：不看任何代码能够自己写出来。
###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:案例演示
  
  需求：
  
  定义一个长方形类,定义求周长和面积的方法，
  
  然后定义一个测试类进行测试。
###07.08_面向对象(员工类案例练习)(掌握)
- A:案例演示
  
  需求：定义一个员工类Employee
  
  自己分析出几个成员，然后给出成员变量
  
  姓名name,工号id,工资salary
  
  构造方法，
  
  空参和有参的
  
  getXxx()setXxx()方法，
  
  以及一个显示所有成员信息的方法。并测试。
  
  work
###07.09_面向对象(static关键字及内存图)(了解)
- A:案例演示
  
  通过一个案例引入static关键字。
  
  人类：Person。每个人都有国籍，中国。
- B:画图演示
  
  带有static的内存图
###07.10_面向对象(static关键字的特点)(掌握)
Java中的static关键字解析
 static class 静态类
- 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之间)
###07.19_day07总结
- 构造方法：
  
  特点：
  
  方法名与类名相同
  
  没有返回值，也没有返回值类型
  
  注意事项：
  
  如果一个类中没有构造方法，那么系统默认提供一个无参构造；如果我们写了一个构造，系统将不再提供。
  
  作用：给对象进行初始化，而不是创建对象
- static
  
  最大的特点：被所有对象共享；
  
  调用方式：用类名调用（可以用对象调用，不推荐，如果你这样用，一定会挨骂）
  
  加载方式：随着类的加载而加载；
  
  优先于对象而存在
- API：（应用程序编程接口；文档；帮助文档；Java文档）
  
  Application Programming Interface
  
  命令：javadoc
  
  使用：
  
  找到索引；
  
  在下面的文本框输入要找的类，可以不输入完；
  
  敲回车，敲回车；
  
  查看该类所属的包，注：java.lang包不需要导包，其它都要导包；
  
  看类的说明，了解这个类是做什么的；
  
  看构造方法，了解如何创建对象；
  
  看方法摘要：
  
  左边是方法的修饰符和返回值类型
  
  右边是方法名和方法的描述
###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();
	}
}
```
###08.03_面向对象(继承案例演示)(掌握)
- A:继承(extends)
  
  让类与类之间产生关系,子父类关系
- B:继承案例演示：
  
  动物类,猫类,狗类
  
  定义两个属性(颜色,腿的个数)两个功能(吃饭，睡觉)
- C:案例演示
  
  使用继承前
- D:案例演示
  
  使用继承后
###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:代表当前对象父类的引用（代表父类内存空间的标识，代表子类对象中存储父类成员的内存空间）
- B:this和super的使用区别
  
  a:调用成员变量
  
  this.成员变量调用本类的成员变量,也可以调用父类的成员变量
  
  super.成员变量调用父类的成员变量
  
  b:调用构造方法
  
  this(…) 调用本类的构造方法
  
  super(…) 调用父类的构造方法
  
  c:调用成员方法
  
  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修饰变量的初始化时机
  
  显示初始化
  
  在对象构造完毕前即可
###08.22_day08总结
- 子父类继承关系中，构造代码块、静态代码块、构造方法执行次序：
  
  静态优先于非静态；
  
  父类优先于子类；
  
  构造代码块优先于构造方法；
- 继承：
  
  概念：没有官方说法，可以用以下方式来回答：
  
  实际开发中是如何使用继承的
  A:想要使用已知类中的部分功能，这个时候可以继承的方式让两个类产生关系，被继承的类叫父类，继承的类叫子类，子类拥有父类所有非私有成员；
  B:抽取多个已知类中的共同的内容，把它们放到一个类中，这个类就是父类，让已知类通过继承和父类产生关系，所有已知类就拥有父类所有非私有成员。以后再定义新的类，让新类继承自父类，新类也拥有父类所有非私有成员；
  
  特点：
  
  注意事项：
  
  定义继承的原则：is a
- this和super的区别：
  
  最大的区别：this是对象，super是父类内存空间的标识
  
  用法上的区别：this调用成员变量或方法时从当前类的成员位置开始找，super从父类成员位置开始找；
- 方法重写：
  
  子父类继承关系中，子类出现了和父类方法声明相同的情况，我们就说子类方法重写了父类的方法，或者叫覆盖、复写了父类的方法；
  
  注意事项：
  
  A:子类方法的访问权限要大于等于父类方法访问权限；
  
  B:异常：子类不能抛出比父类更大的异常；
  
  常见面试题：
  
  重写和重载的区别？
  （答：罗列二者概念即可）
- 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;向下转型
  ###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 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不能和哪些关键字共存
###09.16_面向对象(接口的概述及其特点)
- A:接口概述
  
  从狭义的角度讲就是指java中的interface
  
  从广义的角度讲对外提供规则（标准、功能）的都是接口
- 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:案例演示
  
  动物类：姓名，年龄，吃饭，睡觉。
  
  猫和狗
  
  动物培训接口：跳高
###09.21_day09总结
- 多态：
  
  两种表现形式：方法重写；方法重载；
  
  概念：（同一个对象响应不同消息的能力）
  
  前提：
  A:要有继承或实现关系；
  B:要有方法重写；
  C:要有父类（父接口）引用指向子类对象；
- 抽象类：
  有抽象方法的类就是抽象类。
  抽象方法的由来：当我们不明确方法的具体实现的时候，就。。
  特点：抽象类不能被实例化
  成员变量，成员方法，构造方法
- 接口：
  定义关键字，实现关键字
  接口就是特殊的抽象类
- 抽象类和接口的区别：
  A:成员
  B:关系
  C:设计理念：
  抽象类：共性内容
  接口：扩展功能
###10.01_面向对象(package关键字的概述及作用)(了解)
- A:为什么要有包
  
  将字节码(.class)进行分类存放
  
  包其实就是文件夹
- B:包的概述
- 举例：
  学生：增加，删除，修改，查询
  老师：增加，删除，修改，查询
  …
  
  方案1：按照功能分 com.heima.add AddStudent AddTeacher com.heima.delete DeleteStudent DeleteTeacher com.heima.update UpdateStudent UpdateTeacher com.heima.find FindStudent FindTeacher 方案2：按照模块分 com.heima.teacher AddTeacher DeleteTeacher UpdateTeacher FindTeacher com.heima.student AddStudent DeleteStudent UpdateStudent FindStudent
###10.02_面向对象(包的定义及注意事项)(掌握)
- A:定义包的格式
  
  package 包名;
  
  多级包用.分开即可
- B:定义包的注意事项
  
  A:package语句必须是程序的第一条可执行的代码
  
  B:package语句在一个java文件中只能有一个
  
  C:如果没有package，默认表示无包名
- C:案例演示
  
  包的定义及注意事项
###10.03_面向对象(带包的类编译和运行)(掌握)
- A:如何编译运行带包的类
  
  a:javac编译的时候带上-d即可
  
  javac -d . HelloWorld.java
  
  b:通过java命令执行。
  
  java 包名.HellWord
  ###10.04_面向对象(不同包下类之间的访问)(掌握)
- A:案例演示
  
  不同包下类之间的访问
###10.05_面向对象(import关键字的概述和使用)(掌握)
- A:案例演示
  
  为什么要有import
  
  其实就是让有包的类对调用者可见,不用写全类名了
- B:导包格式
  
  import 包名;
  
  注意：
  
  这种方式导入是到类的名称。
  
  虽然可以最后写*，但是不建议。
- C:package,import,class有没有顺序关系(面试题)
###10.06_面向对象(四种权限修饰符的测试)(掌握)
- A:案例演示
  
  四种权限修饰符
- B:结论
- 本类同一个包下(子类和无关类) 不同包下(子类) 不同包下(无关类) private Y 默认 Y Y protected Y Y Y public Y Y Y Y
###10.07_面向对象(类及其组成所使用的常见修饰符)(掌握)
- A:修饰符：
  
  权限修饰符：private，默认的，protected，public
  
  状态修饰符：static，final
  
  抽象修饰符：abstract
- B:类：
  
  权限修饰符：默认修饰符，public
  
  状态修饰符：final
  
  抽象修饰符：abstract
  
  用的最多的就是：public
- C:成员变量：
  
  权限修饰符：private，默认的，protected，public
  
  状态修饰符：static，final
  
  用的最多的就是：private
- D:构造方法：
  
  权限修饰符：private，默认的，protected，public
  
  用的最多的就是：public
- E:成员方法：
  
  权限修饰符：private，默认的，protected，public
  
  状态修饰符：static，final
  
  抽象修饰符：abstract
  
  用的最多的就是：public
- F:除此以外的组合规则：
  
  成员变量：public static final
  
  成员方法：
  
  public static
  
  public abstract
  
  public final
###10.08_面向对象(内部类概述和访问特点)(了解)
- A:内部类概述
- B:内部类访问特点
  
  a:内部类可以直接访问外部类的成员，包括私有。
  
  b:外部类要访问内部类的成员，必须创建对象。
  
  外部类名.内部类名对象名 = 外部类对象.内部类对象;
- C:案例演示
  
  内部类极其访问特点
###10.09_面向对象(成员内部类私有使用)(了解)
- private
###10.10_面向对象(静态成员内部类)(了解)
- static
- B:成员内部类被静态修饰后的访问方式是:
  
  外部类名.内部类名对象名 = 外部类名.内部类对象;
###10.11_面向对象(成员内部类的面试题)(掌握)
- A:面试题
- 要求：使用已知的变量，在控制台输出30，20，10。
```
class Outer {
	public int num = 10;
	class Inner {
		public int num = 20;
		public void show() {
			int num = 30;
			System.out.println(?);
			System.out.println(??);
			System.out.println(???);
		}
	}
}
class InnerClassTest {
	public static void main(String[] args) {
		Outer.Inner oi = new Outer().new Inner();
		oi.show();
	}	
}
```
###10.12_面向对象(局部内部类访问局部变量的问题)(掌握)
- A:案例演示
  
  局部内部类访问局部变量必须用final修饰
  
  局部内部类在访问他所在方法中的局部变量必须用final修饰,为什么?
  因为当调用这个方法时,局部变量如果没有用final修饰,他的生命周期和方法的生命周期是一样的,当方法弹栈,这个局部变量也会消失,那么如果局部内部类对象还没有马上消失想用这个局部变量,就没有了,如果用final修饰会在类加载的时候进入常量池,即使方法弹栈,常量池的常量还在,也可以继续使用
  
  但是jdk1.8取消了这个事情,所以我认为这是个bug
###10.13_面向对象(匿名内部类的格式和理解)
- A:匿名内部类
  
  就是内部类的简化写法。
- B:前提：存在一个类或者接口
  
  这里的类可以是具体类也可以是抽象类。
- C:格式：
- new 类名或者接口名(){ 重写方法; }
- D:本质是什么呢?
  
  是一个继承了该类或者实现了该接口的子类匿名对象。
- E:案例演示
  
  按照要求来一个匿名内部类
###10.14_面向对象(匿名内部类重写多个方法调用)
- A:案例演示
  
  匿名内部类的方法调用
###10.15_面向对象(匿名内部类在开发中的应用)
- A:代码如下
```
//这里写抽象类，接口都行
abstract class Person {
	public abstract void show();
}

class PersonDemo {
	public void method(Person p) {
		p.show();
	}
}

class PersonTest {
	public static void main(String[] args) {
		//如何调用PersonDemo中的method方法呢?
		PersonDemo pd = new PersonDemo ();
		
	}
}
```
###10.16_面向对象(匿名内部类的面试题)

###10.今天知识点总结
查看全文

相关阅读:
定义函数
 变量与常量
 字符串与格式化
 字符串与编码
 字符编码
 元组-tuple
列表-list
分支和循环
 润乾配置连接kingbase（金仓）数据库
 润乾报表在proxool应用下的数据源配置

原文地址：https://www.cnblogs.com/hoonick/p/9820788.html

热门文章
调优
 mysql-jdbc connector
bi的tableau
CDH日常运维
 aws S3
ucloud建新主机
 hdfs-yarn大数据常用命令
 CDH5.X文档
 CDH6.2官方文档
 位置参数

文章目录

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

06.17_day06总结

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

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

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