Java自学之类结构扩展

面向对象中的核心组成是类与接口，在项目中会利用【包】进行一组相关类的管理，这样适合于程序代码的部分更新，也更加符合面向对象封装性的概念，同时合理地使用封装也可以方便地实现实例化对象数量的控制。

包

包的定义

在Java程序中，包主要的目的是可以将不同功能的文件进行分割。所谓的包实际上是指文件夹，在Java中可以使用package定义包名，此语句必须编写在源代码的首行。

package cn.uihtml.demo;
 class Hello {
     public static void main(String[] args) {
         System.out.println('www.uihtml.cn');
     }
 }

本程序将Hello类放在一个自定义的包中，这样一来在程序编译后就必须将*.class文件保存在指定的目录中。

手工建立程序包目录非常麻烦，此时最好的做法是进行打包编译处理。

javac -d . Hello.java

【-d】表示要生成目录，而目录的结构就是package定义的结构。

【.】表示在当前所在的目录中生成程序类文件。

包的导入

利用包的定义可以将不同功能的类保存在不同的包中以实现分模块开发的需求，但是不同包中的类彼此之间也一定存在相互调用的关系，那么这时就需要使用import语句来导入被调用的其他包中的程序类。

package cn.uihtml.util;
 class Message {
     public String getContent() {
         return 'www.uihtml.cn';
     }
 }

package cn.uihtml.demo;
 import cn.uihtml.util.Message;
 class JavaDemo {
     public static void main(String[] args) {
         Message msg = new Message();
         System.out.println(msg.getContent());
     }
 }

本程序实现了不同包中类的引用，在JavaDemo类中需要使用import语句导入指定的类，这样就可以直接实例化类对象并且进行相应方法调用。

自动导入

在进行不同包类导入时，除了使用【“import 包.类”】名称的形式外，还可以使用【“import 包.*”】的通配符形式自动进行导入处理，这样可以减少import语句的编写数量。

package cn.uihtml.demo;
 import cn.uihtml.util.*;
 class JavaDemo {
     public static void main(String[] args) {
         Message msg = new Message();
         System.out.println(msg.getContent());
     }
 }

静态导入

当一个类中的全部组成方法都是static时，可以使用静态导入机制进行操作。

package cn.uihtml.util;
 class MyMath {
     public static int add(int… args) {
         int sum = 0;
         for (int item : args) {
             sum += item;
         }
         return sum;
     }
     public static int sub(int x,int y) {
         return x - y;
     }
 }

package cn.uihtml.demo;
 import static cn.uihtml.util.MyMath.*;
 class JavaDemo {
     public static void main(String[] args) {
         System.out.println(add(1,2,3,4,5));
         System.out.println(sub(10,6));
     }
 }

jar文件

jar【Java Archive，Java归档文件】是一种Java给出的压缩格式文件。

如果要使用jar文件的话，可以利用jar命令完成。在实际开发中，Java最常用的3个参数如下。

【-c】：创建一个新的文件；
【-v】：生成标准的压缩信息；
【-f】：由用户自己指定一个*.jar的文件名称；

源代码需要首先编译为*.class文件后才可以打包为jar文件。

访问控制权限

范围	private	default	protected	public
同一包的同一类	true	true	true	true
同一包的不同类		true	true	true
不同包的子类			true	true
不同包的非子类				true

对于访问控制权限，初学者把握以下的原则即可。
属性声明以private为主。
方法声明以public为主。
对于封装性实际上是有3种表示方式：private、default、protected

构造方法私有化

在类结构中每当使用new关键字都会调用构造方法并实例化新的对象，然而在设计中，也可以利用构造方法的私有化形式来实现实例化对象的控制。

单例设计模式

单例设计模式是指在整个系统中一个类只允许提供一个实例化对象，为实现此要求就可以通过private进行构造方法的封装，这样该类将无法在类的外部利用new关键字实例化新的对象，同时为了方便使用本类的方法，则可以在内部提供一个全局实例化对象供用户使用。

package cn.uihtml.demo;
 class Singleton {
     // 在类的内部进行Singleton类对象实例化，为了防止可能出现重复实例化所以使用final标记
     // 定义成员属性时直接进行实例化对象，俗称饿汉式单例设计模式
     private static final Singleton INSTANCE = new Singleton();
     // 构造方法私有化，外部无法通过new关键字实例化对象
     private Singleton() {}
     /**
     * 获取本类实例化对象方法，static方法属于类方法，可以不受实例化对象的限制进行调用
     * @return INSTANCE内部实例化对象，不管调用多少次此方法，都只会返回同一个实例化对象
     */
     public static Singleton getInstance() {
         return INSTANCE;
     }
     public void print() {
         System.out.println('www.uihtml.cn');
     }
 }

package cn.uihtml.demo;
 class JavaDemo {
     public static void main(String[] args) {
         Singleton instance = null;
         instance = Singleton.getInstance();
         instace.print();
     }
 }

对于单例设计模式也分为两种：饿汉式单例设计模式和懒汉式单例设计模式，两种单例设计模式的主要差别是在于对对象进行实例化的时机。饿汉式单例设计模式是在类中定义成员属性时直接进行实例化对象处理，懒汉式单例设计模式是在第一次使用类的时候才会进行对象实例化。

懒汉式单例设计模式

