框架图

理解面向对象

• 面向对象是相对面向过程而言
• 面向对象和面向过程都是一种思想
• 面向过程强调的是功能行为
• 面向对象将功能封装进对象，强调具备了功能的对象。
• 面向对象是基于面向过程的。

面向对象的特点
是一种符合人们思考习惯的思想
可以将复杂的事情简单化
将程序员从执行者转换成了指挥者
完成需求时：

• 先要去找具有所需的功能的对象来用。
• 如果该对象不存在，那么创建一个具有所需功能的对象。
• 这样简化开发并提高复用。

面向对象开发，设计，特征
开发的过程：其实就是不断的创建对象，使用对象，指挥对象做事情。
设计的过程：其实就是在管理和维护对象之间的关系。
面向对象的特征：

• 封装
• 继承
• 多态

类与对象的关系

计算机语言是虚拟的，但描述的是现实中的事物，java中描述事物通过类的形式体现，类是具体事物的抽象，概念上的定义。对象即是该类事物实实在在存在的个体。

类与对象的关系好比汽车的设计图纸，参照这个设计图制造的汽车，具有颜色、轮胎等特征。图纸就是类，汽车就是堆内存中的实体对象。我们可以对某个汽车所改观，比如换颜色换轮胎，和其他汽车没有关系。

生活中描述事物无非就是描述事物的属性和行为。Java中用类class来描述事物也是如此：
属性：对应类中的成员变量。
行为：对应类中的成员函数。
定义类其实就是在定义类中的成员(成员变量和成员函数)。

匿名对象

匿名对象是对象的简化形式

对比如下：

 Car c = new Car();

 c.color="red"

 c.run();

 new Car().run();

匿名对象两种使用情况

• 当对对象方法仅进行一次调用的时，如果对一个对象进行多个成员调用，必须给这个对象起名。
• 匿名对象可以作为实际参数进行传递，函数调用完成后自动释放，没了引用指向，匿名对象在堆内存中成为垃圾被自动回收。

成员变量和局部变量

a.无论成员变量还是局部变量使用前都需要声明；

b. 局部变量使用前必须初始化；成员变量可以不用初始化，其每个类型的的成员变量都有一个初始值：byte、short、int、long类型初始值为 0；float、double类型初始值为0.0;char类型的初始'\u0000';boolean类型的初始值为false;

c.局 部变量没有访问权限修饰符，不能用public，private，protected来修饰。局部变量不能用static修饰，没有”静态局部变量“。局 部变量的作用域仅限于定义它的方法，在该方法的外部无法访问它；成员变量定义在类中，在整个类中都可以被访问。如果权限允许，还可以在类的外部使用成员变 量;

d.局部变量的生存周期与方法的执行期相同。当方法执行到定义局部变量的语句时，局部变量被创建，执行到它所在的作用域的最后一条语句时，局部变量被销毁；类的成员变量，如果是实例成员变量，它和对象的生存期相同。而静态成员变量的生存期是整个程序运行期;

e.在同一个方法中，不允许有同名的局部变量。在不同的方法中，可以有同名的局部变量，它们互不干涉。 局部变量可以和成员变量同名，且在使用时，局部变量具有更高的优先级。

局部变量代码示例

 public class localVariable

 {

     public void method_1()

 {

               int va = 0;    //正确

               public int pva;   //错误，不能有访问权限

               static int sa;   //错误，不能是静态的

               final int CONST = 10; //正确，可以是常量

               double va =0.0;   //错误，与前面的va同名

               vb = 100.0;    //错误，vb还未定义

               double vb;

               vb = 100.0;    //正确，现在可以使用了

 }

      public void method_2()

 {

               va = 0;     //错误，method_1()中的变量va在此不可用

               int CONST = 100;   //正确，它与method_1()中的CONST不同

 }

 }

局部变量与成员变量同名示例

 public class localVSmember

 {

            private int iVar = 100;

            public void method_1()

 {

            int iVar;    //正确可以与成员变量同名

            iVar = 200;    //这里访问的是局部变量

            this.iVar = 300;  //这里访问的是成员变量

 }

            public void method_2(){

            iVar = 400;    //这里访问的是成员变量

 }

 }

 //因为局部变量优先级高于成员变量，同一函数内调用，同名的局部变量会屏蔽掉成员变量。为了访问被屏蔽的成员变量，需要使用"this"关键字，它表示的是"本类对象"（所在函数所属对象）成员变量其实还是对象在调用

构造函数

