02面向对象

 1.面向对象思想特点
    * a:是一种更符合我们思想习惯的思想
    * b:可以将复杂的事情简单化
    * c:将我们从执行者变成了指挥者
2.类与对象概述
    * 属性  就是该事物的描述信息(事物身上的名词)
    * 行为  就是该事物能够做什么(事物身上的动词)
    * 类描述多个对象的共同特征,是对象的模板;对象描述的是现实中的个体,是类的实例.
    * Java中最基本的单位是类,Java中用class描述事物也是如此
3.成员变量和局部变量的区别
    * A:在类中的位置不同
        * 成员变量：在类中方法外
        * 局部变量：在方法定义中,或者方法声明上
    * B:在内存中的位置不同
        * 成员变量：在堆内存(成员变量属于对象,对象进堆内存)
        * 局部变量：在栈内存(局部变量属于方法,方法进栈内存)
    * C:生命周期不同
        * 成员变量：随着对象的创建而存在，随着对象的消失而消失
        * 局部变量：随着方法的调用而存在，随着方法的弹栈而消失
    * D:初始化值不同
        * 成员变量：有默认初始化值
        * 局部变量：没有默认初始化值，必须定义，赋值，然后才能使用。
4.封装的概述
    * 是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。
    * 封装好处
        隐藏实现细节，提供公共的访问方式
        提高了代码的复用性
        提高安全性。
5.构造方法Constructor概述和格式
    * 给对象的数据(属性)进行初始化
    * 构造方法格式特点
        * a:方法名与类名相同(大小也要与类名一致)     //构造方法不能用对象调用，当创建对象的同时就调用了方法
        * b:没有返回值类型，连void都没有           //构造方法也有return语句的，格式是： return；
        * c:没有具体的返回值return;
    * 构造方法的重载
        * 重载:方法名相同,与返回值类型无关(构造方法没有返回值),只看参数列表 
        * 构造方法注意事项
            * a:如果我们没有给出构造方法，系统将自动提供一个无参构造方法。
            * b:如果我们给出了构造方法，系统将不再提供默认的无参构造方法。
            * 注意：这个时候，如果我们还想使用无参构造方法，就必须自己给出。建议永远自己给出无参构造方法
6.创建一个(有构造方法)对象的步骤
    * 1, Student.class加载进内存
    * 2, 声明一个Student类型引用s
    * 3, 在堆内存创建对象,
    * 4, 给对象属性默认初始化值
    * 5, 属性进行显示初始化  (private String name ="张三"; private int age =23;)
    * 6, 构造方法进栈,对对象中的属性赋值,构造方法弹栈
    * 7, 将对象的地址值赋值给s
7.static关键字的特点
    * a: 随着类的加载而加载
    * b: 优先于对象存在
    * c: 被类的所有对象共享
    * d:可以通过类名调用 
   static的注意事项    
    * a:在静态方法中是没有this关键字的
    * b:静态方法只能访问静态的成员变量和静态的成员方法 //静态和非静态一起加载，但非静态要创建对象才能调用。
8.静态变量和成员变量的区别
    静态变量也叫类变量  成员变量也叫对象变量
        * A:所属不同
            * 静态变量属于类，所以也称为为类变量
            * 成员变量属于对象，所以也称为实例变量(对象变量)
        * B:内存中位置不同
            * 静态变量存储于方法区的静态区
            * 成员变量存储于堆内存
        * C:内存出现时间不同
            * 静态变量随着类的加载而加载，随着类的消失而消失
            * 成员变量随着对象的创建而存在，随着对象的消失而消失
        * D:调用不同
            * 静态变量可以通过类名调用，也可以通过对象调用
            * 成员变量只能通过对象名调用
9.代码块概述
    * 在Java中,使用{}括起来的代码被称为代码块
    * 根据其位置和声明的不同，可以分为局部代码块，构造代码块，静态代码块，同步代码块
        * a:局部代码块 
            * 在方法中出现；限定变量生命周期，及早释放提高内存利用率
        * b:构造代码块 (初始化块)  
            * 在类中方法外出现；把构造方法中相同的代码存放到一起，每创建一次对象就会执行一次，并且在构造方法前执行
        * c:静态代码块 
            * 在类中方法外出现，由static关键字修饰；用于给类进行初始化，加载的时候就执行，并且只执行一次。
            * 优先于主方法执行的。(不管是在主方法前面还是后面)
            * 一般用于加载驱动
        * d:同步代码块
            * 使用synchronized关键字加上一个锁对象来定义一段代码, 这就叫同步代码块
            * 当多线程并发, 有多段代码同时执行时, 我们希望某一段代码执行的过程中CPU不要切换到其他线程工作. 这时就需要同步.
            * 如果两段代码是同步的, 那么同一时间只能执行一段, 在一段代码没执行结束之前, 不会执行另外一段代码.
