3_面向对象

##1、面向对象的三个特征

封装

继承

多态

##2、当一个对象被创建时，若没有赋值的话会进行自动初始化赋值

byte 0

short 0

int 0

long 0

float 0

double 0

char ‘\u0000’

boolean false

引用类型 null

##3、对象的比较
###（1）==：比较两个变量的值是否相等（ Person p = new Person()中的 p 的值是地址）

###（2）equals():比较两个对象的内容是否相同

##4 匿名对象
###（1）定义：
  不定义对象的句柄，直接调用这个对象的方法

###（2）示例：
new Person().show();

###（3）应用场合：
####1° 只需要进行一次方法调用

####2° 把匿名对象作为实参传递给函数调用

##5 模块设计要求
###（1） 强内聚：许多功能尽量在类的内部独立完成，不让外面干预

###（2） 弱耦合：提供给外部尽量少的方法调用

##6 构造函数
###（1） 可重载

###（2） 没写构造函数的话有默认构造函数，它什么也不做

###（3） 我们无法在程序中调用构造函数，但是可以在一个构造函数中使用this调用其他重载的构造方法。根据其中的参数列表，选择相应的构造函数。

例如：

public Person(String name)
{
    this.name = name;
}
public Person(String name, int age)
{
    this(name);
    this.age = age;
}

##7 finalize方法 与 System.gc
###（1） finalize方法是 Object类的方法，任何一个类都从Object继承了这个方法。

###（2） finalize()类似于 C++ 的析构函数，只不过是由Java已经提供好的垃圾回收机制，何时启动finalize()函数无规律。

###（3） System.gc() 可以强制启动垃圾回收器来回收垃圾

##8 函数的参数传递
###（1） Java在向函数传递参数时，只采用 值传递 的方式

###（2） 基本类型数据传递的是数据的值本身； 引用类型数据传递的是对象的句柄（引用）本身，而不是对象本身。因此，对象的内容可以改变，对象的引用不能改变。

##9 static关键字
###（1） 静态成员变量（类属性）属于一个类，被这个类的所有对象共有

###（2） 静态成员函数（类方法）
####1° 可以用类直接调用，也可以用类的实例对象调用

####2° System.out.println() 中， System是类名，out是System类的一个静态成员变量，println()是out所引用的对象的方法

####3° 静态方法直接调用其他静态变量和方法，因为非静态的变量和方法要先创建实例对象才能使用

####4° 静态方法不能使用 this 和 super 关键字

####5° main()方法永远是静态的，所以main()方法中不能直接访问类中的非静态成员

###（3） 静态代码块
####1° 示例

class Hahaha
{
    static String country;

    static                        //静态代码块
    {
        country = "china";
        System.out.println("haha");
    }
}

####2° 类被载入时，静态代码块被执行 且 只执行一次

####3° 静态代码块的作用时进行 静态成员变量的初始化

####4° 类是第一次被使用时装载， 而不是程序启动时装载

###（4） 单例模式
####1° 要点
I 类的构造函数为private，这样外部无法new新的类实例

II 为了保证类有一个实例，使用静态成员变量

III 为了对外提供接口，提供一个静态成员函数，并且静态成员变量设为private

####2° 示例
public class Singleton
{
private static final Singleton instance = new Singleton();

    private Singleton()
    {
    }

    public static Singleton getInstance()
    {
        return instance;
    }
}

##10 继承
###（1） extends关键字表示子类具有父类所有的属性与方法

public class Person          //父类
{
    public String name;
    public int age;
    
    public String getInfo() { ... }
}

public class Student extends Person    //extends 继承
{
    public String school;

    public String study()  { ... }
}

###（2） Java只支撑单继承，不允许多重继承。即：一个类只能继承一个类，但是一个类可以被多个类继承

###（3） 可以多层继承

例如：

class A 
{
}
class B extends A
{
}
class C extends B
{
} 

###（4） 子类继承父类所有的成员变量和方法，但是不继承父类的构造方法

###（5） 如果子类需要调用父类的构造方法，需要使用语句super

例如：

class Person
{
   public String name;
   public int age;

   public Person()
   {
   }

   public Person( String name, int age)
   {
       this.name = name;
       this.age  = age;
   }
}

class Student extends Person
{
    public Student( String name, int age, String school )
    {
        super(name, age);         //使用super语句调用父类的构造方法
        
        this.school = school;
    }
}

###（6） 如果子类的构造方法没有显示调用父类构造方法，也没有使用this关键字调用重载的其他构造方法，则在产生子类的实例对象时，默认调用父类的无参数的构造方法。（创建子类对象的时候，子类构造器中默认调用父类无参数的构造方法，而且位于方法中的第一条语句。所以创建子类对象的时候先创建父类对象）

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

