封装

1.封装的概念
    （1）将东西包装在一起，然后以新的完整的形式呈现出来（即将属性和方法封装到类里面，通过添加访问修饰符来限制访问权限，以达到信息隐藏的目的）
    （2）信息隐藏：隐藏对象的实现细节，不让外部直接访问到
    （3）将数据和方法包装进类中，加上具体实现的隐藏，共同被称作封装，其结果是一个同时带有特征和行为的数据类型。（定义类，定义其属性、方法的过程称为封装类）
    （4）信息隐藏是OOP最重要的功能之一，也是使用访问修饰符的原因。
    （5）信息隐藏的原因包括：
        ①对模块的任何实现细节所做的更改不会影响使用该模块的代码
        ②防止用户意外修改数据
        ③使模块易于使用和维护
    （6）访问修饰符：
        ①public（公开的）：该类或非该类均可访问，权限最大
        ②private（私有的）：只有该类可以访问，权限最小
        ③protected（受保护的）：该类及其子类的成员可以访问，同一个包中的类也可以访问
        ④默认：同一个包中的类可以访问
    （7）属性封装的实现
        ①修改属性的可见性来限制对属性的访问
        ②为每个属性创建一对赋值（setter）方法和取值（getter）方法，用于公开对这些属性的访问接口
        ③在setter和getter方法中，根据需要加入对属性操作的限制

public class Demo {
	private String name;
	private int age;

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		if (age < 22) {
			System.out.println("错误！最小年龄应为22岁！");
			this.age = 22;
		} else {
			this.age = age;
		}
	}
}

     注意：除非必须公开底层实现细节，否则应该将所有属性指定为private加以封装，让外界不能直接访问修改，只能对外界提供set/get方法。使用属性封装，通过增加数据访问限制，增强了类的可维护性。
    （8）封装方法的目的：
        ① 隐藏方法实现细节（方法体），向外部提供公开接口（方法头），以供安全使用
        ② 简化调用，方便修改维护
        ③ 根据需要，可以私有化方法以供类内部使用
类的修饰符：
    1.前缀修饰符(public,abstract,final)
    2.后缀修饰符(extends,implements)
方法的修饰符有两类：
    1.访问控制修饰符(public,private,protected,package)
    2.方法本身修饰符(static,final,abstract,native,synchronized)
2.UML类图
    unified Modeling Language （UML）又称统一建模语言或标准建模语言，它是一个支持模型化和软件系统开发的图形化语言。为软件开发的所有阶段提供模型化和可视化支持，包括由需求分析到规格，到构造和配置。
3.构造方法
    （1）类的构造方法的概念和作用
        构造方法负责对象初始化工作，为对象的属性赋合适的初始值。创建对象时，其类的构造方法确保在用户操作对象之前，系统保证初始化的进行。（即对属性进行初始化）
    （2）构造方法的语法规则
        ① 构造方法名与类名相同
        ② 没有返回类型
        ③ 方法实现主要为字段赋初始值
    （3）构造方法的调用
             构造方法的调用很特别：通过new操作符（返回新建实例的引用），即创建对象的同时调用构造方法来对属性进行初始化。也就是在我们创建对象的时候自动调用的。注意：当我们在构造一个对象的时候，一定会调用构造方法，所以java系统保证每一个类都有构造方法。当一个类没有显示声明构造方法的时候，系统会有一个默认的无参构造方法。
4.this关键字
（1）this关键字的特点：
       ① 在类的方法中使用this关键字代表的是调用此方法的对象的引用(可以认为this和引用变量是同一个人，存的是同样的地址)
       ② this可以看做是一个变量，它的值是当前对象的引用
       ③ 使用this关键字可以处理方法中的成员变量和形参同名的问题
       ④ 当在方法内需要用到调用该方法的对象时，就可以用this
       ⑤ 在类的构造方法中可以调用this（[参数列表]）来调用该类的指定构造方法

public class Teacher {
	private String name = "";
	private int age;
	private String city = "";

	public Teacher() {
		System.out.println("这是一个无参的构造方法");
	}

	public Teacher(String name, int age, String city) {
		// 当一个构造方法去调用另一个构造方法的时候，对this的调用必须是该构造器中的第一条语句，因为要确保初始化的操作先被执行
		// 构造方法中的this指的是正在被创建的对象
		this();
		this.name = name;
		this.age = age;
		this.city = city;
	}

	// 同一个类中的方法去调用同一个类中的其它方法的时候，this可加可不加，不加时，程序在编译的时候会自动加上。
	public String toString() {
		// 这里的this可以省略不写
		return "名字：" + this.name + ",年龄：" + this.age + ",城市：" + this.city;
	}
}

