###06.01_面向对象(面向对象思想概述)(了解)
* A:面向过程思想概述
* 第一步
* 第二步
* B:面向对象思想概述
* 找对象(第一步,第二步)
*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:学生类
###06.04_面向对象(学生类的使用)(掌握)
* A:文件名问题
* 在一个java文件中写两个类：一个基本的类，一个测试类。
* 建议：文件名称和测试类名称一致。
* B:如何使用对象?
* 创建对象并使用
* 格式：类名 对象名 = new 类名();
* D:如何使用成员变量呢?
* 对象名.变量名
* E:如何使用成员方法呢?
* 对象名.方法名(...)
###06.05_面向对象(成员变量和局部变量的区别)(掌握)
* A:在类中的位置不同
* 成员变量：在类中方法外
* 局部变量：在方法定义中或者方法声明上
* B:在内存中的位置不同
* 成员变量：在堆内存(成员变量属于对象,对象进堆内存)
* 局部变量：在栈内存(局部变量属于方法,方法进栈内存)
* C:生命周期不同
* 成员变量：随着对象的创建而存在，随着对象的消失而消失
* 局部变量：随着方法的调用而存在，随着方法的调用完毕而消失
* D:初始化值不同
* 成员变量：有默认初始化值
* 局部变量：没有默认初始化值，必须定义，赋值，然后才能使用。
* 注意事项：
* 局部变量名称可以和成员变量名称一样，在方法中使用的时候，采用的是就近原则。
* 基本数据类型变量包括哪些:byte,short,int,long,float,double,boolean,char
* 引用数据类型变量包括哪些:数组,类,接口,枚举
###06.06_面向对象(方法的形式参数是类名的时候如何调用)(掌握)
* 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:学生练习
* 请把手机类写成一个标准类，然后创建对象测试功能。
package com.foudation.eclipse;
public class Demo_Phone {
public static void main(String[] args) {
Phone p1 = new Phone();
Phone p2 = new Phone();
p1.setPrice(5288);
p1.setBrand("三星");
p2.setPrice(1300);
p1.setBrand("vivo");
System.out.println(p1.getBrand() + "..." + p1.getPrice() );
p1.call();
p1.sendMessage();
p1.playGame();
}
}
class Phone{
private int price;
private String brand;
public int getPrice() {
return price;
}
public void setPrice(int price) {
this.price = price;
}
public String getBrand() {
return brand;
}
public void setBrand(String brand) {
this.brand = brand;
}
public void call(){
System.out.println("打电话");
}
public void sendMessage(){
System.out.println("发短信");
}
public void playGame(){
System.out.println("打游戏");
}
###06.17_面向对象(构造方法Constructor概述和格式)(掌握)
* A:构造方法概述和作用
* 给对象的数据(属性)进行初始化
* B:构造方法格式特点
* a:方法名与类名相同(大小也要与类名一致)
* b:没有返回值类型，连void都没有
* c:没有具体的返回值 格式：return;
###06.18_面向对象(构造方法的重载及注意事项)(掌握)
* A:案例演示
* 构造方法的重载
* 重载:方法名相同,与返回值类型无关(构造方法没有返回值),只看参数列表
* B:构造方法注意事项
* a:如果我们没有给出构造方法，系统将自动提供一个无参构造方法。
* b:如果我们给出了构造方法，系统将不再提供默认的无参构造方法。
* 注意：这个时候，如果我们还想使用无参构造方法，就必须自己给出。建议永远自己给出无参构造方法
###06.19_面向对象(给成员变量赋值的两种方式的区别)
* A:setXxx()方法
* 修改属性值
* B:构造方法
* 给对象中属性进行初始化
###06.20_面向对象(学生类的代码及测试)(掌握)
* A:案例演示
* 学生类：
* 成员变量：
* name，age
* 构造方法：
* 无参，带两个参
* 成员方法：
* getXxx()/setXxx()
* show()：输出该类的所有成员变量值
* B:给成员变量赋值：
* a:setXxx()方法
* b:构造方法
* C:输出成员变量值的方式：
* a:通过getXxx()分别获取然后拼接
* b:通过调用show()方法搞定
###06.21_面向对象(手机类的代码及测试)(掌握)
* A:案例演示
* 模仿学生类，完成手机类代码
###06.22_面向对象(创建一个对象的步骤)(掌握)
* A:画图演示
* 画图说明一个对象的创建过程做了哪些事情?
* Student s = new Student();
* 1,Student.class加载进内存
* 2,声明一个Student类型引用s
* 3,在堆内存创建对象,
* 4,给对象中属性默认初始化值
* 5,属性进行显示初始化
* 6,构造方法进栈,对对象中的属性赋值,构造方法弹栈
* 7,将对象的地址值赋值给s
###06.23_面向对象(长方形案例练习)(掌握)
* A:案例演示
* 需求：
* 定义一个长方形类,定义 求周长和面积的方法，
* 然后定义一个测试类进行测试。
###06.24_面向对象(员工类案例练习)(掌握)
* A:案例演示
* 需求：定义一个员工类Employee
* 自己分析出几个成员，然后给出成员变量
* 姓名name,工号id,工资salary
* 构造方法，
* 空参和有参的
* getXxx()setXxx()方法，
* 以及一个显示所有成员信息的方法。并测试。
* work
###06.25_面向对象(static关键字及内存图)(了解)
* A:案例演示
* 通过一个案例引入static关键字。
* 人类：Person。每个人都有国籍，中国。
* B:画图演示
* 带有static的内存图
###06.26_面向对象(static关键字的特点)(掌握)
* A:static关键字的特点
* a:随着类的加载而加载
* b:优先于对象存在
* c:被类的所有对象共享
* 举例：咱们班级的学生应该共用同一个班级编号。
* 其实这个特点也是在告诉我们什么时候使用静态?
* 如果某个成员变量是被所有对象共享的，那么它就应该定义为静态的。
* 举例：
* 饮水机(用静态修饰)
* 水杯(不能用静态修饰)
* 共性用静态,特性用非静态
* d:静态的都可以通过类名调用，非静态的不可以
* 其实它本身也可以通过对象名调用。
* 推荐使用类名调用。
* 静态修饰的内容一般我们称其为：与类相关的，类成员
* B:案例演示
* static关键字的特点
###06.27_面向对象(static的注意事项)(掌握)
* A:static的注意事项
* a:在静态方法中是没有this关键字的
* 如何理解呢?
* 静态是随着类的加载而加载，this是随着对象的创建而存在。
* 静态比对象先存在。
* b:静态方法只能访问静态的成员变量和静态的成员方法
* 静态方法：
* 成员变量：只能访问静态变量
* 成员方法：只能访问静态成员方法
* 非静态方法：
* 成员变量：可以是静态的，也可以是非静态的
* 成员方法：可是是静态的成员方法，也可以是非静态的成员方法。
* 简单记：
* 静态只能访问静态。
* B:案例演示
###06.28_面向对象(静态变量和成员变量的区别)(掌握)
* 静态变量也叫类变量 成员变量也叫对象变量
* A:所属不同
* 静态变量属于类，所以也称为为类变量
* 成员变量属于对象，所以也称为实例变量(对象变量)
* B:内存中位置不同
* 静态变量存储于方法区的静态区
* 成员变量存储于堆内存
* C:内存出现时间不同
* 静态变量随着类的加载而加载，随着类的消失而消失
* 成员变量随着对象的创建而存在，随着对象的消失而消失
* D:调用不同
* 静态变量可以通过类名调用，也可以通过对象调用
* 成员变量只能通过对 象名调用
###06.29_面向对象(main方法的格式详细解释)(了解)
* A:格式
* public static void main(String[] args) {}
* B:针对格式的解释
* public 被jvm调用，访问权限足够大。
* static 被jvm调用，不用创建对象，直接类名访问
* void被jvm调用，不需要给jvm返回值
* main 一个通用的名称，虽然不是关键字，但是被jvm识别
* String[] args 以前用于接收键盘录入的
* C:演示案例
* 通过args接收键盘例如数据
###06.30_面向对象(工具类中使用静态)(了解)
* A:制作一个工具类
* ArrayTool
* 1,获取最大值
* 2,数组的遍历
* 3,数组的反转
###06.30_面向对象(说明书的制作过程)(了解)
* A:对工具类加入文档注释
* B:通过javadoc命令生成说明书
* @author(提取作者内容)
* @version(提取版本内容)
* javadoc -d 指定的文件目录 -author -version ArrayTool.java
* @param 参数名称//形式参数的变量名称@return 函数运行完返回的数据
###06.31_面向对象(如何使用JDK提供的帮助文档)(了解)
* A:找到文档，打开文档
* B:点击显示，找到索引，出现输入框
* C:你应该知道你找谁?举例：Scanner
* D:看这个类的结构(需不需要导包)
* 成员变量 字段
* 构造方法 构造方法
* 成员方法 方法
###06.32_面向对象(学习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;
###06.33_面向对象(猜数字小游戏案例)(了解)
* A:案例演示
* 需求：猜数字小游戏(数据在1-100之间)
###06.34_面向对象(代码块的概述和分类)(了解)(面试的时候会问,开发不用或者很少用)
* A:代码块概述
* 在Java中，使用{}括起来的代码被称为代码块。
* B:代码块分类
* 根据其位置和声明的不同，可以分为局部代码块，构造代码块，静态代码块，同步代码块(多线程讲解)。
* C:常见代码块的应用
* a:局部代码块
* 在方法中出现；限定变量生命周期，及早释放，提高内存利用率
* b:构造代码块 (初始化块)
* 在类中方法外出现；多个构造方法方法中相同的代码存放到一起，每次调用构造都执行，并且在构造方法前执行
* c:静态代码块
* 在类中方法外出现，并加上static修饰；用于给类进行初始化，在加载的时候就执行，并且只执行一次。
* 一般用于加载驱动
###06.35_面向对象(代码块的面试题)(掌握)
* 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();
}
}###06.36_面向对象(继承案例演示)(掌握)
* A:继承(extends)
* 让类与类之间产生关系,子父类关系
* B:继承案例演示：
* 动物类,猫类,狗类
* 定义两个属性(颜色,腿的个数)两个功能(吃饭，睡觉)
* C:案例演示
* 使用继承前
* D:案例演示
* 使用继承后
###06.37_面向对象(继承的好处和弊端)(掌握)
* A:继承的好处
* a:提高了代码的复用性
* b:提高了代码的维护性
* c:让类与类之间产生了关系，是多态的前提
* B:继承的弊端
* 类的耦合性增强了。
* 开发的原则：高内聚，低耦合。
* 耦合：类与类的关系
* 内聚：就是自己完成某件事情的能力
###06.38_面向对象(Java中类的继承特点)(掌握)
* A:Java中类的继承特点
* a:Java只支持单继承，不支持多继承。(一个儿子只能有一个爹)
* 有些语言是支持多继承，格式：extends 类1,类2,...
* b:Java支持多层继承(继承体系)
* B:案例演示
* Java中类的继承特点
* 如果想用这个体系的所有功能用最底层的类创建对象
* 如果想看这个体系的共性功能,看最顶层的类
###06.40_面向对象(继承的注意事项和什么时候使用继承)(掌握)
* A:继承的注意事项
* a:子类只能继承父类所有非私有的成员(成员方法和成员变量)
* b:子类不能继承父类的构造方法，但是可以通过super(马上讲)关键字去访问父类构造方法。
* c:不要为了部分功能而去继承
* 项目经理 姓名 工号 工资 奖金
* 程序员 姓名 工号 工资
* B:什么时候使用继承
* 继承其实体现的是一种关系："is a"。
Person
Student
Teacher
水果
苹果
香蕉
橘子
采用假设法。
如果有两个类A,B。只有他们符合A是B的一种，或者B是A的一种，就可以考虑使用继承。
###06.41_面向对象(继承中成员变量的关系)(掌握)
* A:案例演示
* a:不同名的变量
* b:同名的变量
###06.42_面向对象(this和super的区别和应用)(掌握)
* A:this和super都代表什么
* this:代表当前对象的引用,谁来调用我,我就代表谁
* super:代表当前对象父类的引用
* B:this和super的使用区别
* a:调用成员变量
* this.成员变量 调用本类的成员变量,也可以调用父类的成员变量
* super.成员变量 调用父类的成员变量
* b:调用构造方法
* this(...) 调用本类的构造方法
* super(...) 调用父类的构造方法
* c:调用成员方法
* this.成员方法 调用本类的成员方法,也可以调用父类的方法
* super.成员方法 调用父类的成员方法
###06.43_面向对象(继承中构造方法的关系)(掌握)
* A:案例演示
* 子类中所有的构造方法默认都会访问父类中空参数的构造方法
* B:为什么呢?
* 因为子类会继承父类中的数据，可能还会使用父类的数据。
* 所以，子类初始化之前，一定要先完成父类数据的初始化。
* 其实：
* 每一个构造方法的第一条语句默认都是：super() Object类最顶层的父类。
###06.44_面向对象(继承中构造方法的注意事项)(掌握)
* A:案例演示
* 父类没有无参构造方法,子类怎么办?
* super解决
* this
不能同时调用
* B:注意事项
* super(…)或者this(….)必须出现在构造方法的第一条语句上，不能同时调用
###06.45_面向对象(继承中的面试题)(掌握)
* 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);//30
System.out.println(this.num);//20
System.out.println(super.num);//10
}
}
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();
###06.46_面向对象(继承中成员方法关系)(掌握)
* A:案例演示
* a:不同名的方法
* b:同名的方法（重写） 调用子类的方法
此时如果想要调用父类的同名方法，使用super.方法名（）
###06.47_面向对象(方法重写概述及其应用)(掌握)
* A:什么是方法重写
* 重写:子父类出现了一模一样的方法(注意:返回值类型可以是子父类,这个我们学完面向对象讲)
* B:方法重写的应用：
* 当子类需要父类的功能，而功能主体子类有自己特有内容时，可以重写父类中的方法。这样，即沿袭了父类的功能，又定义了子类特有的内容。
* C:案例演示
* a:定义一个手机类。
###06.48_面向对象(方法重写的注意事项)(掌握)
* A:方法重写注意事项
* a:父类中私有方法不能被重写
* 因为父类私有方法子类根本就无法继承
* b:子类重写父类方法时，访问权限不能更低
* 最好就一致
* c:父类静态方法，子类也必须通过静态方法进行重写
* 其实这个算不上方法重写，但是现象确实如此，至于为什么算不上方法重写，多态中我会讲解(静态只能覆盖静态)
* 子类重写父类方法的时候，最好声明一模一样。
* B:案例演示
* 方法重写注意事项
###06.49_面向对象(方法重写的面试题)(掌握)
* A:方法重写的面试题
* Override和Overload的区别?Overload能改变返回值类型吗?
* overload可以改变返回值类型,只看参数列表
* 方法重写：子类中出现了和父类中方法声明一模一样的方法。与返回值类型有关,返回值是一致(或者是子父类)的
* 方法重载：本类中出现的方法名一样，参数列表不同的方法。与返回值类型无关。
* 子类对象调用方法的时候：
* 先找子类本身，再找父类。
###08.16_面向对象(使用继承前的学生和老师案例)(掌握)
* A:案例演示
* 使用继承前的学生和老师案例
* 属性:姓名,年龄
* 行为:吃饭
* 老师有特有的方法:讲课
* 学生有特有的方法:学习
###06.50_面向对象(使用继承后的学生和老师案例)(掌握)
* A:案例演示
* 使用继承后的学生和老师案例
###06.51_面向对象(猫狗案例分析,实现及测试)(掌握)
* A:猫狗案例分析
* B:案例演示
* 猫狗案例继承版
* 属性:毛的颜色,腿的个数
* 行为:吃饭
* 猫特有行为:抓老鼠catchMouse
* 狗特有行为:看家lookHome
###06.52_面向对象(final关键字修饰类,方法以及变量的特点)(掌握)
* A:final概述
* B:final修饰特点
* 修饰类，类不能被继承
* 修饰变量，变量就变成了常量，只能被赋值一次
* 修饰方法，方法不能被重写
* C:案例演示
* final修饰特点
###06.53_面向对象(final关键字修饰局部变量)(掌握)
* A:案例演示
* 方法内部或者方法声明上都演示一下(了解)
* 基本类型，是值不能被改变
* 引用类型，是地址值不能被改变,对象中的属性可以改变
###06.54_面向对象(final修饰变量的初始化时机)(掌握)
* A:final修饰变量的初始化时机
* 显示初始化
* 在对象构造完毕前即可
91
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
