面向对象

定义

    面向对象是基于面向过程的编程思想

面向对象的思想特点

    A:是一种更符合我们思考习惯的思想
    B:把复杂的事情简单化
    C:让我们从执行者变成了指挥者

    举例：
        买电脑
        洗衣服
        做饭
        ...
        万事万物皆对象

把大象装进冰箱(理解)

    A:面向过程实现
    B:面向对象实现

    注意：如何让我们的操作更符合面向对象思想呢?
    A:有哪些类
    B:每个类有哪些成员
    C:类与类的关系

类与对象

    A:现实世界的事物
        属性  事物的基本描述
        行为  事物的功能
    B:Java语言中最基本的单位是类。所以，我们要用类来体现事物
    C:类
        成员变量    事物属性
        成员方法    事物行为
    D:类：是一组相关的属性和行为的集合。是一个抽象的概念。
      对象：是该类事物的具体存在，是一个具体的实例。(对象)

      举例：
        学生：类
        班长：对象

类的定义及使用

    A:类的定义
        成员变量    定义格式和以前一样，就是位置不同，在类中，方法外。
        成员方法    定义格式和以前一样，就是去掉了static。
    B:使用类的内容
        a:创建对象? 格式
            类名 对象名 =  new 类名();
        b:如何使用成员变量和成员方法呢
            对象名.成员变量
            对象名.成员方法()

案例：

    A:学生类的定义和使用
    B:手机类的定义和使用

内存图

    A:一个对象的内存图
    B:二个对象的内存图
    C:三个对象的内存图

Java程序的开发，设计和特征

    A:开发：就是不断的创建对象，通过对象调用功能
    B:设计：就是管理和维护对象间的关系
    C:特征
        a:封装
        b:继承
        c:多态

成员变量和局部变量的区别(理解)

(1)在类中的位置不同
    成员变量：类中方法外
    局部变量：方法定义中或者方法声明上
(2)在内存中的位置不同
    成员变量：在堆中
    局部变量：在栈中
(3)生命周期不同
    成员变量：随着对象的创建而存在，随着对象的消失而消失
    局部变量：随着方法的调用而存在，随着方法的调用完毕而消失
(4)初始化值不同
    成员变量：有默认值
    局部变量：没有默认值，必须定义，赋值，然后才能使用

类作为形式参数的问题?(理解)

(1)如果你看到一个方法需要的参数是一个类名，就应该知道这里实际需要的是一个具体的对象。

匿名对象(理解)

(1)没有名字的对象
(2)应用场景
    A:调用方法，仅仅只调用一次的时候。
    b:可以作为实际参数传递。

封装(理解)

(1)隐藏实现细节，提供公共的访问方式
(2)好处：
    A:隐藏实现细节，提供公共的访问方式
    B:提高代码的复用性
    C:提高代码的安全性
(3)设计原则
    把不想让外界知道的实现细节给隐藏起来，提供公共的访问方式
(4)private是封装的一种体现。
    封装：类，方法，private修饰成员变量

private关键字(掌握)

(1)私有的意义，可以修饰成员变量和成员方法
(2)特点：
    被private修饰的后的成员只能在本类中被访问
(3)private的应用：
    以后再写一个类的时候：
        把所有的成员变量给private了
        提供对应的getXxx()/setXxx()方法

this关键字(掌握)

(1)代表当前类的引用对象
    记住：哪个对象调用方法，该方法内部的this就代表那个对象
(2)this的应用场景：
    A:解决了局部变量隐藏成员变量的问题
    B:其实this还有其他的应用，明天讲解。

构造方法(掌握)

作用：用于对对象的数据进行初始化

格式：

    A:方法名和类名相同
    B:没有返回值类型，连void都不能有
    C:没有返回值

    思考题：构造方法中可不可以有return语句呢?
    可以。而是我们写成这个样子就OK了：return;
    其实，在任何的void类型的方法的最后你都可以写上：return;