5.static关键字
    1.static关键字的特点
    （1）用来修饰类的成员（属性和方法）：修饰成员变量的称之为类变量（静态变量），修饰成员方法的称之为类方法（静态方法）。
    （2）当类被加载的时候就会被加载，优先于对象的存在，并且有默认初始值。
    （3）用来修饰语句块（称之为静态代码块）。static修饰的静态代码块，在类被加载的时候就会执行，先于构造方法之前执行，只会执行一次，用来对静态成员做初始化。
    （4）静态修饰的成员被所有的对象共享，调用的时候可以直接类名.成员来进行访问。
    2.static关键字注意事项
    （1）静态方法中只能访问外部的静态成员，静态方法中不能出现this关键字。

​
public class Demo01 {
	/**
	 * 一个类可以构造多个对象，每个对象都有各自的一份属性。这里acc1.num1++,修改的是acc1这个引用变量所指向内存空间里面num1的值，
	 * 不会影响acc2这个引用变量所指向的内存空间里面num1，num2的值。因为他们两个是互相独立的，每个对象都有自己的一份独立的属性。
	 */
	public static void main(String[] args) {
		Account acc1 = new Account();
		acc1.num1++;
		acc1.showNum1();
		acc1.showNum2();

		Account acc2 = new Account();
		acc2.showNum1();
		acc2.showNum2();
	}
}

class Account {
	public int num1 = 1;
	public int num2 = 2;

	public void showNum1() {
		System.out.println(num1);
	}

	public void showNum2() {
		System.out.println(num2);
	}
}

public class Demo02 {

	/**
	 * 一旦一个属性被static关键字修饰，这个属性就被称之为静态变量（类变量），它不属于任何一个对象，被多个对象所共享。
	 * 访问方式可以直接通过类名.属性名这种方式。(因为num1被acc1这个引用变量修改了，而num1又是被多个对象所共享，所以acc2
	 * 取出的num1的值为修改后的值而不是之前的1。这里的num2不能通过类名.属性名访问是因为它不是静态的，不是静态的说明它属于某个
	 * 具体的对象的，要访问这个属性就要通过对象名.属性名来访问。)
	 */
	public static void main(String[] args) {
		Account acc1 = new Account();
		acc1.num1++;// 可以直接写成Account.num1++;
		acc1.showNum1();

		Account acc2 = new Account();
		acc2.showNum1();
	}
}

class Account {
	public static int num1 = 1;
	public int num2 = 2;

	public void showNum1() {
		System.out.println(num1);
	}

	public void showNum2() {
		System.out.println(num2);
	}
}

前提条件：将上面的showNum1方法改为静态方法，即：
    public static void showNum1(){
         System.out.println(num1);
    }
    (1)在方法体中加上下面这条语句：System.out.println(num2);程序就会报错，因为这个方法是静态方法，是属于类的，在类加载的时候就可以直接调用静态方法，而类加载的时候，对象还没有产生。即当我们通过类名.属性名调用这个方法的时候，对象还没有产生，而你需要访问对象里面的一个属性num2，所以静态方法中不能直接访问非静态的变量。静态方法里只能访问外部静态的东西。
    (2)在方法体中加上下面这条语句：System.out.println(this.num2);程序会报错。因为静态方法中不能使用this关键字，因为this指的是当前对象的引用，当对象存在的情况下，才会有this,而对象都没有产生，怎么会有this呢。
    (3)非静态的方法可以访问静态的内容和非静态的内容。  
    (4)此外给属性和方法都加上static并不好，因为它破坏了面向对象的特点。我们说每一个对象都有自己的属性，若其都加上static，就变成了大家都可以共享了，破坏了面向对象的封装性。此外如果属性被static修饰的话，说明属性的生命周期比较长，只有当程序结束的时候，内存才会被释放，而如果是某个对象的属性，当该属性运行完就会被释放，占用内存的时间比较短。那什么时候才用static呢？
        ① 类中没有属性或者属性都是静态的，可以把方法声明为static。
        ② 类中没有任何属性，只有方法，而且这些方法专门为其他的类服务，比如Arrays类。它里面是没有属性的，它是专门提供很多方法来对数组进行操作，这种情况就可以把类中的所有方法定义为静态的，调用起来就很方便，不用产生对象，直接通过类名.方法名直接访问。
6.单例模式
    （1）定义：单例模式的意思就是只有一个实例，单例模式确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例，这个类称为单例类。

public class Demo {
	public static void main(String[] args) {
		// 程序在执行的时候，构造方法中的打印语句只会执行一次。
		SingleTon singleTon1 = SingleTon.getInstance();
		SingleTon singleTon2 = SingleTon.getInstance();
	}
}

class SingleTon {
	private static SingleTon singleTon = new SingleTon();

	private SingleTon() {
		System.out.println("构造方法私有化");
	}

