Java（面向对象）

（一）类和对象

1、（1）面向过程就是分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，使用的时候一个一个依次调用就可

以。
     （2）面向对象是把构成问题事务分解成各个对象，建立对象的目的不是为了完成一个步骤，而是为了描叙某个事物在整个解

决问题的步骤中的行为。

2、全局声明其实只是可以公用一个指定类型的变量，而全局变量则是已经初始化并且分配了唯一的地址并且在任何地方都可以

使用，局部变量则只能在方法内部使用，其它地方不能使用。全局变量是一个容器，而局部变量只能是容器里的一部分。

    （1）成员变量（（全局变量：JAVA中没有全局变量的定义，这是C中的），当前类的所有方法和一些其他类使用）

    （2）局部变量（当前方法使用）

    两者区别： （1）作用域不同：局部变量仅限于定义它的方法，而成员变量在整个类内部都是可见的；（2）初始值不同：

Java会给成员变量一个初始值，不会给局部变量赋予初始值；（3）在同一方法中，不允许有同名局部变量，在不同方法中，可

以有同名局部变量；（4）两类变量同名时，局部变量具有更高优先级。

3、构造方法（创建对象，并初始化对象的值）

      （1）通过无参构造方法可以创建对象

      （2）通过有参构造方法可以创建对象并给对象中的实例变量赋初值

      （3）构造方法重载

      （4）有参构造传值控制

4、使用static修饰变量、方法和代码块

【静态变量】（静态成员或类成员）

      Java 中被 static 修饰的成员称为静态成员或类成员，属于整个类所有，而不是某个对象所有（即被类的所有对象所共

      （1）静态成员可以使用类名直接访问（省略类名），也可以使用对象名进行访问）

      （2）静态成员属于整个类，当系统第一次使用该类时，就会为其分配内存空间直到该类被卸载才会进行资源回收

【静态方法】（静态方法或类方法）

      静态变量一样，也可以使用 static 修饰方法，称为静态方法或类方法。其实之前我们一直写的 main 方法就是静态方法。

      （1）静态方法中可以直接调用同类中的静态成员，但不能直接调用非静态成员或调用非静态方法(需要通过对象来访问

非静态方法)；

      （2） 在普通成员方法中，则可以直接访问同类的非静态变量和静态变量。

    静态变量和成员变量有什么区别：

       静态变量静态变量也称作类变量，是在类之中，方法之外，以static关键字申明的变量，其独立在对象之外，有许多对象共

享的变量。静态变量在对象产生之前产生，并长驻于内存，其在JVM关闭时销毁。成员变量成员变量也称作实例变量、属性， 申

明在类之中，方法之外的变量，随对象销毁而销毁。

【静态初始化块】

       （1）静态初始化块只在类加载时执行，且只会执行一次，同时静态初始化块只能给静态变量赋值，不能初始化普通的成员

变量。 

       （2）程序运行时静态初始化块最先被执行，然后执行普通初始化块，最后才执行构造方法。由于静态初始化块只在类加载

时执行一次

 

（二）封装（隐藏属性）

1、概念：将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访

问。

2、好处：只能通过规定的方法访问数据；隐藏类的实例细节，方便修改和实现。

3、封装的实现步骤：（1）修改属性的可见性（设为private）、（2）创建getter/setter方法（用于属性的读写）、（3）在

getter/setter方法中加入属性控制语句（对属性值的合法性进行判断）

【访问修饰（控制）符】：可以修饰属性和方法的访问范围（属性通常用private修饰，方法用public修饰）

          （1）private修饰：本类（访问范围最小）

          （2）默认修饰（不写）：本类、同包

          （3）protected修饰：本类、同包、子类

          （4）public修饰：本类、同包、子类、其它（任何）

【this关键字】（当前对象）

    （1）this.属性 操作当前对象的属性

    （2）this.方法 调用当前对象的方法

【内部类】：内部类（ Inner Class ）就是定义在另外一个类里面的类。与之对应，包含内部类的类被称为外部类（内部类也

