面向对象编程详解（包含封装，继承，多态，static详解，抽象类，接口，内部类）

面向过程思想

1. 步骤清晰简单，第一步做什么，第二步做什么。。。。。

2. 面向过程适合处理一些比较简单的问题。

面向对象思想

1. 物以类聚，分类的思维模式，思考问题首先要会解决问题需要哪些类，然后对这些类进行单独思考。最后才对某个分类下你的细节进行面向过程思索。

2. 面向对象适合处理复杂的问题，适合处理多人协作的问题！

对于描述复杂的事物，为了从宏观上把握，从整体上合理分析，我们需要使用面向对象的思路来分析整个系统。但是，具体到微观操作，容然需要面向过程的思路去处理。

面向对象编程（Object Oriented Programming,OOP）

面向对象编程的本质就是：以类的方式组织代码，以对象的方式组织（封装）数据！！！！

抽象

三大封装：

1. 封装:把客观的事物封装厂抽象的类、并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行信息隐藏。

2. 继承:继承就是由已经存在的类创建新类的机制、在已经存在的类的基础上扩展功能。

3. 多态:多态是指父类的方法被子类重写时、可以各自产生自己的功能行为。

从认识论角度考虑是先有对象后有类。对象，是具体的事物。类，是抽象的，是对对象的抽象。

从代码运行的角度考虑先有类后有对象。类对象的模板。

方法的定义

1. 修饰符

2. 返回类型

    修饰符    返回值类型      方法名（。。。）{
   //方法体
   return   返回值；
   }

3. break：跳出switch，结束循环和return的区别

4. 方法名：注意规范，见名知意

5. 参数类表：（参数类型，参数名）。。。。

6. 异常抛出：有疑问，后面详细介绍

方法的调用

1. 静态方法

2. 非静态方法

3. 形参和实参

4. 值传递和引用传递

5. this关键字

   this.name = name; this.后面是当前的类 后面name是参数

类是一个抽象的数据类型，它是对某一类事物整体描述/定义，但是不能代表某一个具体的事物。

1. 手机，电脑，动物，植物。。。。

2. person类，pet类，car类等等，这些类都是描述/定义某一类具体到事物应该具备的特点和行为。

对象是抽象概念的具体事例

1. 张三就是一个人的具体实例，张三家里的旺财就是狗的一个具体实例。
2. 能够体现出特点，展现出功能的是具体的实例，而不是一个抽象的概念。

• 使用new关键字创建对象

  1. 使用new关键字创建的时候，除了分配内存空间之外，还会给创建好的对象进行默认初始化以及对可中构造器的调用。

  2. 类中构造器也称构造方法，是进行创建对象的时候必须要调用的。并且构造器有以下两个特点：

     （1.） 必须和类的名字相同。

     （2.）必须没有返回值类型，也不能写viod。

  3. 构造器必须要掌握！

      

  4. 创建对象的内存分析

1. 类与对象

   类是一个模板：抽象；对象是一个具体的实例。

2. 方法

   定义，调用！

3. 对应的类型

   引用类型： 八个基本类型

   对象是通过引用来操作的：栈----->堆

4. 属性：字段（field） 成员变量

   默认初始化：

   数字： 0 0.0

   char： u0000

   boolean: false

   引用： null

   修饰符 属性类型 属性名 = 属性值

5. 对象的创建和使用

   1. 必须使用new关键字创建对象，构造器 。 例子：Person zhangxu = new Person;

   2. 对象的属性 zhangxu.name

   3. 对象的方法 zhangxu.sleep()

6. 类：

   静态的属性 属性

   动态的行为 方法

• 该露的露 ，该藏的藏。

  1. 我们程序设计要追求“高内聚，低耦合”。高内聚就是累的内部数据操作细节自己完成，不允许外部干涉；低耦合：仅暴露少量的方法给外部使用。

• 封装（数据的隐藏）

  1. 通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏。

• 记住这句话就够了：属性私有，get/set

• 继承的本质是对某一批类的抽象，从而实现对现实世界的建模。

• extands的意思是 “拓展”。子类是 父类的拓展。

• Java中类只有单继承，没有多继承。

• 继承是类与类之间的关系。除此之外，类与类之间的关系还有依赖，组合，聚合等。

• 继承关系是两个雷，一个为子类（派生类），一个为父类（基类）。子类继承父类，使用关键字extands来表示。

• 子类与父类之间，从意义上讲应该具有“is a”的关系。

• object类