对象一建立就会调用与之对应的构造函数，用于给对象进行初始化。当一个类中没有定义构造函数时，那么系统会默认给该类加入一个空参数的构造函数。当在类中自定义了构造函数后，默认的构造函数就没有了。

构造函数和一般函数在写法上不同，在运行上也有不同：

• 构造函数是在对象一建立就运行。给对象初始化；而一般方法是对象调用才执行，给是对象添加对象具备的功能。
• 一个对象建立，构造函数只运行一次；而一般方法可以被该对象调用多次。

什么时候定义构造函数呢？
当分析事物时，该事物存在具备一些特性或者行为，那么将这些内容定义在构造函数中。

构造函数的特点：

• 函数名与类名相同
• 不用定义返回值类型(区别void)
• 不可以写return语句
• 多个构造函数是以重载的形式存在的

构造代码块
构造代码块和构造函数一样，也是为对象进行初始化用的。
共同点是在对象一建立的时候他们都在运行，区别在于构造代码块要优先于构造函数执行，同时，构造代码块是给所有对象进行统一的初始化，而构造函数则是给对应的对象进行初始化。

this关键字

this代本类对象的引用，也就是它所在函数所属对象的引用，简单说：哪个对象在调用this所在的函数，this就代表哪个对象。

this关键字的使用：

1.当成员变量和局部变量重名时，在方法中使用this时，表示的是该方法所在类中的成员变量。例如上面局部变量和成员变量同名的示例。
2.用于构造函数之间进行调用。注意：只能定义在构造函数的第一行，构造函数之间不允许相互调用，会形成死循环。

static关键字

static关键字用于修饰成员(成员变量和成员函数)。

被修饰后的成员具备以下特点：

• 随着类的加载而加载,消失而消失。
• 优先于对象存在
• 被所有对象所共享
• 可以直接被类名调用,格式为：类名.静态成员

使用注意
静态方法只能访问静态成员，非静态方法既可以访问静态也可以访问非静态。
因为静态优先于对象存在，所以静态方法中不可以写this，super关键字。
主函数是静态的

静态有利有弊
利处：对对象的共享数据进行单独空间的存储，节省空间。没有必要每一个对象中都存储一份。
        可以直接被类名调用。
弊端：生命周期过长。
        访问出现局限性。(静态虽好，只能访问静态)

什么使用静态？要从两方面下手：因为静态修饰的内容有成员变量和函数。
什么时候定义静态变量(类变量)呢？
当对象中出现共享数据时，该数据被静态所修饰。对象中的特有数据要定义成非静态存在于堆内存中。

什么时候定义静态函数呢？
当功能内部没有访问到非静态数据(没有操作对象的特有数据)，那么该功能可以定义成静态的。

静态代码块
示例1

 class StaticCode

 {

     static

     {

      System.out.println("a");

     }

 }

 class StaticCodeDemo

 {

     static

     {

         System.out.println("b");

     }

     public static void main(String[] args)

     {

         new StaticCode();

         new StaticCode();//随类加载只执行一次且优先于主函数执行

         System.out.println("over");

         }

     static

     {

              System.out.println("c");

     }

 }

 //运行结果

 //b c a over

示例2

 class StaticCode

 {

     int num = 9;

     StaticCode()//无参数类型的构造函数

     {

         System.out.println("b");

     }

     static//静态代码块------给类初始化

     {

         System.out.println("a");

     }

     {

         System.out.println("c"+this.num);//构造代码块-------给对象初始化

     }

     StaticCode(int x)//有参数类型的构造函数---------给对应对象初始化

     {

         System.out.println("d");

     }

     public static void show()

     {

         System.out.println("show run");

     }

 }

 class StaticCodeDemo

 {

     static

     {

         System.out.println("f");

     }

     public static void main(String[] args)

     {

         new StaticCode(4);

     }

 }

 //运行结果:f a c9 d

特点：随着类的加载而执行，只执行一次，优先于主函数执行。类似构造代码块。用于给类进行初始化。表示：一个类进入内存，不需要对象的情况下，需要先做什么事情，较少使用。
注意：可能不止一个。位置不固定，可能在末尾。新建对象和调用类方法都可以加载类，但是创建一个没有实体指向的空变量不会加载类，例如，StaticCode s = null;，因为没有指向、没有意义。只有用到了类中的内容，例如，构造函数等，类才会被加载。
执行顺序：加载类—》静态变量—》静态代码块—》主函数—》加载对象—》加载属性—》构造代码块—》构造函数
静态代码块内部只能放静态成员，构造代码块内部能放各种成员变量。