构造方法的注意事项

    A:如果我们没写构造方法，系统将提供一个默认的无参构造方法
    B:如果我们给出了构造方法，系统将不再提供默认构造方法
        如果这个时候，我们要使用无参构造方法，就必须自己给出。
        推荐：永远手动自己给出无参构造方法。

给成员变量赋值的方式

    A:setXxx()
    B:带参构造方法

标准案例

    class Student {
        private String name;
        private int age;

        public Student(){}

        public Student(String name,int age) {
            this.name = name;
            this.age = age;
        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public int getAge() {
            return age;
        }

        public void setAge(int age) {
            this.age = age;
        }
    }

    测试：
    class StudentDemo {
        public static void main(String[] args) {
            //方式1
            Student s1 = new Student();
            s1.setName("林青霞");
            s1.setAge(27);
            System.out.println(s1.getName()+"---"+s1.getAge());

            //方式2
            Student s2 = new Student("刘意",30);
            System.out.println(s2.getName()+"---"+s2.getAge());
        }
    }

代码：Student s = new Student();做了哪些事情?(理解)

(1)把Student.class文件加载到内存
(2)在栈内存为s开辟空间
(3)在堆内存为学生对象申请空间
(4)给学生的成员变量进行默认初始化。null,0
(5)给学生的成员变量进行显示初始化。林青霞,27
(6)通过构造方法给成员变量进行初始化。刘意,30
(7)对象构造完毕，把地址赋值给s变量

面向对象的练习题(掌握)

(1)标准的手机类的定义和测试
(2)Demo类有求和方法，Test类进行测试。
    什么时候定义成员变量?
    当该变量是用来描述一个类的时候。
(3)长方形案例
(4)员工案例
(5)MyMath案例(自己提供加减乘除并测试)

static关键字(理解)

静态的意思。

 可以修饰成员变量和成员方法。

静态的特点：

    A:随着类的加载而加载
    B:优先与对象存在
    C:被类的所有对象共享
        这其实也是我们判断该不该使用静态的依据。
        举例：饮水机和水杯的问题思考
    D:可以通过类名调用
        既可以通过对象名调用，也可以通过类名调用，建议通过类名调用。

静态的内存图

    静态的内容在方法区的静态区

静态的注意事项；

    A:在静态方法中没有this对象
    B:静态只能访问静态(代码测试过)

静态变量和成员变量的区别

    A:所属不同
        静态变量：属于类，类变量
        成员变量：属于对象，对象变量，实例变量
    B:内存位置不同
        静态变量：方法区的静态区
        成员变量：堆内存
    C:生命周期不同
        静态变量：静态变量是随着类的加载而加载，随着类的消失而消失
        成员变量：成员变量是随着对象的创建而存在，随着对象的消失而消失
    D:调用不同
        静态变量：可以通过对象名调用，也可以通过类名调用
        成员变量：只能通过对象名调用

main方法是静态的

    public:权限最大
    static:不用创建对象调用
    void:返回值给jvm没有意义
    main:就是一个常见的名称。
    String[] args:可以接收数据，提供程序的灵活性
        格式：java MainDemo hello world java
              java MainDemo 10 20 30

final关键字(掌握)

(1)是最终的意思，可以修饰类，方法，变量。
(2)特点：
    A:它修饰的类，不能被继承。
    B:它修饰的方法，不能被重写。
    C:它修饰的变量，是一个常量。
(3)面试相关：
    A:局部变量
        a:基本类型 值不能发生改变
        b:引用类型 地址值不能发生改变，但是对象的内容是可以改变的
    B:初始化时机
        a:只能初始化一次。
        b:常见的给值
            定义的时候。(推荐)
            构造方法中。

多态(掌握)

同一个对象在不同时刻体现出来的不同状态。

多态的前提：

    A:有继承或者实现关系。
    B:有方法重写。
    C:有父类或者父接口引用指向子类对象。

    多态的分类：
        a:具体类多态
            class Fu {}
            class Zi extends Fu {}

            Fu f = new Zi();
        b:抽象类多态
            abstract class Fu {}
            class Zi extends Fu {}

            Fu f = new Zi();
        c:接口多态
            interface Fu {}
            class Zi implements Fu {}

            Fu f = new Zi();

多态中的成员访问特点

    A:成员变量
        编译看左边，运行看左边
    B:构造方法
        子类的构造都会默认访问父类构造
    C:成员方法
        编译看左边，运行看右边
    D:静态方法
        编译看左边，运行看左边

    为什么?
        因为成员方法有重写。

多态的好处：

    A:提高代码的维护性(继承体现)
    B:提高代码的扩展性(多态体现)

多态的弊端：

    父不能使用子的特有功能。

    现象：
        子可以当作父使用，父不能当作子使用。

多态中的转型

    A:向上转型
        从子到父
    B:向下转型
        从父到子
(7)孔子装爹的案例帮助大家理解多态
(8)多态的练习
    A:猫狗案例
    B:老师和学生案例

抽象类(掌握)

(1)把多个共性的东西提取到一个类中，这是继承的做法。
   但是呢，这多个共性的东西，在有些时候，方法声明一样，但是方法体。
   也就是说，方法声明一样，但是每个具体的对象在具体实现的时候内容不一样。
   所以，我们在定义这些共性的方法的时候，就不能给出具体的方法体。
   而一个没有具体的方法体的方法是抽象的方法。
   在一个类中如果有抽象方法，该类必须定义为抽象类。
(2)抽象类的特点
    A:抽象类和抽象方法必须用关键字abstract修饰
    B:抽象类中不一定有抽象方法,但是有抽象方法的类一定是抽象类
    C:抽象类不能实例化
    D:抽象类的子类
        a:是一个抽象类。
        b:是一个具体类。这个类必须重写抽象类中的所有抽象方法。
(3)抽象类的成员特点：
    A:成员变量
        有变量，有常量
    B:构造方法
        有构造方法
    C:成员方法
        有抽象，有非抽象
(4)抽象类的练习
    A:猫狗案例练习
    B:老师案例练习
    C:学生案例练习
    D:员工案例练习
(5)抽象类的几个小问题
    A:抽象类有构造方法，不能实例化，那么构造方法有什么用?
        用于子类访问父类数据的初始化
    B:一个类如果没有抽象方法,却定义为了抽象类，有什么用?
        为了不让创建对象
    C:abstract不能和哪些关键字共存
        a:final 冲突
        b:private 冲突
        c:static 无意义

接口(掌握)

引入

回顾猫狗案例，它们仅仅提供一些基本功能。
   比如：猫钻火圈，狗跳高等功能，不是动物本身就具备的，
   是在后面的培养中训练出来的，这种额外的功能，java提供了接口表示。

接口的特点：

    A:接口用关键字interface修饰
        interface 接口名 {}
    B:类实现接口用implements修饰
        class 类名 implements 接口名 {}
    C:接口不能实例化
    D:接口的实现类
        a:是一个抽象类。
        b:是一个具体类，这个类必须重写接口中的所有抽象方法。

接口的成员特点：

    A:成员变量
        只能是常量
        默认修饰符：public static final
    B:构造方法
        没有构造方法
    C:成员方法
        只能是抽象的
        默认修饰符：public abstract

类与类,类与接口,接口与接口

    A:类与类
        继承关系，只能单继承，可以多层继承
    B:类与接口
        实现关系，可以单实现，也可以多实现。
        还可以在继承一个类的同时，实现多个接口
    C:接口与接口
        继承关系，可以单继承，也可以多继承

抽象类和接口的区别

    A:成员区别
抽象类：
    成员变量：可以变量，也可以常量
    构造方法：有
    成员方法：可以抽象，也可以非抽象
接口：
    成员变量：只可以常量
    成员方法：只可以抽象

B:关系区别
类与类
继承，单继承
类与接口
实现，单实现，多实现
接口与接口
继承，单继承，多继承

    C:设计理念不同
        抽象类：is a，抽象类中定义的是共性功能。
        接口：like a，接口中定义的是扩展功能。
(6)练习：
    A:猫狗案例，加入跳高功能
    B:老师和学生案例，加入抽烟功能

如何制作帮助文档(了解)

(1)写一个类
(2)加入文档注释
(3)通过javadoc工具生成即可
    javadoc -d 目录 -author -version ArrayTool.java

通过JDK提供的API学习了Math类(掌握)

(1)API(Application Programming Interface)
    应用程序编程接口(帮助文档)
(2)如何使用呢?
    请参照
        day08\code\02_如何使用JDK提供的帮助文档\如何使用帮助文档.txt
(3)Math类
    A:是针对数学进行操作的类
    B:没有构造方法，因为它的成员都是静态的
    C:产生随机数
        public static double random(): [0.0,1.0)
    D:如何产生一个1-100之间的随机数
        int number = (int)(Math.random()*100)+1;
    E:猜数字小游戏

代码块(理解)

(1)用{}括起来的代码。
(2)分类：
    A:局部代码块
        用于限定变量的生命周期，及早释放，提高内存利用率。
    B:构造代码块
        把多个构造方法中相同的代码可以放到这里，每个构造方法执行前，首先执行构造代码块。
    C:静态代码块
        对类的数据进行初始化，仅仅只执行一次。
(3)静态代码块,构造代码块,构造方法的顺序问题?
    静态代码块 > 构造代码块 > 构造方法

继承(掌握)

(1)把多个类中相同的成员给提取出来定义到一个独立的类中。然后让这多个类和该独立的类产生一个关系，
   这多个类就具备了这些内容。这个关系叫继承。
(2)Java中如何表示继承呢?格式是什么呢?
    A:用关键字extends表示
    B:格式：
        class 子类名 extends 父类名 {}
(3)继承的好处：
    A:提高了代码的复用性
    B:提高了代码的维护性
    C:让类与类产生了一个关系，是多态的前提
(4)继承的弊端：
    A:让类的耦合性增强。这样某个类的改变，就会影响其他和该类相关的类。
        原则：低耦合，高内聚。
        耦合：类与类的关系
        内聚：自己完成某件事情的能力
    B:打破了封装性
(5)Java中继承的特点
    A:Java中类只支持单继承
    B:Java中可以多层(重)继承(继承体系)
(6)继承的注意事项：
    A:子类不能继承父类的私有成员
    B:子类不能继承父类的构造方法，但是可以通过super去访问
    C:不要为了部分功能而去继承
(7)什么时候使用继承呢?
    A:继承体现的是：is a的关系。
    B:采用假设法
(8)Java继承中的成员关系
    A:成员变量
        a:子类的成员变量名称和父类中的成员变量名称不一样，这个太简单
        b:子类的成员变量名称和父类中的成员变量名称一样，这个怎么访问呢?
            子类的方法访问变量的查找顺序：
                在子类方法的局部范围找，有就使用。
                在子类的成员范围找，有就使用。
                在父类的成员范围找，有就使用。
                找不到，就报错。
    B:构造方法
        a:子类的构造方法默认会去访问父类的无参构造方法
            是为了子类访问父类数据的初始化
        b:父类中如果没有无参构造方法，怎么办?
            子类通过super去明确调用带参构造
            子类通过this调用本身的其他构造，但是一定会有一个去访问了父类的构造
            让父类提供无参构造
    C:成员方法
        a:子类的成员方法和父类中的成员方法名称不一样，这个太简单
        b:子类的成员方法和父类中的成员方法名称一样，这个怎么访问呢?
            通过子类对象访问一个方法的查找顺序：
                在子类中找，有就使用
                在父类中找，有就使用
                找不到，就报错
(9)两个面试题：
    A:Override和Overload的区别?Overload是否可以改变返回值类型?
    B:this和super的区别和各自的作用?
(10)数据初始化的面试题
    A:一个类的初始化过程
    B:子父类的构造执行过程
    C:分层初始化
(11)案例：
    A:学生和老师案例
        继承前
        继承后
    B:猫狗案例的分析和实现