一、   我也是黑马基础班的一名学员,马上就要就业班点招考试了,在此总结了面向对象的知识点,共享给大家

面向面向对象

1.      面对对象的理解：面向对象是基于面向过程的。在开发过程中，要完成特定的功能就去找相应的对象，如果找不到就创建相应的对象，使用对象，维护完善对象

2.    面对对象的特征：封装，继承，多态

3.    .面向对象和面向过程的区别：面向过程强调的是功能行为；面向对象将功能封装成对象，强调的是具备功能的对象

4.   . 如何创建使用对象：类名 对象名=new 类名（）；

如何使用成员变量，对象名.类名

如何使用成员方法,  对象名.方法名()

5.    A:在类中的位置不同

      成员变量：在类中方法外

局部变量：在方法定义中或者方法声明上

B:在内存中的位置不同

    成员变量：在堆内存(成员变量属于对象,对象进堆内存)

    局部变量：在栈内存(局部变量属于方法,方法进栈内存)

C:生命周期不同

   成员变量：随着对象的创建而存在，随着对象的消失而消失

局部变量：随着方法的调用而存在，随着方法的调用完毕而消失

D:初始化值不同

  成员变量：有默认初始化值

局部变量：没有默认初始化值，必须定义，赋值，然后才能使用。

注意: 局部变量名称可以和成员变量名称一样，在方法中使用的时候，采用的是就近原则。

6.    匿名对象:没有名字的对，调用方法：new 类名();   

使用:对象中的方法只调用一次,可以使用匿名对象.

          用做参数的传递

7.    封装的好处:隐藏了实现细节,提供了公共的访问模式

提高了代码的复用性

提高了安全性

8.       四种权限修饰符作用范围

	本类	同一个包下(子类和无关类)	不同包下(子类)	不同包下(无关类)
private	√
默认	√	√
protected	√	√	√
public	√	√	√	√

A.    private:是一个权限修饰符，可以修饰成员变量和成员方法，被其修饰的的成员只能在本类中访问。

9.    状态修饰符：

A  static :静态修饰符，特点随着类的加载而加载；优先于对象存在；被所有对象所共享；可以直接被类名所调用。

       静态方法只能访问静态成员，非静态方法既可以访问静态也可访问非静态

       静态方法中不可以定义this、super关键字，因为静态优先于对象存在，所以静态方法中不可以出现this；

B  final:(注意final、finally、finalize的区别)

       final修饰的变量只能赋值一次，不能发生改变，如果修饰的基本类型，是其值不能发生改变，如果修饰的引用数据类型，是地址值不能发生改变；

final修饰的方法不能被重写；

final修饰的类不能被继承，也称最终类。

注意:

       finally：异常处理try()..catch()时使用，可以添加也可以不添加，用于执行一些必须执行的代码，如关闭资源等

       finalize：Object类中的方法，其中定义了对象要被垃圾收集器回收之前要做的相关的清理工作

11.抽象修饰符

abstrsct:抽象类特点

a   :抽象类和抽象方法必须用abstract关键字修饰

abstract class 类名 {}

public abstractvoid eat();

b   :抽象类不一定有抽象方法，有抽象方法的类一定是抽象类或者是接口

c   :抽象类不能实例化那么，抽象类如何实例化呢?

按照多态的方式，由具体的子类实例化。其实这也是多态的一种，抽象类多态。

d  :抽象类的子类

要么是抽象类

要么重写抽象类中的所有抽象方法

问题: abstract与哪些关键字不能共存为什么?

       private：私有的方法是不可见的，无法被复写

       final：被final修饰的方法是最终方法，无法被复写

       static：被static修饰的方法，要随类加载到方法区，由于抽象方法没有方法体所以不能加载

12.构造方法(给对象的属性和数据进行初始化)
        特点:方法名和类名相同,没有具体返回值,连void都没有,也没有具体的返回值return.
13. 静态变量和成员变量的区别
        ①生命周期不同:
        静态变量:随着类的加载而加载,随着类的消失而消失.
        成员变量:随着对象的创建而存在,随着对象的消失而消失.
        ②于内存中存在的位置不同:
        静态变量:存在于方法区中的静态区
        成员变量:存在于堆内存
        ③调用不同
        静态变量:可以同过类名调用,也可以通过对象调用
        成员变量:只能通过对象调用