对象的初始化

Person p = new Person(“zhangsan”,20);
该句话的执行步骤如下：

1．因为new用到了Person类，所以会先找到Person.class文件并加载到内存中，静态变量加载到方法区。同时，栈内存中分配空间给变量p。

2. 会执行该类中的静态代码块，如果有的话，同时给Person.class类进行初始化。

3. 在堆内存中开辟空间，分配内存地址。

4. 在堆内存中建立对象的特有属性（实例变量），并进行默认初始化。

5. 对属性进行显示初始化。

6. 对对象进行构造代码块初始化。

7. 对对象进行对应的构造函数初始化。

8. 将内存地址赋给栈内存中的p变量，p指向对象。

面向对象的特征

封装

封装：就是隐藏对象的属性和实现的细节，控制在程序中属性的读和写的访问级别，仅对外提供公共的访问方式。
好处：
•将变化隔离。
•便于使用。
•提高重用性。
•提高安全性。
封装原则：
•将不需要对外提供的内容都隐藏起来。
•把属性都隐藏，提供公共方法对其访问。

private(私有)关键字是一个权限修饰符。用于修饰成员(成员变量和成员函数)，被私有化的成员只在本类中有效。private可以将成员变量私有化，对外提供对应的
set方法(返回值为void且有参数)和get方法(没有参数)对其进行访问，提高对数据访问的安全性。私有仅仅是封装的一种表现形式。

继承

多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承单独的那个类即可。多个类可以称为子类，单独这个类称为父类或者超类。

通过extends 关键字让类与类之间产生继承关系。
写法：class SubDemo extends Demo{}

• 继承的出现提高了代码的复用性。
• 继承的出现让类与类之间产生了关系，提供了多态的前提。

子类可以直接访问父类中的非私有的属性和行为。定义继承要注意不能仅为了获取其他类的功能，简化代码而继承，必须是类与类之间有所属关系才可以继承（is a）。

使用继承体系中的功能：先查阅体系中父类的描述，因为父类中定义的是该体系*性功能，通过了解共性功能就可以知道该体系的基本功能。具体调用时，要创建最子类的对象。因为有可能父类不能创建对象，如抽象类；而且创建子类对象可以使用更多的功能，包括基本功能和特有功能。总的说就是查阅父类功能，创建子类对
象使用功能。

Java语言中：java只支持单继承，不支持多继承。
因为多继承容易带来安全隐患:当多个父类中定义了相同功能，当功能内容不同时，子类对象不确定要运行哪一个。但是java保留这种机制。并用另一种体现形式来完成表示。多实现。
java支持多层继承。也就是一个继承体系。

继承出现后，子父类成员的特点：
类中成员：
1，变量。

如果子父类中出现非私有的同名成员变量时，子类要访问本类的变量用this，一般可以省略。子类要访问父类中的同名变量用super，不可以省略。父类private成员变量可以被继承但无法被访问。
2，函数。

当子类出现和父类一模一样的函数时，当子类对象调用该函数，会运行子类函数的内容。如同父类的函数被覆盖一样。这种情况是函数的另一个特性：重写(覆盖)
当子类继承父类，沿袭了父类的功能，到子类中，但是子类虽具备该功能，但是功能的内容却和父类不一致，这时，没有必要定义新功能，而是使用覆盖特殊，保留父类的功能定义，并重写功能内容。

• 子类覆盖父类，必须保证子类权限大于等于父类权限，才可以覆盖，否则编译失败。
• 静态只能覆盖静态。

注意区分：
重载：同一个类中，只看同名函数的参数列表。
重写：子父类方法要一模一样。（包括返回值类型）
3，构造函数。