是一个类，可以有自己的成员方法和成员变量）

      内部类的主要作用如下：

     （1）内部类提供了更好的封装，可以把内部类隐藏在外部类之内，不允许同一个包中的其他类访问该类

     （2）内部类的方法可以直接访问外部类的所有数据，包括私有的数据

     （3）内部类所实现的功能使用外部类同样可以实现，只是有时使用内部类更方便

      内部类有几种：成员内部类、静态内部类、方法内部类、匿名内部类

        成员内部类（普通内部类，最常见）：定义了成员内部类后，必须使用外部类对象来创建内部类对象，而不能直接去

new一个内部类对象，即：内部类 对象名 = 外部类对象.new 内部类( );

         （1）外部类是不能直接使用内部类的成员和方法（可先创建内部类的对象，然后通过内部类的对象来访问其成员变量和

方法）
         （2）如果外部类和内部类具有相同的成员变量或方法，内部类默认访问自己的成员变量或方法，如果要访问外部类的成

员变量，可以使用 this 关键字

        静态内部类（静态内部类是 static 修饰的内部类）

        （1）静态内部类不能直接访问外部类的非静态成员，但可以通过 new 外部类().成员 的方式访问 

        （2）如果外部类的静态成员与内部类的成员名称相同，可通过“类名.静态成员”访问外部类的静态成员；如果外部类的

成员与内部类的成员名称不相同，则可通过“成员名”直接调用外部类的静态成员

         （3）创建静态内部类的对象时，不需要外部类的对象，可以直接创建 内部类 对象名= new 内部类();
     
       方法内部类：内部类定义在外部类的方法中，方法内部类只在该方法的内部可见，即只在该方法内可以使用。

       匿名内部类（学习接口时会提到）

 

（三）继承（子类拥有父类的所有属性和方法）
    
    1、概念：继承是类与类的一种关系，是一种 is a 的关系（Java中的继承是单继承，只有一个父类）

    2、好处：子类拥有父类的所有属性和方法（private修饰的无效），实现代码复用

    3、语法：class 子类 extends 父类（ 子类 / 派生类、父类 / 基类）

【方法的重写】（重写父类继承的方法）

    1、概念：如果子类对继承父类的方法不满意，是可以重写父类继承的方法的，当调用方法时会优先调用子类的方法。

    2、语法规则：（1）返回值类型 、（2）方法名 、（3）参数类型及个数 ，都要与父类继承的方法相同，才叫方法的重写。

    3、@Override标签的作用 ：　　　       

        @Override是伪代码，所以是可写可不写的，它表示方法重写，写上会给我们带来好处． 　　

       （1）可以当注释用，方便阅读；（2）告诉阅读你代码的人，这是方法的复写；  （3）编译器可以给你验证@Override下面

的方法名是否是你父类中所有的，如果没有则报错．

        总结：重载与覆盖的区别：

            （1）重载是在同一个类中，为了满足不同的需求

            （2）覆盖是在子类中进行重写，为了更加具体化

【继承的初始化顺序】（初始化父类再初始化子类）    

      （1）初始化父类再初始化子类、（2）先执行初始化对象中属性，再执行构造方法中的初始化

        即：父类对象（属性初始化->构造方法）->子类对象（属性初始化->构造方法）

【final关键字】（最终的，可以修饰类，方法，属性和变量）    

      （1）final修饰类，则该类不能被继承（最终类）

      （2）final修饰方法，则该方法可以被继承，但不能被覆盖（重写）

      （3）final修饰属性，则该属性在定义时需要初始化，或者在构造方法中初始化（二选一初始化） 

      （4）final修饰变量，该变量只能进行一次赋值（包括初始化），而后值不可更改，相当于常量

         public static final String NICKNAME = "小黄";  // static表示类变量，可使用类名访问