14 代码块(开发时很少用,主要面试可能会问)
①局部代码块
在方法中出现；限定变量生命周期，及早释放，提高内存利用率
②构造代码块 (初始化块)
在类中方法外出现；多个构造方法方法中相同的代码存放到一起，每次调用构造都执行，并且在构造方法前执行
③静态代码块
在类中方法外出现，并加上static修饰；用于给类进行初始化，在加载的时候就执行，并且只执行一次。一般用于加载驱动
面试题代码:
                看程序写结果
                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();
                        }
                }
输出结果:
Demo2_Student静态代码块
我是main方法
Student 静态代码块
Student 构造代码块
Student 构造方法
Student 构造代码块
Student 构造方法
15继承:让类与类之间产生子父类的关系
继承的好处:提高了代码的复用性,
                        提高了代码的维护性
`                        让类与类之间产生关系,是多态的前提
        弊端:让类之间的耦合性增强了.
注意: 父类中被private修饰的成员不可以被继承到，java不支持多继承，支持多层继承。
16.this、super关键字
this: （1）区别局部变量和成员变量（2）代表本类对象的引用（3）也可以用于构造方法的调用
super:代表当前对象的父类引用.
注意: super(…)或者this(….)必须出现在构造方法的第一条语句上
17继承中的面试题:
看程序写结果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();
18 多态
多态的前提:要有继承关系,要有方法重写,要有父类引用指向子类对象
多态的好处:提高了代码的维护性,提高了代码的扩展性.
弊端:父类不能访问子类特有的方法(若需使用子类特有方法.可以向下转型).
19接口
①接口概述
        * 从狭义的角度讲就是指java中的interface
        * 从广义的角度讲对外提供规则的都是接口
②接口特点
        * a:接口用关键字interface表示       
                * interface 接口名 {}
        * b:类实现接口用implements表示
                * class 类名 implements 接口名 {}
        * c:接口不能实例化
                * 那么，接口如何实例化呢?
                * 按照多态的方式来实例化。
        * d:接口的子类
                * a:可以是抽象类。但是意义不大。
                * b:可以是具体类。要重写接口中的所有抽象方法。(推荐方案)
注意_1: 抽象类和接口的区别
（1）成员的特点：抽象类可以有变量、常量、构造方法、一般方法、抽象方法；接口有且只能有常量和抽象方法。
（2）关系特点：类与类支持单继承，不能多继承，但是能够多层次继承，类与接口是实现关系，一个类能实现多个接口，一个类继承 一个类的同时能实现多个接口；接口与接口之间能单继承，也能多继承；
注意_2接口中的成员的特点？
答：都是常量，public static final ;方法都是抽象方法，public abstract;没有构造方法。
20类与类,类与接口,接口与接口的关系
        ①类与类：
                继承关系,只能单继承,可以多层继承。
        ②:类与接口：
                实现关系,可以单实现,也可以多实现。
                并且还可以在继承一个类的同时实现多个接口。
        ③:接口与接口：
                继承关系,可以单继承,也可以多继承。
21、对匿名内部类的理解
        匿名内部类其实是内部类的简写形式。  new 类名或接口名(){重写方法}
        内部类是定义在类中的类，就好比我们人类，我们人类都有心脏，而心脏又有自己独特组成，可以把心脏也抽象成一个类。
        这个心脏类就是人类的内部类。如果要研究某一种心脏疾病，需要一个实例时，我们不需要知道这个患病的心脏到底是谁的，那找到的这个就是匿名的。
        匿名内部类必须要继承一个类或实现一个接口，在使用时直接父类或接口的名称创建了一个子类对象并实现其中的方法，匿名内部类其实是一个匿名的子类对象
作用:  1: 实现了隐藏内部实现
2: 内部类无条件访问外部类属性
3: 间接实现了多继承
4: 解决继承类与实现接口时出现抽象方法重名的问题

楼主棒，很全很好啊。

很好，很强大