子类不能覆盖父类构造函数，因为类名不一样。在对子类对象进行初始化时，父类的构造函数也会运行，那是因为子类的构造函数默认第一行有一条隐式的语句super();
super()会访问父类中空参数的构造函数。而且子类中所有的构造函数默认第一行都是super()；(只能写在第一行）

为什么子类一定要访问父类中的构造函数?
因为父类中的数据子类可以直接获取。所以子类对象在建立时，需要先查看父类是如何对这些数据进行初始化的。所以子类在对象初始化时，必须要先访问一下父类中的构造函数。子类中至少会有一个构造函数会访问父类中的构造函数。
如果要访问父类中指定的构造函数，可以通过手动定义super显示语句的方式来指定。当然子类的构造函数第一行也可以手动指定this语句来访问本类中的构造函数。

final关键字

1，可以修饰类，函数，变量。
2，被final修饰的类不可以被继承。为了避免被继承，被子类复写功能。
3，被final修饰的方法不可以被复写。
4，
被final修饰的变量是一个常量只能赋值一次，既可以修饰成员变量，也可以修饰局部变量。当在描述事物时，一些数据的出现值是固定的，那么这时为了增强
阅读性，都给这些值起个名字。方便于阅读。而这个值不需要改变，所以加上final修饰。作为常量：常量的书写规范所有字母都大写，如果由多个单词组成，
单词间通过_连接。
5，内部类定义在类中的局部位置上是，只能访问该局部被final修饰的局部变量。

抽象类

当多个类中出现相同功能，但是功能主体不同，这时可以进行向上抽取。这时，只抽取功能定义，而不抽取功能主体。例如void work() ,工人和程序员都需要工作，但是工作的内容不会相同。不抽取主体只抽取方法再通过方法的覆盖来实现多态的属性。是一种运行时绑定。

抽象类的特点：
1，抽象方法一定在抽象类中。抽象类中可以不定义抽象方法，这样做仅仅是不让该类建立对象。
2，抽象方法和抽象类都必须被abstract关键字修饰。
3，抽象类不可以用new创建对象。因为调用抽象方法没意义。
4，抽象类中的抽象方法要被使用，必须由子类复写起所有的抽象方法后，建立子类对象调用。如果子类只覆盖了部分抽象方法，那么该子类还是一个抽象类。

接口

接口是对外暴露的规则，是程序的功能扩展。

格式：
interface {}
接口中的成员修饰符是固定的：

• 成员常量：public static final----全局常量
• 成员函数：public abstract

接口可以理解为一个特殊的抽象类，当类中的方法都是抽象的，该类可以通过接口的形式来表示。接口中的方法都是没有方法体的，便于以后的覆盖。

类与接口之间是“实现”关系，implements。父类中有非抽象内容可以直接拿来用，子类只有将接口中的内容全部实现后才能实例化，否则是抽象类。接口
是不可以创建对象的，因为有抽象方法。覆盖接口中的方法必须用public，因为接口中的方法都是共有的，抽象类的权限不确定。
接口可以被类多实现。一个类可以同时现实多个接口。也是对多继承的不支持的转换形式。依然需要覆盖每个接口的方法。即使多个接口有相同名称的方法也没有问题，因为没有方法体，不会产生矛盾，子类可以全部覆盖。子类在继承父类的同时，还可以实现多个接口。
类之间是继承关系；类和接口之间是实现关系；接口之间是继承关系，接口之间可以多继承，但是不能有重载函数。

接口的使用思路：

子类继承父类的全部功能；但是，有的子类需要某些功能，有的子类不需要某些功能，可以将这些功能作为接口，需要的用，不需要的不用，防止不需要的子类也带上这些功能，而且其他的子类也可以使用这些接口；如果所有的子类都需要这些功能，但是具体的内容不同，可以使用抽象类，子类自己进行覆盖，或者使用一般类，
少部分的子类通过覆盖获得自己所需要的功能。
基本功能定义在类中，扩展功能定义在接口中。例如培训班的学员基本功能都要学习，扩展功能有部分学员需要抽烟。

抽象类和接口异同
相同：
1，都可以在内部定义抽象方法。
2，通常都在顶层。
3，都不可以实例化，都需要子类来实现。

不同：
1，抽象类中可以定义抽象方法和非抽象方法，而接口中只能定义抽象方法。
2，抽象类只能单继承。接口的出现可以多实现，也就是说接口的出现避免了单继承的局限性。
3，继承和实现的关系不一致。继承：is a，实现：like a

多态

多态可以理解为事物存在的多种体现形态。 比如动物的体现形态：猫、狗等。

猫这个对象对应的类型是猫类型
•猫 x = new 猫();
同时猫也是动物中的一种，也可以把猫称为动物。
•动物 y = new 猫();

动物是猫和狗具体事物中抽取出来的父类型。

父类型引用指向了子类对象，这就是多态的体现。

多态的前提必须是类与类之间有关系。要么继承，要么实现。通常还有一个前提：方法存在覆盖。

好处：大大提高了程序的扩展性，便于后期维护。

弊端：但是只能使用父类的引用访问父类的成员。

 Animal a = new Cat();//类型提升。 向上转型。

 a.eat();

 //如果想要调用猫的特有方法时，如何操作？强制将父类的引用转成子类类型。向下转型。

 Cat c = (Cat)a;

 c.catchMouse();

 //千万不要出现这样的操作，就是将父类对象转成子类类型。

 //        Animal a = new Animal();

 //        Cat c = (Cat)a;错误的。

 //多态自始至终都是子类对象在做着变化。

自己写了个小代码加深下多态的理解

 class Polymorphic

 {

     public static void main(String[] args)

     {

         Boss boss=new Boss();

         boss.command(new MDWorker());

         boss.command(new MTWorker());

     }

 }

 //父类员工类

 abstract class Worker

 {    String name;

      int age;

      abstract void salaried();//领薪水的方法

      abstract void doProject();//做项目的方法

 }

 //市场部员工子类

 class MDWorker extends Worker

 {     

       public void salaried(){

       System.out.println("领3K薪水!");

       }

       public void doProject(){

       System.out.println("做市场调差项目!");

       }

       public void report(){

       System.out.println("特有功能写报告!");

       }

 }

 //技术部员工子类

 class MTWorker extends Worker

 {     public void salaried(){

       System.out.println("领4K薪水!");

       }

       public void doProject(){

       System.out.println("做技术测试项目!");

       }

       public void coding(){

       System.out.println("特有功能写代码!");

       }

 }

 //老板类

 class Boss

 {   

     public void command(Worker w)//接收父类的引用

     {   

         w.doProject();

         w.salaried();

         //w.report();编译不通过。想调用子类特有功能必须向下转型。

         if(w instanceof MDWorker)

         {

             MDWorker md = (MDWorker)w;//父类引用强转为市场部子类对象，调用写报告的特有方法。

             md.report();

         }

         else if(w instanceof MTWorker)

         {

             MTWorker mt = (MTWorker)w;

             mt.coding();

         }

     }

 }

在多态中成员函数的特点：
在编译时期：参阅引用型变量所属的类中是否有调用的方法。如果有编译通过，如果没有编译失败。
在运行时期：参阅对象所属的类中是否有调用的方法。
简单总结就是：成员函数在多态调用时，编译看左边，运行看右边。

在多态中，成员变量的特点：
无论编译和运行，都参考左边(引用型变量所属的类)。

在多态中，静态成员函数和静态成员函数的特点：
无论编译和运行，都参考左边(引用型变量所属的类)。

接口实现多态

        实现      被使用

     类——--——>接口——--——>主程序

  将相似的类中的方法抽象出来放在接口。

  主程序只需要使用接口的方法建立接口的引用，类只需实现了接口，有新类出现只要将接口的引用指向新类，无需改动主程序和接口，就降低了程序的耦合性。

Object类

Object类:是所有对象的直接或者间接父类，唯一没有父类的类，传说中的上帝。该类中定义的是所有对象都具备的功能。

注意：实际应用中一般都有复写object父类中的方法。

equals()方法

 Object类中的equals()方法如下：

 public boolean equals(Object obj)

 {

     return (this == obj);

 }

Object类中的equals()方法等价于==。只有当继承Object的类覆写了equals()方法之后，子类实现了用equals()方法比较两个对象是否相等，才可以说equals()方法与==的不同。

toString()

 Object类中的toString()方法定义如下：

 public String toString()

 {

     return getClass().getName() + "@" + Integer.toHexString(hashCode());

 }

覆写equals和toString例子

 class  CarDemo

 {

     public static void main(String[] args)

     {

     Car c1 = new Car("2013", "宝马");

     Car c2 = new Car("2013", "宝马");

     System.out.println(c1.equals(c2));

     System.out.println(c1);

     }

 }

 class Car {

         private String year;

         private String type;

         Car(String year, String type){

             this.year= year;

             this.type =type;

         }

         //复写equals()方法

         public boolean equals(Object obj){ //如果比较双方指向同一个对象，则直接返回true。

             if( this == obj)

                 return true;

             if(obj != null && getClass() == obj.getClass())//使用getClass方法来判断运行时对象是否是同类对象，还要防止对null的对象执行getClass操作。

             {

                 Car c = (Car)obj;//强转转换向下转型，才能访问子类中year和type。

                 if((this.year== c.year) && (this.type == c.type))

                     return true;

             }

             return false;

         }

         //复写toString()方法

         public String toString(){

         return ("这是"+year+"年生产的"+type+"汽车。");

         }

 }  

运行结果