Java—包及访问控制权限

一.包的定义：

在Java程序中的包主要用于将不同功能的文件进行分割。在之前的代码开发中，所有编译后的*.class文件都保存在同一个目录中。这样一来就会有一个问题：如果出现了同名文件，就会发生文件的覆盖问题，因为在同一个目录中不允许有重名文件。想要解决同名文件冲突的问题就必须设置不同的目录，因为在不同的目录下可以有重名文件。所谓的包其实指的就是文件夹。在Java中用package关键字来定义包，此语句必须写在 *.java文件的首行。

1.定义包：

package com.yooth.demo ;
public class Hello {
    public static void main(String args[]) {
        System.out.println("Hello World");
    }
}

本程序代码的功能就是在屏幕中输出一个字符串信息，但是唯一的区别是将Hello程序类定义在了com.yooth.demo的包中
在JDK中提供两种自动的打包编译指令：
1.打包编译：java -d . Hello.java
“-d”：生成目录，根据package的定义生成；
“.”:设置保存的路径，如果为“.”表示在当前所在路径下生成。
2.在解释程序的时候不要进入到包里面，应该在包外面输入类的完整名称。
输入：java com.yooth.Hello

2.包的导入：

使用包可以将一个完整的程序拆分为不同的文件进行分别保存，这样就会造成一个问题，不同包之间有可能要进行相互访问，此时就需要使用包的导入（import语句）操作。
1.定义一个com.yooth.util.Message的类。

package com.yooth.utli ;
public class Message {
    public void print() {
        System.out.println("Hello World");
    }
}

本程序定义了一个Message类，并且在类中定义了一个print()打印信息的方法。
2.定义一个com.yooth.test.TestMessage的类，这个类要使用Message类。

package com.yooth.test ;
import com.yooth.utli.Message ;
public class TestMessage {
    public static void main(String args[]) {
        Message msg = new Message() ;
        msg.print();
    }
}

本程序由于要使用到Message类，所以使用了import语句根据类的名称进行导入，导入后直接实例化Message类对象，然后调用print()方法。

3.关于public class和class声明类的区别：

1.public class：文件名称必须与类名称一致，在一个*.java文件里面只能有一个public class声明，如果一个类需要被不同的包访问，那么一定要定义为public class。
2.class:外包名称可以与类名称不一致，并且一个*.java文件里可以有多个class定义，编译后会形成多个*.class文件，如果一个类使用的是class定义，那么表示这个类只能被本包所访问。
在以后的实际的项目开发中，绝大多数情况都只会在一个*.java文件里面定义一个类，并且类的声明绝大部分使用的是public class完成的。

4.导入一个包中的多个类：

package com.yooth.test ;
import com.yooth.utli.*;

public class TestMessage {
    public static void main(String args[]) {
        com.yooth.utli.Message msg = new Message() ;
        msg.print();
    }
}

本程序假设需要导入com.yooth.utli包中的多个类，所以使用“import com.yooth.utli.*”语句简化导入操作。

5.jar命令：

在任何一个项目中一定会存在大量的*.class文件，如果将这些文件直接交给用户使用，就会造成文件过多，并且会导致程序没有结构。所以在交付用户使用之前，会使用jar命令针对*.class文件进行压缩，最终交付用户使用的往往是java归档文件。
1.-c：创建一个新的文件。
2.-v：生成标准的压缩信息。
3.-f：由用户自己指定一个*.jar的文件名称。

6.访问控制权限：

4种访问权限：private只能在一个类中访问；default只能在一个包中访问；protected在不同包的子类中访问；public为所有都可以。
关于protected：
定义com.yooth.demoa.A类：

package com.yooth.demoa ;
public class A {
    protected String info = "Hello" ;
}

定义com.yooth.demob.B类，以此继承A类：

package com.yooth.demob ;
import com.yooth.demoa.A ;
public class B extends com.yooth.demoa.A {
    public void print() {
        System.out.println("A类的info=" + super.info);
    }
}

代码测试：