##11 覆盖父类的方法
###（1） 子类对父类继承的方法进行改造称为方法的的覆盖，覆盖方法必须和被覆盖方法具有相同的方法名称、参数列表和返回值类型

###（2） 如果子类中想要调用父类中的被覆盖的方法，可以用 super.方法打格式

例如：

class Person
{
    public String name;

    public void getInfo()
    {
        System.out.println(name);
    }
}
class Student extends Person
{
    public String school;

    public void getInfo()
    {
        super.getInfo();     //用super调用父类中被覆盖的方法

        System.out.println(school);
    }
}

###（3） 覆盖方法时，不能使用比父类中被覆盖的方法更严格的访问权限（例如父类某方法是public，子类覆盖方法不能是private的）

##12 final 关键字
###（1） final标记的类不能被继承

###（2） final标记的方法不能被子类重写

###（3） final标记的变量（成员变量或局部变量）为常量，只能赋值一次

###（4） final标记的成员变量必须在 声明的同时 或 在类的构造方法中显式赋值，才能使用

例如：

class Hahaha
{
    final int x = 3;
    ...
}

或

class Hahaha
{
    final int x;

    Hahaha()
    {
        x = 3;
        ...
    }
}

###（5） public static final 用于定义全局常量， 这样的常量只能在定义时赋值，不能再构造函数里赋值

##13 抽象类 abstract
###（1） 一些类方法只有定义，没有实现，这样的方法称之为抽象方法

###（2） 包含抽象方法的类称之为抽象类，一个抽象类中可以有一个或多个抽象方法

###（3） 抽象类和抽象方法必须由 abstract 修饰

###（4） 抽象类不能被实例化

###（5） 抽象类的子类必须覆盖所有的抽象方法后才能被实例化，否则这个子类也是抽象类

###（6） 示例

abstract class A
{
    abstract int aa(int x);

    void display()
    {
    }
}

##14 接口 interface
###（1） 如果一个抽象类中的所有方法都是抽象的，那么可以使用接口定义。接口是抽象方法和常量值的定义的集合，接口中的方法都是抽象的

###（2) 接口中的常量和方法都是默认 public 修饰的

###（3） 接口里的变量默认是 public static final 标识的

###（4） 接口的示例

interface Runner    //默认是public的
{
    int ID = 1;     //默认是public static final的

    void Run();     //抽象方法
}

###（5） 可以定义一个新的接口，继承已有接口

interface Animal extends Runner
{
    void breathe();
}

###（6） 可以定义一个类，用implements关键字实现一个接口中的所有方法

class Fish implements Animal
{
    public void run()
    {
       ...
    }
    public void breathe()
    {
       ...
    }
}

###（7） 可以定义一个抽象类，用implements关键字实现一个接口定义中的部分方法

abstract class LandAnimal implements Animal
{
    public void breathe()
    {
        ...
    }
}

###（8） 利用接口可以实现多重继承的目的。同时由于接口中没有任何实现，避免了一个类有可能继承了同一个方法的不同实现的危险

###（9） 一个类可以在继承一个父类的同时，实现一个或多个接口，此时 extends 必须位于 implements 关键字之前

class Bird extends Animal implements Runner, Flyer
{
}

###（10） 多个无关的类可以实现同一个接口， 一个类可以实现多个无关的接口

##15 对象的多态性
###（1）子类能够自动转换成父类类型

###（2）父类不能自动转换成子类类型

###（3）instanceof 操作符：
  用于判断一个类是否实现了某个接口，或一个实例对象是否属于一个类

例如：

public static void CallA(A a)
{
    if ( a instanceof B)
    {
        B b = (B)a;

        b.func1();
        b.func2();
        b.func3();
    }
    else
    {
        a.func1();
        a.func2();
    }
}

##16 Object类
###（1）是所有类的父类，如果没写继承关系，那么一个类默认继承Object类

###（2）Object类有一个 equals方法

##17 对象的多态性
###（1）应用程序不必为每一个子类编写功能调用，只需要对抽象基类进行处理即可。根据传进来的参数决定调用哪一个子类的方法

###（2）编译器无法根据一个类中有哪些方法，判断它属于哪个类的子类，只能从extends 和 implements关键字上判断

###（3）接口interface用于软件模块的插接。一个类若要实现一个接口，那么它必须实现接口中的所有方法。

##17 匿名内部类

##18 异常
###（1）异常定义了程序中遇到的非致命的错误

###（2）形式：

try 
{
    ...
}
catch (Exception e)
{
    ...
}

###（3）当try代码块中的语句出现了异常，程序会跳转到catch中执行，而不会执行try代码块中发生异常语句后的代码

###（4）throw关键字：
  在方法中声明throw Exception，则调用该方法时必须使用try…catch，否则编译会报错

例如：