10.继承
    让类与类之间产生关系,子父类关系
    继承的好处
        * a:提高了代码的复用性
        * b:提高了代码的维护性
        * c:让类与类之间产生了关系，是多态的前提
    继承的弊端
        * a:类的耦合性增强了。
        * b:开发的原则：高内聚，低耦合。
    继承的注意事项
        * a:子类只能继承父类所有非私有的成员(成员方法和成员变量)
        * b:子类不能继承父类的构造方法，但是可以通过super关键字去访问父类构造方法。
        * c:不要为了部分功能而去继承
    重写
        * 当子类需要父类的功能，而功能主体子类有自己特有内容时，可以重写父类中的方法。这样，即沿袭了父类的功能，又定义了子类特有的内容
        * 方法重写注意事项
            * a:父类中私有方法不能被重写
            * b:子类重写父类方法时，访问权限不能更低
            * c:父类静态方法，子类也必须通过静态方法进行重写
11.this和super的区别和应用
    * this:代表当前对象的引用,谁来调用我,我就代表谁
    * super:代表当前对象父类的引用
         * a:调用成员变量
            * this.成员变量  调用本类的成员变量;也可以调用父类的成员变量(本类没有这个变量时，就会继承父类的变量),其实是先继承再调用
            * super.成员变量 调用父类的成员变量
        * b:调用成员方法
            * this.成员方法 调用本类的成员方法,也可以调用父类的方法,其实是先继承再调用
            * super.成员方法 调用父类的成员方法
        * c:调用构造方法
            * this(...)     调用本类的构造方法, 构造方法不会被继承,所以this调用不了
            * super(...)  调用父类的构造方法    
12.Override和Overload的区别?Overload能改变返回值类型吗?
    * overload可以改变返回值类型,只看参数列表
    * 方法重写：子类中出现了和父类中方法声明一模一样的方法。与返回值类型有关,返回值是一致(或者是子父类)的
    * 方法重载：本类中出现的方法名一样，参数列表不同的方法。与返回值类型无关。
13.final关键字修饰类,方法以及变量的特点
final修饰特点
    * 修饰类，类不能被继承
    * 修饰变量，变量就变成了常量，只能被赋值一次
    * 修饰方法，方法不能被重写    
final关键字修饰局部变量
    * 方法内部或者方法声明上都演示一下
    * 基本类型，是值不能被改变
    * 引用类型，是地址值不能被改变,对象中的属性可以改变
        final int num = 10;
            //num = 20;  不能在赋值，只能是一次
        System.out.println(num); 

        final Person p = new Person("张三",23);
            //p = new Person("李四",24);  p记录的是地址值，不能再记录其他地址值，
        p.setName("李四");   可以修改对象的属性
        p.setAge(24);
        System.out.println(p.getName() + "..." + p.getAge());

        method(10); 方法调用后就弹栈了，这种在开发中没实际意义
        method(20);
    }
    public static void method(final int x) {
        System.out.println(x);   //使x在方法中不能被修改
    }
final修饰变量的初始化时机
    * 1.显示初始化（成员变量的默认初始化值是无效值）
    * 2.在对象构造完毕前即可(在对象构造方法完毕前就可以)   创建对象时会通过构造方法赋值,然后才打印,这样就不会出现未初始化变量.
        class Demo3_Final {
            public static void main(String[] args) {
                Demo d = new Demo();
                d.print();
            }
        }
        class Demo {
            final int num;    //成员变量的默认初始化值是无效值
    
            public void print() {
                System.out.println(num);
            }
    
            public Demo() {
                num = 10;
            }
        }
14.多态    
    事物存在的多种形态    
    多态前提
        * a:要有继承关系。
        * b:要有方法重写。
        * c:要有父类引用指向子类对象
    多态的好处
        * a:提高了代码的维护性(继承保证)
        * b:提高了代码的扩展性(由多态保证)
        * c:可以当作形式参数,可以接收任意子类对象
     多态的好处
        * 不能使用子类的特有属性和行为。
15.抽象类特点
    * a:抽象类和抽象方法必须用abstract关键字修饰
        * abstract class 类名 {}
        * public abstract void eat();
    * b:抽象类不一定有抽象方法，有抽象方法的类一定是抽象类或者是接口
    * c:抽象类不能实例化,那么抽象类如何实例化呢?
        * 按照多态的方式，由具体的子类实例化。其实这也是多态的一种，抽象类多态。
    * d:抽象类的子类
        * 要么是抽象类
        * 要么重写抽象类中的所有抽象方法
16.abstract不能和哪些关键字共存
    * abstract和static
        被abstract修饰的方法没有方法体
        被static修饰的可以用类名.调用,但是类名.调用抽象方法是没有意义的
    * abstract和final
        被abstract修饰的方法强制子类重写
        被final修饰的不让子类重写,所以他俩是矛盾
    * abstract和private
        被abstract修饰的是为了让子类看到并强制重写
        被private修饰不让子类访问,所以他俩是矛盾的
17.接口
    接口特点
        * a:接口用关键字interface表示    
            * interface 接口名 {}
        * b:类实现接口用implements表示
            * class 类名 implements 接口名 {}
        * c:接口不能实例化，调用抽象方法没有意义
            * 那么，接口如何实例化呢?
            * 按照多态的方式来实例化。
        * d:接口的子类
            * a:可以是抽象类。但是意义不大。
            * b:可以是具体类。要重写接口中的所有抽象方法