package com.yooth.test ;
import com.yooth.demob.B ;
public class Test {
    public static void main(String args[]) {
        new B().print();
    }
}

本程序直接导入了B类，而后实例化对象调用print()方法，而在print()方法中利用“super.info”直接访问了父类中的protected权限属性。

7.命名规范：

1.类名称：每一个单词的开头首字母大写，例如：TestDemo。
2.变量名称：第一个单词的首字母小写，之后每个单词的首字母大写，例如：studentName。
3.方法名称：第一个单词的首字母小写，之后每个单词的首字母大写，例如：printInfo()；
4.常量名称：每个字母大写，例如：FLAG；
5.包名称：所有字母小写。

8.单例设计模式：

构造方法非私有化：

class Singleton {
    public void print() {
        System.out.println("Hello World");
    }
}
public class TestDemo {
    public static void main(String args[]) {
        Singleton inst = null ;
        inst = new Singleton() ;
        inst.print();
    }
}

在本程序中Singleton类里面存在构造方法（因为如果一个类中没有明确地定义一个构造方法，则会自动生成一个无参的、什么都不做的构造方法），所以可以直接实例化对象，再调用类中提供地print()方法。
私有化构造方法：

class Singleton {
    private Singleton() {
        
    }
    public void print() {
        System.out.println("Hello World");
    }
}
public class TestDemo {
    public static void main(String args[]) {
        Singleton inst = null ;
        inst = new Singleton() ;
        inst.print();
    }
}

本程序在实例化Singleton类对象时。程序出现了编译错误，因为构造方法私有化了，无法在外部调用，即无法在外部实例化Singleton类的对象。

class Singleton {
    private static Singleton Instance = new Singleton() ;
    private Singleton() {
    }
    public void print() {
        System.out.println("Hello World");
    }
    public static Singleton getInstance() {
        return Instance;
    }
}
public class TestDemo {
    public static void main(String args[]) {
        Singleton inst = null ;
        inst = Singleton.getInstance() ;
        inst.print();
    }
}

1.static定义的属性特点是由类名称直接调用，并且在没有实例化对象时候可以调用。类中的全部属性被封装，而封装之后想要取得属性，则要编写getter方法，这时的getter方法也应该由类名称直接调用，定义为static型。
2.如果要控制一个类中实例化对象产生个数，首先要锁定的就是类中的构造方法（使用private定义构造方法），因为在实例化任何新对象时都要使用构造方法，如果构造方法被锁，就自然无法产生新的实例化对象。
3.如果要调用类中定义的操作，那么显然需要一个实例化对象，这时就可以在类的内部使用static方法来定义一个公共的对象，并且每一次通过static方法返回唯一的一个对象，这样不管外部有多少次调用，最终一个类只能够产生唯一的一个对象。
4.Windows的回收站就属于单例设计，除了桌面上的回收站之外，每个硬盘都有一个回收站。实际每个硬盘的回收站和桌面上的回收站是同一个，也就是说在整个操作系统上只有一个回收站实例，各个地方只是引用此实例而已。

9.多例设计模式：

单例设计模式只留下类的一个实例化对象，而多例设计模式，会定义出多个对象。
定义一个表示性别的类：

package com.yooth.demo ;
class Sex {
    private String title ;
    private static final Sex MALE = new Sex("男") ;
    private static final Sex FEMALE = new Sex("女");
    private Sex(String title) {
        this.title = title ;
    }
    public String toString() {
        return this.title ;
    }
    public static Sex getInstance(int ch) {
        switch (ch) {
            case 1 :
                return MALE ;
            case 2 :
                return FEMALE ;
            case 3 :
                return null;
        }
    }
    public class TestDemo{
        public static void main(String args[]) {
            Sex sex = Sex.getInstance(2) ;
            System.out.println(sex);
        }
    }
}

本程序首先定义了一个描述性别的多例程序类，并且将构造方法进行封装，然后利用getInstance()方法，接收指定编号后返回同一个实例化好的Sex类对象。