【super关键字】（父类对象）

      在对象的内部使用（子类对象方法内），可以代表父类对象。

      （1）访问父类的属性：super.age；（2）访问父类的方法：super.eat()；

      super应用：super关键字和构造方法有紧密关系

         （1）子类的构造过程中必须调用起父类的构造方法

         （2）如果子类的构造方法中没有显式调用父类的构造方法，则系统默认调用父类无参的构造方法（隐式显示）

         （3）如果显式的调用构造方法，必须在子类构造方法的第一行（子类构造方法第一行）

         （4）如果子类构造方法中既没有显式的调用父类构造方法，而父类又没有无参的构造方法，则编译出错

【Object类】（所有类的父类，默认继承该类）

      如果一个类没有使用extends关键字明确标识继承另外一个类，那么这个类默认继承Object类。Object类中的方法，适合所有

子类。

      1、toString（）方法：在Object类里面定义toString()方法的时候返回对象的哈希code码（对象地址字符串）

              可以通过重写toString（）方法表示出对象的属性（source->generate to String()）

      2、equals（）方法：

                equals()方法，比较的是对象的引用是否指向同一块内存地址（其实是比较是否是一个手机，即为同一个对象)

总结：Java 中的数据类型，可分为两类： 

       （1）基本数据类型，也称原始数据类型。byte、short、int、long、float、double、,char和boolean之间的比较，应用双等号

（==），比较的是他们的值。 

       （2）复合数据类型（String、Integer、Date，对象）

          当他们用（==）进行比较的时候，比较的是他们在内存中的存放地址，所以，除非是同一个new出来的对象，他们的比较

后的结果为true，否则比较后结果为false。因为每次new都会开辟新的内存空间，故指向的内存地址不相同。

         JAVA当中所有的类都是继承于Object这个基类的，在Object中的基类中定义了一个equals的方法，这个方法的初始行为是

比较对象的内存地址，但在一些类库当中这个方法被覆盖掉了，如String、Integer、Date在这些类当中equals有其自身的实现，

而不再是比较类在堆内存中的存放地址。

        如需比较复合数据类型则需重新equals 方法使用eclipse工具----source-------Generate hashcode()-----andequals()自动重写

public class Main {
  public static void main(String args[]){
	   String str1 = new String("hello"); // Java中，只要使用new关键字来创建对象，则一定会（在堆区或栈区）创建一个新的对
       String str2 = "hello";   //因为它们都是从缓冲池取出来的，由于string类比较特殊，jdk专门做了缓存优化
       String str3="hello";

	  System.out.println("str1==str2： " + (str1 == str2));
	  System.out.println("str2==str3"+(str2==str3));
	  System.out.println("str1.equals(str2)： " + str1.equals(str2));
  }
}

    
（四）多态（对象多种形态，继承是实现多态的基础）

    1、引用多态

        父类的引用可以指向本类的对象（Animal obj1 = new Animal();）

        父类的引用可以指向子类的对象（Animal obj2 = new Dog();）

    2、方法多态

        创建本类对象时，调用的方法为本类方法

        创建子类对象时，调用的方法为子类重写的方法或者继承的方法（父类的引用不能调用子类独有的方法）

【引用的类型转换】

      1、向上类型转换（隐式/自动类型转换），是小类型打大类型的转换（没有风险）。

      2、向下类型转换（强制类型转换），是大类型转到小类型。

      3、instanceof运算符，来解决引用对象的类型，避免类型转换的安全性问题、如内存溢出（判断一个类型是否是某个类

