JAVA面向对象开发

---

面向对象开发

---

包
包本质上属于一个文件夹，在项目开发中为了避免类名称重复的问题，假如所有的java文件都放在一个文件夹中，就有可能存在覆盖问题，所以有了包的概念。在java首行使用package包名称就是定义了一个包。
访问控制权限
在JAVA中提供有四种访问控制权限：private, default, protected, public
（1）同一包中的同一类：private, default, protected, public
（2）同一包中的不同类：default, protected, public
（3）不同包中的子类：protected, public
（4）不同包中的非子类：public
关于权限的选择：属性都使用private，方法都使用public。
模式设计–单例模式（重点）
单例模式指的是一个类只允许产生一个实例化对象。对于单例模式有两种形式：懒汉式、饿汉式。
（1）饿汉式单例模式：不管是否使用Singleton类的对象，只要该类加载了，就一定会自动创建好一个公共的instance对象。

package com.single;
class Singleton{
    //在类的内部可以访问私有结构，在类的内部实例化对象
    private final static Singleton instance = new Singleton();
    private Singleton(){
        //private声明构造
    }
    //getter()方法
    public static Singleton getInstance(){
        return instance;
    }
    public void print(){
        System.out.println("haha");
    }
}
public class Test {
    public static void main(String[] args){
        Singleton singleton = null;
        singleton = Singleton.getInstance();
        singleton.print();
    }
}

既然是饿汉式，就希望整体的操作中只能够有一个实例化对象，所以会在前面追加一个final关键字。
（2）懒汉式单例模式：构造方法私有化，外部无法产生新的实例化对象，只能通过static方法取得实例化对象。当第一次使用Singleton对象的时候才会为其产生实例化对象的操作。

package com.single;
class Singleton{
    private static Singleton instance;
    private Singleton(){
        //private声明构造
    }
    public static Singleton getInstance(){
        if(instance == null){
            //表示此时还没有实例化
            instance = new Singleton();
        }
        return instance;
    }
    public void print(){
        System.out.println("hehe");
    }
}
public class Test1 {
    public static void main(String[] args){
        //声明对象
        Singleton singleton = null;
        singleton = Singleton.getInstance();
        singleton.print();
    }
}

单例模式特点
（1）构造方法私有化；
（2）类内部一定会提供一个static方法用于取得实例化对象；
（3）懒汉式存在多线程安全问题，而饿汉式不存在。
异常与捕获
为什么会存在这个概念呢？几乎所有的代码里面都会出现异常，为了保证程序在出现异常之后可以正常执行完，就需要进行异常处理。看一幅图：

这就是异常的继承类结构。可以看出来，所有的异常都是由Throwable继承而来，他有两个子类Error, Exception。
（1）Error：描述了Java运行时内部错误和资源耗尽错误。应用程序不抛出此类异常，这种内部错误一旦出现，除了告知用户并使程序安全终止以外，再无能为力，但是这种情况很少；
（2）Exception：由于程序错误导致的异常属于RuntimeException，而如果程序本身没有问题，是由于像I/O错误导致的异常属于IOException；
（3）Java中规范将派生于Error或RuntimeException类的所有异常称为非受查异常，其它异常称为受查异常。
异常的处理
异常是导致程序中断执行的一种指令流，在异常语句产生之前的语句可以正常执行完毕，而异常产生之后程序直接进行结束，为了保证程序出现异常后还能执行完毕，就需要异常处理。那么应该怎么处理呢？看例子：

package com.single;
public class Test1 {
    public static void main(String[] args){
        System.out.println("1.计算前");
        System.out.println("2.计算："+10/2);
        System.out.println("3.计算完成");
    }
}

结果正确：

1.计算前
2.计算：5
3.计算完成

但是如果除以0呢？

1.计算前
Exception in thread "main" java.lang.ArithmeticException: / by zero

我们都知道，这个是错的，所以程序抛出异常，只执行了异常之前的程序，为了让程序执行完毕，进行下面的处理：

package com.single;
public class Test1 {
    public static void main(String[] args){
        System.out.println("1.计算前");
        try{
            //有可能出现异常的语句
            System.out.println("2.计算："+10/0);
        }catch(ArithmeticException e){
            //异常类 + e （表示异常对象）
            System.out.println("异常已经处理");
        }
        System.out.println("3.计算完成");
    }
}

1.计算前
异常已经处理
3.计算完成

进行了异常处理，程序执行完毕。
处理异常的方法：try...catch, try...finally, try...catch...finally.
上面的代码虽然进行了异常处理，但是用户并不能知道出现了什么异常，所以为了明确异常信息，可以直接输出异常类对象，或者调用printStackTrace()方法进行完整异常信息的输出。对上面的例子进行改进：

package com.single;
public class Test1 {
    public static void main(String[] args){
        System.out.println("1.计算前");
        try{
            //有可能出现异常的语句
            System.out.println("2.计算："+10/0);
        }catch(ArithmeticException e){
            //异常类 + e （表示异常对象）
            //打印出异常信息
            e.printStackTrace();
            System.out.println("异常已经处理");
        }
        System.out.println("3.计算完成");
    }
}

1.计算前
异常已经处理
3.计算完成
java.lang.ArithmeticException: / by zero

此处需要注意的是：输出异常信息的位置与调用printStackTrace()方法的位置无关。若使用finally，此时不管出现异常，最终都要执行finally程序代码，所以finally会作为程序统一出口。看下面的例子：

package com.single;
public class Test1 {
    public static void main(String[] args){
        System.out.println("1.计算前");
        try{
            //有可能出现异常的语句
            System.out.println("2.计算："+10/0);
        }catch(ArithmeticException e){
            System.out.println("异常已经处理");
        }finally{
            System.out.println(10/2);
        }
        System.out.println("3.计算完成");
    }
}

1.计算前
异常已经处理
5
3.计算完成

当然这里还有一个问题就是：异常往往是未知的，通过catch捕获异常的时候如果没有捕获指定的异常，程序依然无法进行处理，所以此时就需要多个catch.不过这显然不是一个很好的办法，那应该怎么办呢？这就需要清楚异常地处理流程。
throws关键字
在进行方法定义时，如果要明确告诉调用者本方法可能产生哪些异常，就可以使用throws方法进行声明，也就是说，如果该方法出现问题后不希望进行处理，就使用throws抛出。主方法也是一个方法，所以主方法也可以使用该关键字抛出异常，这个时候如果产生异常就会交给java虚拟机(JVM)处理。
throw关键字
throw表示人为进行异常抛出，用于方法内部。即异常类对象实例化不希望由JVM产生而由用户产生，就使用该关键字。
RuntimeException
方法上明确抛出异常，但是在调用的时候会发现即使没有进行异常处理，也可以正常进行，这就是RuntimeException.该异常类可以不需要强制性进行异常处理。Exception是RuntimeException的父类，使用Exception定义的异常都强制要求异常处理。常见的RuntimeException有：ClassCastException, NullPointerException.