JAVA面向对象

面向对象的主要特点主要可以概括为封装性，继承性，多态性。

    1.封装性

        是指隐藏对象的属性和实现细节，仅对外提供公共访问方式，这就是封装性。

    2.继承性

        继承性主要描述的是类与类之间的关系，通过继承，可以在无须重新编写原有类的情况下，对原有类的功能进行扩展。

    3.多态性

       多态性指的是在程序中允许出现重名现象，它指在一个类中定义的属性和方法被其他类继承后，它们可以具有不同的数据类型或表现出不同的地方。 

类与对象

类：对某一类事物的具体描述。

类中可以定义成员变量和成员方法，其中成员变量用于描述对象的特征，也被称作属性，成员方法用于描述对象的行为，可简称为方法。

在java中，定义在类中的变量被称为成员变量，定义在方法中的变量被称为局部变量。

对象：该类事物的实例。

对象的创建与使用

    类名    对象名称    =    new    类名（）；

    对象引用.对象成员

    类的封装

1.将类中的属性私有化，即使用private修饰属性

2.在类中提供公用的可以获取属性值的getXxx方法

3.在类中提供公用的可以设置属性值的setXxx方法

构造方法    void

1.方法名与类名相同。

2.在方法名的前面没有返回值类型的声明。

3.在方法中不能使用return语句返回一个值。

构造方法的重载：只要每个构造方法的参数类型或参数个数不同即可。

this关键字：

使用this调用类的构造方法时，应该注意以下几点：

1.只能在构造方法中使用this调用其他的构造方法，不能在成员方法中使用。

2.在构造方法中，使用this调用构造方法的语句必须位于第一行，且只能出现一次。

3.不能在一个类的两个构造方法中使用this互相调用。

垃圾回收：

    1.定义finalize()方法。

    2.调用System.gc( )方法来通知java虚拟机立即进行垃圾回收。

static关键字

在定义一个类时，只是在描述某类事物的特征和行为，并没有产生具体的数据。只有通过 new 关键字创建该类的实例对象后，系统才会为每个对象分配空间，存储各自的数据。

在一个Java类中，可以使用static关键字来修饰成员变量，该变量被称作静态变量。静态变量被所有实例共享，可以使用“类名.变量名”的形式来访问。

注意：static关键字只能用于修饰成员变量，不能用于修饰局部变量，否则编译会报错。

静态方法：

在一个静态方法中只能访问用 static 修饰的成员，原因在于没有被 static 修饰的成员需要先创建对象才能访问，而静态方法在被调用时可以不创建任何对象。

静态代码块：

在 Java 类中，使用一对大括号包围起来的若干行代码被称为一个代码块，用 static 关键字修饰的代码块称为静态代码块。当类被加载时，静态代码块会执行，由于类只加载一次，因此静态代码块只执行一次。在程序中，通常会使用静态代码块来对类的成员变量进行初始化 。

        static{

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

        }

内部类

成员内部类：

在 Java 中，允许在一个类的内部定义类，这样的类称作内部类，这个内部类所在的类称作外部类。根据内部类的位置、修饰符和定义的方式可分为：成员内部类、静态内部类、方法内部类。

在一个类中除了可以定义成员变量、成员方法，还可以定义类，这样的类被称作成员内部类。在成员内部类中，可以访问外部类的所有成员 。

如果想通过外部类去访问内部类，则需要通过外部类对象去创建内部类对象，创建内部类对象的具体语法格式如下：

注意：

1.在静态内部类中只能访问外部类的静态成员

2.在静态内部类中可以定义静态的成员，而在非静态的内部类中不允许定义静态的成员

    类的继承

类的继承是指在一个现有类的基础上去构建一个新的类，构建出来的新类被称作子类，现有类被称作父类，子类会自动拥有父类所有可继承的属性和方法。在程序中，如果想声明一个类继承另一个类，需要使用extends关键字。

注意：1.类只支持单继承，不允许多重继承，也就是说一个类只能有一个直接父类

          2.多个类可以继承一个父类

          3.多层继承是可以的，即一个类的父类可以再去继承另外的父类。

          4.子类和父类是一种相对概念，也就是说一个类是某个类父类的同时，也可以是另一个类的子类。

  重写父类的方法（子父类出现一模一样的方法）

    在继承关系中，子类会自动继承父类中定义的方法，但有时在子类中需要对继承的方法进行一些修改，即对父类的方法进行重写。

  注意：1.在子类中重写的方法需要和父类被重写的方法具有相同的方法名，参数列表以及返回值类型。  

            2.子类重写父类方法时，不能使用比父类中被重写的方法更严格的访问权限，如父类中的方法是public的，子类的方法就不能是private的。

super关键字

子类不能继承父类的构造方法，但可以通过super关键字去访问父类的构造方法。

1.使用super关键字调用父类的成员变量和成员方法

        super.成员变量

        super.成员方法([参数1，参数2...])

2.使用super关键字调用父类的构造方法

        super([参数1，参数2...])

注意：通过super调用父类的构造方法的代码必须位于子类构造方法的第一行，并且只能出现一次。

结论：在定义一个类时，如果没有特殊需求，尽量在类中定义一个无参的构造方法，避免被继承时出现错误。