package cn.uihtml.demo;
 class Singleton {
     // 定义公共的instance属性，由于需要在第一次使用时实例化，所以无法通过final关键字定义
     private static Singleton instance;
     pirvate Singleton() {}
     /**
     * 获取本类实例化对象方法，static方法不受实例化对象的限制，可以直接调用
     * @return 返回唯一的一个Singleton类的实例化对象
     */
     public static Singleton getInstance() {
         if (instance == null) {
             instance = new Singleton();
         }
         retrun instance;
     }
     // 定义普通方法，需要进行实例化对象后。才能调用
     public void print() {
         System.out.println('www.uihtml.cn')
     }
 }

多例设计模式

单例设计模式只留有一个类的实例化对象，而多例设计模式会定义多个【有限】对象。

package cn.uihtml.demo;
 class Color {
     // 在类内部提供若干个实例化对象
     private static final Color RED = new Color('红色');
     private static final Color GREEN = new Color('绿色');
     private static final Color BLUE = new Color('蓝色');
     private String title;
     private Color(String title) {
         this.title = title;
     }
     public static Color getInstance(String Color) {
         switch(color) {
             case 'red':
                 return RED;
             case 'green':
                 return GREEN;
             case 'blue':
                 return BLUE;
             default:
                 return null;
         }
     }
     public String toString() {
         return this.title;
     }
 }

package cn.uihtml.demo;
 class JavaDemo {
     public static void main(String[] args) {
         Color c = Color.getInstance('green');
         System.out.println(c);
     }
 }

枚举

Java语言设计之初并没有枚举的概念，所以开发者不得不使用多例设计模式来代替枚举的解决方案。从JDK1.5开始，Java提供了一个新的关键字：enum，利用此关键字可以实现枚举类型的定义，利用枚举可以简化多例设计模式的定义。

package cn.uihtml.demo;
 // 枚举类
 enum Color {
     // 实例化对象
     RED,GREEN,BLUE;
 }

package cn.uihtml.demo;
 class JavaDemo {
     public static void main(String[] args) {
         Color c = Color.RED;
         System.out.println(c)
     }
 }

本程序中，所有枚举类的对象名称全部采用了大写字母定义，这一点是符合多例设计模式要求的，同时枚举类对象的名称也可以采用中文的形式进行定义。

枚举除了简化多例设计模式之外，也提供了方便的信息获取操作，利用“枚举类.values()”结构就可以以对象数组的形式获取枚举中的全部对象。

package cn.uihtml.demo;
 enum Color {
     GREEN,RED,BLUE;
 }

package cn.uihtml.demo;
 class JavaDemo {
     public static void main(String[] args) {
         for(Color c : Color.values) {
             System.out.println(c + '、');
         }
     }
 }

Enum类

枚举并不是一个新的类型，它只是提供了一种更为方便的结构，严格来讲，每一个使用enum定义的类实际上都属于一个类继承了Enum父类而已。

在枚举类中除了可以定义若干个实例化对象之外，也可以像普通类那样定义成员属性、构造方法、普通方法，但是需要记住的是，枚举的本质上是属于多例设计模式，所以构造方法不允许使用public进行定义，如果类中没有提供无参构造方法，则必须在定义一个枚举对象时明确传入参数内容。

package cn.uihtml.demo;
 enum Color {
     // 枚举对象要写在首行
     RED('红色'),GREEN('绿色'),BLUE('蓝色');
     // 成员属性
     private String title;
     // 构造方法初始化属性
     private Color(String title) {
         this.title = title;
     }
     @Override
     public String toString(){
         return this.title;
     }
 }

package cn.uihtml.demo;
 class JavaDemo {
     public static void main(String[] args) {
         for (Color c : Color.values()) {
             System.out.println(c + '、');
         }
     }
 }

通过枚举类实现接口

package cn.uihtml.demo;
 interface IMessage {
     public String getMessage();
 }

package cn.uihtml.demo;
 enum Color implements IMessage {
     RED('红色'),GREEN('绿色'),BLUE('蓝色');
     private String title;
     private Color(String title) {
         this.title = title;
     }
     @Override
     pblic String getMessage() {
         return this.title;
     }
 }

package cn.uihtml.demo;
 class JavaDemo {
     public static void main(String[] args) {
         IMessage msg = Color.RED;
         System.out.println(msg.getMessage())
     }
 }

本程序让枚举类实现了IMessage接口，这样就需要在枚举中覆写接口中的抽象方法，由于Color时IMEssage接口子类，所以每一个枚举对象都可以通过对象的向上转型实现IMessage接口对象实例化。

在枚举中定义抽象方法

枚举还有一个特别的功能就是可以直接进行抽象方法的定义，此时可以在每一个枚举对象中分别实现此抽象方法。

package cn.uihtml.demo;
 enum Color {
     RED('红色') {
         @Override
         public String getMessage() {
             return '颜色为：' + this;
         }
     }, GREEN('绿色') {
         @Override
         public String getMessage() {
             return '颜色为：' + this;
         }
     }, BLUE('蓝色') {
         @Override
         public String getMessage() {
             return '颜色为：' + this;
         }
     }
     // 定义抽象方法
     public abstract String getMessage();
 }

package cn.uihtml.demo;
 class JavaDemo {
     public static void main(String[] args) {
         System.out.println(Color.RED.getMessage());
     }
 }

枚举主要是定义了实例化对象的使用范围，同时枚举类型也可以作为成员属性类型。

原创文章，作者：ZERO，如若转载，请注明出处：https://www.edu24.cn/course/java/java-class-structure.html