	public static SingleTon getInstance() {
		return singleTon;
	}
}

    备注：这里即使多次调用getInstance()方法，返回的都是同一个对象。因为该对象是静态的，在内存中只有一份，而且在调用getInstance()方法的时候，SingleTon这个类已经被加载，一加载就会对静态变量先进行分配空间，产生一个对象，产生对象的时候就会调用构造方法，接下来再调用getInstance()方法的时候，返回的是同一个静态的SingleTon对象，这种方式称之为“恶汉式”加载。所谓“恶汉式”加载就是这个类被加载的时候，这个对象已经产生了，不管有没有调用getInstance()方法，其实这个对象已经产生，假设不去调用getInstance()方法，产生这个对象就会很消耗资源，无缘无故浪费内存空间。所以我们还有另外一种做法（即在调用getInstance方法的时候再产生一个对象）

public class Demo {
	public static void main(String[] args) {
		SingleTon singleTon1 = SingleTon.getInstance();
		SingleTon singleTon2 = SingleTon.getInstance();
	}
}

class SingleTon {
	private static SingleTon singleTon = null;

	private SingleTon() {
		System.out.println("构造方法私有化");
	}

	public static SingleTon getInstance() {
		if (singleTon == null) {
			singleTon = new SingleTon();
		}
		return singleTon;
	}
}

      备注：当我们调用getInstance()方法的时候，判断singleTon对象是不是为空，为空说明还没有产生对象，在产生一个对象，再返回。再次去调用这个方法的时候，这个条件就不会成立，因为这个对象是静态的，已经存在的，为大家所共享的。所以不可能是null，直接返回singleTon就可以了。这种加载方式称之为懒汉式加载。
     这就是单例模式，一个类只能产生一个对象，而且由它自己内部产生，产生好以后，通过对外公开一个方法，让外面人去使用我内部构造出来的对象。
7.方法重载
    （1）多数程序设计语言要求为每个方法（函数）提供一个独一无二的方法名，不存在方法重载的概念。在java中，规定方法签名是解析方法的规则而不是方法名，为方法的重载开创了条件。在java当中，判断这个方法是不是同一个方法，是通过方法签名来判断的，而不是通过方法名。方法重载使得在一个类中，方法名相同而参数列表不同的方法可同时存在，代表相似的行为或功能。
    （2）重载的概念：
        前提条件是同一个类中，同名不同参的方法，称为重载方法。注意：仅有返回值类型不同的方法不能称为重载，也就是说方法的重载跟方法的返回值类型没有任何关系，即方法的重载必须方法签名不同。这里强调一下参数列表不同包括：参数类型不同；参数个数不同；参数顺序不同；与方法的返回值类型无关。构造方法重载是方法重载的典型示例。
    （3）构造方法也是一个方法，只不过它这个方法声明和调用都比较特殊。声明的时候它的方法名必须跟类名一致，而且不能有返回值类型，调用的时候，通过new关键字来调用。一个类里面可以有多个构造方法，就构成了构造方法的重载。通过调用不同的构造方法来表达对象不同的初始化方式。
8.包(package)
    (1)打包的意义：
        标准Java库是由一系列包组成，包括java.lang(称之为java语言包)，java.util(称之为java工具包)，java.net(java网络包)等等。标准java包就是层次型包结构，就如同硬盘上嵌套的子目录一样，我们可以使用嵌套层次结构来组织包，易于查找和维护。
    (2) Java的包是为了更好的规划代码，防止命名冲突和混乱，所以java出现了打包机制。当把类组织起来放进一个包内时，也就给包中的成员赋予了相互访问的权限，包访问权限为把类聚集在一个包中这一做法提供了意义和理由。
    (3) 命名规则
        ① 包名由小写单词组成，且打包语句必须为java源程序的第一条语句；
        ② Java程序员都可以编写属于自己的Java包，为了保障每个Java包命名的唯一性，编程规范要求程序员在自己定义包的名称之前加上唯一前缀；
        ③ 由于互联网上的域名称是不会重复的，所以一般推荐采用公司在互联网上的域名的倒置作为包的唯一前缀
        ④ 一个类可以使用同一个包中所有类以及其他包中的所有公开类，包本身就有访问自己的权限。不同包中的其他类是不能访问使用默认修饰符的属性和方法
        ⑤ 我们可以通过两种方式访问其他包中的公开类：
            第一种：简单在每个类前面加上完整的包名，例如：
                java.util.Date today = new java.util.Date();// 全局路径
            第二种：更简洁更通用的方式是：使用import语句来导包
                import语句提供了引用其他包中类的快捷方式，可以免去使用完整包名的累赘。如：
                import java.util.Date; //导入特定类
                import java.util.*; // 导入整个包