public class TextException
{
    public static void main(String[] args)
    {
        try
        {
            int result = new Test().devide(3, 1);
            System.out.println(result);
        }
        catch ( Exception e )
        {
            e.printStackTrace();
        }
   }
}

class Test
{
    public int divide( int x, int y ) throws Exception
    {
        int result = x/y;
        return result;
    }
}

###（5）Exception类是所有异常类的父类,常见的异常有 ArithmeticException、NullPointerException、ArrayIndexOutOfBoundsException

###（6）可以通过extends Exception类自定义异常类型

例如：

class DevideByMinusException extends Exception
{
    int devisor;

    public DevideByMinusException(String msg, int devisor)
    {
        super(msg);
        this.devisor = devisor;
    }

    public int getDevisor()
    {
        return devisor;
    }
}

class Test
{
    public int devide( int x, int y)  throws ArithmeticException, DevideByMinusException   //可以抛出不止一个异常
    {
        if ( y < 0 )
        {
            throw new DevideByMinusException("被除数为负", y);
        }

        int result = x/y;
        return result;
    }
}


public class TestException
{
    public static void main(String[] args)
    {
        try
        {
            int result = new Test().devide(3,-1);
            System.out.println("the result is " + result);
        }
        catch ( DevideByMinusException e)
        {
            System.out.println( e.getMessage() );    //继承Exception父类的方法
            System.out.println("the devisor is " + e.getDivisor() );
        }
        catch (ArithmeticException e)
        {
            System.out.println( e.getMessage() );    //继承Exception父类的方法
        }
        catch (Exception e)
        {
            System.out.println( e.getMessage() );    //继承Exception父类的方法
        }

        System,out.println("normal running");
    }
}

###（7）try后面可以跟随多个异常，先被哪个异常捕捉到就执行哪个catch块。由于Exception类是所有异常类的父类，所以它可以处理所有异常，因此要放在catch的最后，否则其他的catch就失去意义了

###（8） finally关键字
  finally关键字用于try…catch的最后，格式为

try
{
   ...
}
catch
{
   ...
}
finally
{
   ...
}

无论try和catch中发生了什么，即使写了 break return 等， finally块也要被执行，唯一不执行finally块的方法是 System.exit(0)

###（9） try代码块、catch代码块、finally代码块中间不能有其他语句

##19 包
###（1） 格式：

packages org.it315         //表示有一个org的包，内含一个it315的子包，这个子包中包含两个类
public class Test
{
    public static void main( String[] args)
    {
       ...
    }
}

class Hello
{
    ...
}

###（2） 同一个包中的类相互访问不用指定包名

###（3） package语句必须位于源文件的最前面，每个源文件只能声明一个包

###（4）import语句

####1° 不使用 import

//TestPackage.java
package org.it315;
public class TestPackage
{
    public static void main(String[] args)
    {
        new org.it315.example.Test().print();
    }
}

//Test.java
package org.it315.example;
public class Test
{
    public void print()
    {
        System.out.println("haha");
    }
}

####2° 使用 import
//TestPackage.java

package org.it315;
import org.it315.example.*;              //导入整个org.it315.example中的所有类
//import org.it315.example.Test;         //导入org.it315.example中的Test类

public class TestPackage
{
    public static void main(String[] args)
    {
        new Test().print();
    }
}

//Test.java
package org.it315.example;
public class Test
{
    public void print()
    {
        System.out.println("haha");
    }
}

###（5）使用import时，导入父包，并不会默认导入子包

####例如import java.awt.*; 不会把 java.awt.event.*一并导入

###（6）常用的JDK包
####1° java.lang：核心类，包括Math,String,Integer,System,Thread等（会自动import)

####2° java.io： 输入输出

####3° java.util：使用工具类

##20 访问控制
###（1）成员方法和变量的访问控制

可以被同一个类中的方法访问？ private, default, protected, public

可以被同一个包中的其他类访问？ default, protected, public

可以被子类访问？ protected,public

可以被其他包中的类访问？public

###（2）类的访问控制

public：可以被所有的类访问

default：只能被同一个包中的类访问

##21 命名习惯
###（1） 包的字母一律小写

###（2） 类名、接口名应当使用名词，每个单词首字母大写

###（3） 方法名、变量名第一个单词首字母小写，后面每个单词首字母大写

###（4） 常量名所有字母大写

##22 jar文件
###（1）当开发了很多类时，为了把这些类提供给别人使用，通常会将这些类压缩到一个jar文件中。使用时，java虚拟机会自动在内存中解压这个jar文件，把这个jar文件当作一个目录，在这个jar文件中寻找所需要的类及包名对应的目录结构

###（2）jar命令：
jar命令在cmd窗口中可以对大量的.class文件进行压缩，存为.jar文件

###（3）使用WinRar可以查看jar文件中的目录结构