final关键字

    final 关键字可用于修饰类、变量和方法，它有“无法改变”或者“最终”的含义，因此被 final 修饰的类、变量和方法将具有以下特性 ：

    1.final 修饰的类不能被继承。

    2.final 修饰的方法不能被子类重写。

    3.final 修饰的变量（成员变量和局部变量）是常量，只能赋值一次。

    4.Java 中的类被 final 关键字修饰后，该类将不可以被继承，也就是不能够派生子类。

final关键字修饰变量

    被final修饰的变量为常量，它只能被赋值一次，也就是说final修饰的变量一旦被赋值，其值不能改变。

    

抽象类

抽象方法必须使用abstract关键字来修饰，当一个类中包含了抽象方法，该类必须使用abstract关键字来修饰，使用abstract关键字修饰的类为抽象类。

    在定义抽象类时需要注意：

        1.包含抽象方法的类必须声明为抽象类，但抽象类可以不包含任何抽象方法，只需使用 abstract 关键字来修饰即可。

        2.抽象类是不可以被实例化的，因为抽象类中有可能包含抽象方法，抽象方法是没有方法体的，不可以被调用。

        3.如果想调用抽象类中定义的方法，则需要创建一个子类，在子类中将抽象类中的抽象方法进行实现。

接口

    如果一个抽象类中的所有方法都是抽象的，则可以将这个类用另外一种方式来定义，即接口。接口是由常量和抽象方法组成的特殊类，是对抽象类的进一步抽象。

在定义接口时，需要使用 interface 关键字来声明，其语法格式如下 ：

    一个接口可以有多个父接口，他们之间用逗号隔开。 Java 使用接口的目的是为了克服单继承的限制，因为一个类只能有一个父类，而一个类可以实现多个接口。接口中的变量默认使用“ public static final ”来修饰，即全局常量；接口中定义的方法默认使用“ public abstract ”来修饰，即抽象方法。如果接口声明为 public ，则接口中的变量和方法全部为 public 。

    由于接口中的方法都是抽象方法，因此不能通过实例化对象的方式来调用接口中的方法。此时需要定义一个类，并使用 implements 关键字实现接口中所有的方法。一个类可以在继承的同时实现多个接口，在 implements 子句中用逗号隔开。接口的实现类声明格式如下：

接口的特点：

    1.接口中的方法都是抽象的，不能实例化对象。

    2.接口中的属性只能是常量。

    3.当一个类实现接口时，如果这个类是抽象类，则实现接口中的部分方法即可，否则需要实现接口中的所有方法。

    4.一个类通过 implements 关键字实现接口时，可以实现多个接口，被实现的多个接口之间要用逗号隔开。具体示例如下：

    

    5.一个接口可以通过 extends 关键字继承多个接口，接口之间用逗号隔开。具体示例如下：

    

    6.一个类在继承另一个类的同时还可以实现接口，此时， extends 关键字必须位于 implements 关键字之前。具体示例如下：

    

    多态(态：多种表现状态)

    1.要有继承关系(实现)

    2.要有方法重写

    3.要有父类引用指向子类对象

    在同一个方法中，这种由于参数类型不同而导致执行效果各异的现象就是多态。继承是多态得以实现的基础 。

    在 Java 中为了实现多态，允许使用一个父类类型的变量来引用一个子类类型的对象，根据被引用子类对象特征的不同，得到不同的运行结果。

Object类

它是所有类的父类，即每个类都直接或间接继承自该类。

匿名内部类

    在编写 Java 程序时，在类里面定义的类称之为内部类（ Inner Class ），内部类是外部类的一个成员。 Java 内部类可以分为：成员内部类、方法内部类和匿名内部类等 。

    如果方法的参数被定义为一个接口类型，那么就需要定义一个类来实现接口，并根据该类进行对象实例化。除此之外，还可以使用匿名内部类来实现接口。所谓匿名内部类就是没有名字的内部类，表面上看起来它似乎有名字，实际那不是它的名字。当程序中使用匿名内部类时，在定义匿名内部类的地方往往直接创建该类的一个对象。

异常

    Throwable 有两个直接子类 Error 和 Exception ，其中 Error 代表程序中产生的错误， Exception 代表程序中产生的异常。

    Error 类称为错误类，它表示 Java 运行时产生的系统内部错误或资源耗尽的错误，是比较严重的，仅靠修改程序本身是不能恢复执行的。

    Exception 类称为异常类，它表示程序本身可以处理的错误，在开发 Java 程序中进行的异常处理，都是针对 Exception 类及其子类。在 Exception 类的众多子类中有一个特殊的 RuntimeException 类，该类及其子类用于表示运行时异常，除了此类， Exception 类下所有其他的子类都用于表示编译时异常。

try...catch

异常捕获通常使用 try…catch 语句

     其中在 try 代码块中编写可能发生异常的 Java 语句， catch 代码块中编写针对异常进行处理的代码。当 try 代码块中的程序发生了异常，系统会将这个异常的信息封装成一个异常对象，并将这个对象传递给 catch 代码块。 catch 代码块需要一个参数指明它所能够接收的异常类型，这个参数的类型必须是 Exception 类或其子类。

    注意：在try代码块中，发生异常语句后面的代码是不会被执行的

finally

finally表示总是执行，try...catch后使用finally代码块来完成必须做的事情。

throws关键字

throws 关键字声明抛出异常的语法格式如下：

    throws 关键字需要写在方法声明的后面， throws 后面需要声明方法中发生异常的类型，通常将这种做法称为方法声明抛出一个异常。