Java面向对象

1：类与对象

㈠类的声明

    [修饰符] class 类名 [extends 父类名] [implements 接口名列表]

  {

       成员变量声明部分

       成员方法声明部分

  }

注：[](中括号)内为可选项

说明：类修饰符一般为public、abstract和final

         public：把一个类声明为共有类，这意味着该类可以被任意的对象使用和扩展，无须考虑它所在的包。（Java中规定包含main（）函数的类必须是公共类）

         final：说明为最终类，即不能在定义子类的类。

         abstract：定义了一个抽象类，即不能被实例化的对象的类。

㈡对象的创建

    格式：类名 对象名；或者 对象名=new 类名（参数表）； 或者 类名 对象名=new 类名（参数表）；

    Java对象是引用类型，引用类型是指该类型的变量名表示的是一片连续内存地址的首地址。（不能使用该地址直接操作对象的实际内存，这与C++中指针不同，是Java语言保证安全性的一种机制。）

㈢对象销毁

    Java中，清除对象的操作是由系统自动完成的，它提供了一种垃圾回收机制用来清除无用的对象。（也可自己主动释放对象——在类中定义finalize（）函数。）

㈣对象初始化

①当使用new运算符实例化一个对象时，系统自动调用构造函数初始化该对象。如果在类中没有定义构造函数，则调用默认构造函数来初始化该对象，使用默认值来初始化该对象的成员变量。

②定义类时，给成员变量赋初值。

③通过初始化块来初始化成员变量。其语法格式如下：

 {

       代码块

 }

说明：

a：初始化块在两种情况下都执行，对于无参构造函数显示是初始化块中的值，实际上是对默认值的覆盖，对于有参构造函数对初始化块中的值进行覆盖。

b：在没有初始化块的情况下，对于无参构造函数显示的是成员变量的初值，对于有参构造函数相当于对成员变量的初值进行覆盖。

c：在既没有初始化块，又没有初值的情况下，对于无参构造函数显示的是成员变量的默认值，对于有参的构造函数则是对默认值进行覆盖。

㈤静态成员（static修饰的内容隶属于类，而不是直接隶属于对象的，所以static修饰的成员变量一般称作类变量）

 ①静态成员变量——一个静态成员变量单独划分一块存储空间，不kingl与具体的对象绑定在一起，该存储空间被类的各个对象所共享。

    静态成员变量既可以通过类名来访问，又可以通过对象名来访问，但是一般不推荐使用对象名来访问，因为这样可能在读代码时造成误解，以为类变量时实    例变量

    static关键字不能修饰成员函数或构造函数内部的变量。

 ②静态成员函数（其内部只能使用静态的成员变量）

    静态函数在类的外部进行调用时不需要创建对象，可以直接通过类名来访问。

    静态函数不能用this和super关键字，不能直接访问所属类的实例变量和实例函数，只能访问所属类的静态成员变量和成员函数。

 ③静态代码块

    ——类中独立于类成员的static语句块，可以有多个，位置可以随便放，它不在任何的方法体内，JVM加载类时会执行这些静态的代码块，如果static代码块有多个，JVM将按照它们在类中出现的先后顺序依次执行它们，每个代码块只会被执行一次。

④main函数

   ——main函数是Java应用程序的入口函数，它和其它函数有很大的不同比如函数名字必须是main，函数必须是public static void 类型的，函数必须接收一个字符串数组的参数等等。

   完整定义语法：

   public static void main(String[] args){

             ......

   }

  说明：main函数必须是一个静态函数，这样可以在不需要构造类实例的前提下，直接运行应用程序

           返回值声明必须为void，而不能没有定义或定义为其他类型。

           main函数只作为Java应用程序的入口。Applet程序不需要main函数，一般由浏览器不同方式启动，其入口程序一般为init()函数。