型或者某个类型的子类型，返回Boolean值）

        如： class dog entends animal、class cat entends animal

                Dog dog=new Dog();   Animal animal=dog;   // 向下类型转换，自动类型。

                Dog dog=(Dog)animal;  // 强制类型转换。

                Cat cat=(Cat )animal  //因为编译时时Cat类型，运行时Dog类型会报错。

         改为： if(animal instanceof Cat)

                      {   Cat cat=(Cat )animal//依然无法转换，但是不会报错 }

【抽象类】（有抽象方法的一定是抽象类，但是抽象类不一定有抽象方法）

   1、语法定义：抽象类前使用abstract关键字修饰，则该类为抽象类( abstract class A)。

   2、应用场景：

      （1）在某些情况下，某个子类只是知道其子类应该包含怎样的办法，但无法准确知道这些子类如何实现这些方法；

      （2）从多个具有相同特征的类中抽象出一个抽象类，以这个抽象类作为子类的模板，从而避免了子类设计的随机性。

   3、作用：限制规定子类必须实现某些方法，但不关注实现细节（不关注子类的实现，但必须约束子类的特征（约束子类））

   4、使用规则： 

        （1）abstract定义抽象类；（2）abstract定义抽象方法，只有声明，不需要实现；（3）包含抽象方法的类是抽象类

（4）抽象类中可以包含普通的方法，也可以没有抽象方法；（5）抽象类可以有构造方法，但不能直接实例化，只能用来继承

（6）在抽象类中可以定义抽象方法，也可以定义具体方法，如果一个类继承抽象类，那么必须重写抽象类中定义的所

有抽象方法。

【接口】（规范，约束类）

     1、接口概念：接口可以理解为一种特殊的类，有全局常量和公共的抽象方法所组成。类是一种具体实现体，而接口定义了

某一批类所需要遵守的规范，接口不关心这些类的内部数据，也不关心这些类里方法的实现细节，它只规定这些类里必须提供某

些方法。

     2、接口定义：和类定义不用，定义接口不再使用class关键字，而是使用interfaca关键字。

           基本语法：[修饰符]（abstract系统默认）interface 接口名  extends  [父接口1.2.3]

                ｛

                    零个到多个常量定义...
                    零个到多个抽象方法的定义...

                 ｝             

            接口就是用来被继承，被（其他类）实现的，修饰符一般建议用public （注意：不能使用private和protected修饰接口）  

    3、接口定义

    （1）常量：接口中的属性是常量（即使定义时不添加 public static final 修饰符，系统也会自动加上）

    （2）方法：接口中的方法只能是抽象方法（即使定义时不添加public abstract修饰符，系统也会自动加上，不能是方
法体）

     4、使用接口：一个类可以实现一个或多个接口，实现接口使用implements关键字。Java中一个类只能继承一个父类，是不

够灵活的，通过实现多个接口可以做补充。

    继承父类实现接口的语法为：
 
        [修饰符] class 类名 extends 父类 implements 接口1，接口2..（如果要继承父类，继承父类必须在实现接口之前）

           ｛  

                 类体部分//如果继承了抽象类，需要实现继承的抽象方法；要实现接口中的抽象方法。  
         
           ｝

  5、使用接口：经常与匿名内部类配合使用（匿名内部类就是没有名字的内部类，多用于关注实现而不关注实现类的名字

（Android经常使用））

        IplayGame iplayGame=new SmartPhone(); // 实现类
        iplayGame.playGame();
        
        IplayGame iplayGame2=new IplayGame() {
            
            @Override
            public void playGame() {
                // TODO Auto-generated method stub
                System.out.println("使用匿名内部类的方式实现接口");
            }
        };
        iplayGame2.playGame();
        
        new IplayGame() {
            
            @Override
            public void playGame() {
                // TODO Auto-generated method stub
                System.out.println("使用匿名内部类的方式实现接口2");
            }
        }.playGame();

总结：

   相同点：（1）接口和抽象类都不能被实例化（用于被其他类继承和实现）

                  （2）都可以包含抽象方法（实现接口或继承抽象类的普通子类必须实现这些抽象方法）

   不同点：（1）接口里只能包含抽象方法，静态方法和默认方法，不能为普通方法提供方法实现，抽象类则完全可以包含普通方

法。（2）接口里只能定义静态常量，不能定义普通成员变量，抽象类里则既可以定义普通成员变量，也可以定义静态常量；

（3）接口不能包含构造器，抽象类可以包含构造器，抽象类里的构造器并不是用于创建对象，而是让其子类调用这

些构造器来完成属于抽象类的初始化操作；（4）接口里不能包含初始化块，但抽象类里完全可以包含初始化块。（5）一个类最

多只能有一个直接父类，包括抽象类，但一个类可以直接实现多个接口，通过实现多个接口可以弥补Java单继承不足。