面向对象一些重点

以下是学习面向对象的时候的一些重点内容

1.成员变量和局部变量的区别

2.构造方法：用于给对象中的属性就行初始化

3.static关键字的特点

4. 在静态方法中是没有this关键字的5.静态变量和成员变量的区别

6. A:Math 类概述

7.封装的概述

8.继承(extends)

 9.this和super都代表什么

10.继承中构造方法的关系

11.final关键字

12.多态(polymorphic)概述

13.多态中的成员访问特点

14. 抽象

15.A:常见问题1：

16.接口

17.抽象类和接口的区别

18. 四种权限修饰符

19.匿名内部类

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


    2.构造方法：用于给对象中的属性就行初始化
         A:构造方法格式特点
             a:方法名与类名相同(大小也要与类名一致)
             b:没有返回值类型，连void都没有
             c:没有具体的返回值return;

         B:构造方法注意事项
            a:如果我们没有给出构造方法，系统将自动提供一个无参构造方法。
            b:如果我们给出了构造方法，系统将不再提供默认的无参构造方法。
               * 注意：这个时候，如果我们还想使用无参构造方法，就必须自己给出。建议永远自己给出无参构造方法


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

                


    4. 在静态方法中是没有this关键字的
        * 如何理解呢?
         * 静态是随着类的加载而加载，this是随着对象的创建而存在。
           * 静态比对象先存在。

       b:static 修饰的方法的访问特点：
        //静态方法只能访问静态的成员和静态的方法


    5.静态变量和成员变量的区别
            * 静态变量也叫类变量  成员变量也叫对象变量
        * A:所属不同
            * 静态变量属于类，所以也称为为类变量
            * 成员变量属于对象，所以也称为实例变量(对象变量)

        * B:内存中位置不同
            * 静态变量存储于方法区的静态区
            * 成员变量存储于堆内存

        * C:内存出现时间不同
            * 静态变量随着类的加载而加载，随着类的消失而消失
            * 成员变量随着对象的创建而存在，随着对象的消失而消失

        * D:调用不同
            * 静态变量可以通过类名调用，也可以通过对象调用
            * 成员变量只能通过 对象名 调用


    6. A:Math 类概述
            * 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;


       B:生成1-100的随机数的两种方式：
            
   

    方式1：    import java.util.Random;
               Random r = new Random();
               int random2 = r.nextInt(100) + 1;
                  //包左不包右；

    方式2：    int random = (int)(Math.random()*100) + 1;

        
     7.封装的概述
        * A:封装概述
             * 是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。

        * B:封装好处
            * 隐藏实现细节，提供公共的访问方式
            * 提高了代码的复用性
            * 提高安全性。

        * C:封装原则
            * 将不需要对外提供的内容都隐藏起来。
            * 把属性隐藏，提供公共方法对其访问。
       示例：

        public class Stack {
            private LinkedList list = new LinkedList();     //创建LinkedList对象并封装

            public void in(Object obj) {
                list.addLast(obj);                          //封装addLast()方法
            }

            public Object out() {
                return list.removeLast();                   //封装removeLast()方法
            }

            public boolean isEmpty() {
                return list.isEmpty();                      //封装isEmpty()方法
            }
        }

     8.继承(extends)
            * 让类与类之间产生关系,子父类关系

        * A:继承的好处
            * a:提高了代码的复用性
            * b:提高了代码的维护性
            * c:让类与类之间产生了关系，是多态的前提

        * B:继承的弊端
            * 类的耦合性增强了。
            
            * 开发的原则：高内聚，低耦合。
            * 耦合：类与类的关系
            * 内聚：就是自己完成某件事情的能力

        * C:继承的注意事项
            * a:java只支持单继承，不支持多继承
            * b:子类只能继承父类所有非私有的成员(成员方法和成员变量)
            * c:子类不能继承父类的构造方法，但是可以通过super(马上讲)关键字去访问父类构造方法。

        * D:什么时候使用继承：is a 的关系；
            如果有两个类A,B。只有他们符合A是B的一种，或者B是A的一种，就可以考虑使用继承。

     9.this和super都代表什么
            * this:代表当前对象的引用,谁来调用我,我就代表谁
            * super:代表当前对象父类的引用

         B：调用
            a、成员变量
            b、成员方法
            c、构造方法：//构造方法是不能继承的，子类要自己写，所以this只能调用自己的构造方法


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



         B:* 父类没有无参构造方法,子类怎么办?
            * super解决：在子类的无参构造中调用父类的有参构造
            * this解决：在子类的无参构造中调用子类的有参构造
               注意事项
            * super(…)或者this(….)必须出现在构造方法的第一条语句上
            * 每一个构造方法的第一条语句默认都是：super()  调用父类的空参构造

    11.  final关键字

        A:final修饰特点

            * 修饰类，类不能被继承
            * 修饰变量，变量就变成了常量，只能被赋值一次
            * 修饰方法，方法不能被重写
    
        B:final 修饰成员变量：
            * 基本类型，是值不能被改变
            * 引用类型，是地址值不能被改变,对象中的属性可以改变

        


    12.多态(polymorphic)概述
             * 事物存在的多种形态
       * A:多态前提
          * a:要有继承关系。
          * b:要有方法重写。
          * c:要有父类引用指向子类对象。


    
       * B:多态的好处
        * a:提高了代码的维护性(继承保证)
        * b:提高了代码的扩展性(由多态保证)
        * 可以当作形式参数,可以接收任意子类对象

       * C:多态的弊端
        * 不能使用子类的特有属性和行为。    (特有！！！！！！！！！)

      

    13.多态中的成员访问特点
        * A、成员变量
            * 编译看左边(父类)，运行看左边(父类)。

        * B、成员方法
            * 编译看左边(父类)，运行看右边(子类)。
                    //动态绑定

        * C、静态方法
            * 编译看左边(父类)，运行看左边(父类)。
            * (静态和类相关，算不上重写，所以，访问还是左边的)
            *
        总结：只有非静态的成员方法,编译看左边,运行看右边
        
    14. 抽象
        * A、抽象类的子类
            * 要么是抽象类
            * 要么重写抽象类中的所有抽象方法

        * B、抽象类的成员方法特性：
            * a:抽象方法 强制要求子类做的事情。
            * b:非抽象方法 子类继承的事情，提高代码复用性。

        * C、abstract 不能修饰成员变量，没有意义；

    15.A:常见问题1：
        * 一个抽象类如果没有抽象方法，可不可以定义为抽象类?如果可以，有什么意义?
        * 可以
        * 这么做目的只有一个,//就是不让其他类创建本类对象,交给子类完成
       B:常见问题2：
        * abstract不能和哪些关键字共存
            1.abstract和static 不能共存
               被abstract修饰的方法没有方法体
               被static修饰的可以用类名.调用,但是类名.调用抽象方法是没有意义的
            2.abstract和final 不能共存
               被abstract修饰的方法强制子类重写
               被final修饰的不让子类重写,所以他俩是矛盾
            3.abstract和private  不能共存
               被abstract修饰的是为了让子类看到并强制重写
               被private修饰不让子类访问,所以他俩是矛盾的



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

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



    18. 四种权限修饰符
                        本类     同一个包下(子类和无关类)    不同包下(子类)    不同包下(无关类)
        private        Y
        
        默认            Y                 Y

        protected    Y                 Y                                       Y
    
        public          Y                 Y                                        Y                              Y

         记忆：默认两个字，对应两个“Y”.
    19.匿名内部类
        匿名内部类的格式：(创建线程的时候可以使用匿名内部类)

    public class Test4 {
        public static void main(String[] args) {
            Outer.method().show();
        }
    }
    
    interface Inter {
        void show();
    }

    class Outer {
        public static Inter method(){
            return new Inter(){
                public void show(){
                    System.out.println("HelloWorld");
                }
            };
        }
                
    }