㈥final、this、和null（3个关键字）

 ①final

    final修饰数据，则该数据变量变为常量

    final修饰函数，则该函数为最终函数，不能被覆盖（不能在子类的内部重写该方法）

    final修饰类，则该类为最终类，不能被继承，也就是该类不能有子类，且final类内部的每个函数都是final函数

 ②this——代表自身

   使用用途：引用成员变量

                   引用构造函数（在自身构造函数内部引用其他的构造函数，以降低代码的重复）——注：实际调用时，调用的代码只能出现在构造函数内部的第一行可执行代码。

                   代表自身对象

                   引用成员函数

 ③null——Java中的一个直接量（也称常量），表示类类型变量为空的状态。

㈦包——类与接口的集合，是Java中组织程序文件的一种树形结构

    Java规定，同一个包中的文件名必须唯一，不同包中的文件名可以相同。

  ①创建包——包含一个package命令作为Java源文件的第一句即可     eg：package 包名;      package mypackage;

     注：在一个Java文件中，只允许出现一句package语句，因为不可能将某个类放在两个不同的包中。

  ②导入包

      ⑴全限定名方式访问包中的类        eg：java.awt.Graphics a;                   java myPackage.HelloWorld;

      ⑵import导入包                          通用形式：import 包名1[.包名2.包名3﹒ ﹒ ﹒ ].(类名|*);

         如果使用一个星号（*）指明要引入这个包中所有的public类。   eg：import java.util.Date;   //引入java.util.Date类     import java.io.*;   //引入java.io包中的所有public类

2：类的继承与多态（Java近支持单继承）

①继承的实现

语法形式：[修饰符]class 子类名 extends 父类名

               {

                        //新增属性、方法、或改写父类原有方法

               }

    说明：修饰符说明类的访问权限（public）、是否为抽象类（abstract）或最终类（final）。

              如果没有用extends指明父类，则默认继承Object根类，Object类是所有类的直接父类或间接父类。

             Java只支持单一继承，一个类只能继承一个直接父类。

②继承的访问权限

⑴父类与子类在同一个包

   a：子类对父类的private成员没有访问权限

   b：子类对父类的缺省、protected和public成员具有访问权限

⑵父类与子类不在同一个包

   a：子类对父类的缺省、private成员没有访问权限

   b：子类对父类的protected 和public修饰的成员具有访问权限。

   c：子类继承父类时同样要求能够找到父类，因此父类必须有package语句，子类必须有import语句，父类还必须有public修饰符。

③super关键字

super的使用格式：

            super.成员变量                //引用父类成员变量

            super.成员函数(参数表)    //引用父类成员方法

            super(参数表)                          //引用父类的构造函数

④子类的构造函数

      在继承体系下，当创建一个子类对象时，构造函数执行为：先基类在派生类

  子类构造函数常用格式：   构造函数([参数表]){

                                             super([父类构造函数参数]);       //调用父类构造函数

                                             其他;                                      //对本类新增变量进行初始化或进行其他处理

                                       }

⑤多态（静态多态——函数重载；动态多态——运行时多态）

⑴对象的转型——向下转型和向上转型

   向上转型机制自觉遵守对象转换机制，不需要显示声明。   eg： Student s=new GraduateStudent();

   向下转型不会自动进行，需要作强制类型转化。                eg：Student s=new Student();    GraduateStudent g=(GraduateStudent)s;

⑵动态多态性

     规则：由对象本身的实际类型决定

⑥抽象类——凡是用abstract修饰符修饰的类

   抽象类不能实例化对象

   抽象类必须被继承，子类为它们中的所有抽象函数提供实现，否则它们还是抽象类。      

3：接口与内部类

①接口概念——接口是用来实现多重继承功能的一种结构，它在语法上与类相似，接口中有属性和方法，接口可以形成继承关系，但接口中只包含常量和函数的声明，没有变量和函数的实现。接口是一种概念性的模型，有助于类的层次结构的设计。