• super

  • super注意点：

    1. super调用父类的构造方法，必须放在子类构造方法的第一个

    2. super必须只能出现在子类方法或构造方法中。

    3. super和this不能同时调用构造方法

  • super和this的比较

    1. 代表对象不同：this：本身调用这个对象 super：代表父类对象的应用

    2. 前提：this：没有继承也可以使用 super:只能在继承条件下才能使用

    3. 构造方法：this（）：本类的构造 super（）：父类的构造

• 方法重写

  • 多态

     

  • 重写

     

     

    1. 重写：需要有继承关系，子类重写父类的方法！

    2. 重写注意点：方法名必须相同

                            参数类表必须相同

                            修饰符：范围可以扩大：public>protected>default>private

                                                    抛出异常：范围可以被缩小，但不可以扩大

                     3. 重写，子类的方法必须和父类的方法一致；方法体不同！

                    4.为什么需要重写？ 父类的功能，子类不一定需要，或者不一定满足！

                    5. 快捷键 alt+insert Override Methods 方法重写

• 即同一方法可以根据发送对象的不同而采用多种不同的行为方式。

• 一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多。

• 多态存在的条件：

  • 有继承关系

  • 子类重写父类方法

  • 父类引用指向子类对象

• 多态注意事项：多态是方法的多态，属性没有多态性！

  • 多态是方法的多态，属性没有多态性

  • 父类和子类，有联系 类型转换异常！ClassCastException!

  • 存在条件：继承关系，方法需要重写，父类指向子类对象！ father f1 = new son();

  • 哪些方法不能重写：

    1. static 方法，属于类，它不属于

    2. final 常量                           

    3.  private方法 私有的

• instanceof （类型转换） 引用类型，判断一个对象是什么类型

  • instanceof

    package oop.demo07;
    public class Application {
        public static void main(String[] args) {
            //Object>String
            //Object>Person>Teacher
            //Object>Person>Student
           Object object = new Student();
           // System.out.println(X instanceof Y);//能不能编译通过！！！
            System.out.println(object instanceof Student);//true
            System.out.println(object instanceof Person);//true
            System.out.println(object instanceof Object);//true
            System.out.println(object instanceof Teacher);//false
            System.out.println(object instanceof String);//false
            System.out.println("==============");
            Person person = new Student();
            System.out.println(person instanceof Student);//true
            System.out.println(person instanceof Person);//true
            System.out.println(person instanceof Object);//true
            System.out.println(person instanceof Teacher);//false
            //System.out.println(person instanceof String);//编译出错！
            System.out.println("================");
            Student student = new Student();
            System.out.println(student instanceof Student);//true
            System.out.println(student instanceof Person);//true
            System.out.println(student instanceof Object);//true
           // System.out.println(student instanceof Teacher);//编译出错！
           // System.out.println(student instanceof String);//编译出错！
        }
    }
    ​

    • 类型转换

• abstract修饰符可以用来修饰方法也可以修饰类，如果修饰方法，那么该方法就是抽象方法；如果修饰类，那么该类就是抽象类。

• 抽象类中 可以没有抽象方法，但是有抽象方法的类一定要声明为抽象类‘

• 抽象类不能使用new关键字来创建对象，它是用来让子类继承的。

• 抽象方法，只有方法的声明，没有方法的实现，它是用来让子类实现的。

• 子类继承抽象类，那么就必须要实现抽象类没有实现的抽象方法，否则该子类也要声明为抽象类。

• 普通类：只有具体实现

• 抽象类：具体实现和规范（抽象方法）都有！

• 接口：只有规范！！！自己无法写自己的方法。专业的约束！约束和实现分离：面向接口编程

• 接口就是规范，定义的是一组规则，体现了现实世界中“如果你是。。。。则必须能。。。”的 思想。例如：如果你是天使，则必须能飞。

• 接口的本质是契约，就像我们人间的法律一样。制定好大家都遵守。

• OO的精髓，是对对象的抽象，最能体现这一点的就是接口。为什么我们讨论设计模式都只针对具备了抽象能力的语言（C++，Java，C#等），就是因为涉及模式所研究的，实际上就是如何合理的去抽象。

• 声明类的关键字是class，声明接口的关键字是interface！

  • 接口的作用：

    1. Java的接口是一个约束

    2. 定义一些方法，让不同的人实现

    3. 接口中默认的方法都是public abstract

    4. 接口中定义的属性都是常量 方法public static final

    5. 接口不能被实例化，抽象类也不能。接口中没有构造方法。

    6. implents 可以实现多个接口

    7. 必须重写接口中的方法

• 内部类就是一个类的内部在定义一个类，比如，A类中定义一个B类，那么B累相对于A类来说就称为内部类，而A类相对于B类来说就是外部类。

• 成员内部类

   

• 静态内部类(以后在lambada中详解)

• 局部内部类

   

• 匿名内部类