注：接口与类的区别

     a：接口不能用于实例化对象

     b：接口没有构造函数

     c：接口中所有的函数必须是抽象函数

     d：接口不能包含成员变量，除了static和final变量。

     e：接口不能被类继承了，而是要被类实现。

     f：接口支持多重继承。 

②接口的定义

   接口的声明语法格式：

   [public] interface 接口名 [extends<父接口列表>]{

          [public] [static] [final] 常量;

          [public] [abstract] 方法;

   }

   说明：⑴public修饰符的接口可以被所有的类使用，被所有接口继承。没有public修饰的接口只能被同一个包中的其他类使用，被同一个包中的接口继承。

            ⑵接口中所有 的常量默认使用public static final，所以在定义常量时可以省去不写。

            ⑶接口中所有的方法默认为public abstract，在声明时也可以省去不写。

③接口的实现

  [修饰符] class<类名>[extends<父类名>] [implement<接口列表>]{

             类体

  }

 其中，接口列表可以包含多个接口名称，各名称间用逗号分隔。要实现一个接口的非抽象类必须重写接口中定义的方法并添加方法体，同时实现接口的非抽象类可以使用接口中定义的任何常量。

  如何一个类没有覆盖接口中定义的全部方法，那么这个类就成为抽象类，必须被声明为abstract。

④接口回调

接口回调是多态的另一种体现。接口回调是指：可以把使用某一个接口的类创建的对象的引用赋给该接口声明的接口变量中，那么该接口变量就可以调用被类实现的接口中的方法。当接口变量调用被类实现的接口中的方法时，就是通知相应的对象调用接口的方法，成为接口回调。不同的类在使用同一接口时，可能具有不同的功能体现。即接口的方法体不必相同，因此接口回调可能产生不同的行为。

⑤内部类

成员内部类/局部内部类/匿名内部类/静态内部类

⑴成员内部类

a：成员内部类可以无条件访问外部类的所有成员属性和成员方法（包括private成员和静态成员）。

b：当成员内部类拥有和外部类同名的成员变量或者方法时，会发生隐藏现象，即默认情况下访问的是成员内部类的成员。如果要访问外部类的同名成员，需要以下面的形式进行访问：                      外部类.this.成员变量                  外部类.this.成员方法

c：在外部类中如果要访问成员内部类的成员，必须先创建一个成员内部类的对象，再通过指向这个对象的引用来访问。

d：成员内部类不能含有static的变量和方法。因为成员内部类需要先创建了外部类，才能创建它自己的。

e：成员内部类用private修饰，则只能在外部类的内部访问，如果用public修饰，则任何地方都能访问；如果用protected修饰，则只能在同一个包下或者继承外部类的情况下访问；如果是默认访问权限，则只能在同一个包下访问。

⑵局部内部类——定义在一个函数（方法）或者一个代码块中的类，它和成员内部类的区别在于局部内部类的访问仅限与函数内或者代码块中。

a：局部内部类前面不能有访问修饰符。

b：可以访问外部类的所有成员。

c：定义在函数体中的内部类只能访问该函数的final变量。

d：定义在代码块中的内部类只能使用在该代码块中定义的final变量。

⑶静态内部类

创建静态内部类对象 ：      外部类.静态内部类 对象名=外部类.静态内部类（构造函数参数列表）

a：静态内部类可以有非静态成员。

b：静态内部类只能访问外部类静态成员。

⑷匿名内部类——我们只需要内部类的一个对象，而不需要该类的名字时使用匿名内部类。

a：匿名内部类不能有构造函数。

b：匿名内部类不能定义任何静态成员、方法、和类。

c：匿名内部类不能是public、protected、private，static。

d：只能创建匿名内部类的一个实例。

e：一个匿名内部类一定是在new的后面，用其隐含实现一个接口或实现一个类。

f：因匿名内部类为局部内部类，所有局部内部类的所有限制都对其生效。

4：Java异常处理

①将异常的处理递交给当前方法的调用者去处理，称为throws a Exception

②在方法（函数）中使用try-catch-finally语句自己处理异常