关键字的使用

this 关键字

可以调用的结构：属性、方法、构造器

this 调用属性、方法：把 this 理解为当前对象或当前正在创建的对象

this 调用构造器：

1. 在类的构造器中，可以显示的使用 this(形参列表)方式，调用本类中指定的其他构造器
2. 构造器中不能通过 this(形参列表)方式调用自己
3. this(形参列表)必须声明在当前构造器的首行
4. 构造器内部，最多只能声明一个 this(形参列表)用来调用其他的构造器

package 关键字

使用说明：

1. 为了更好的实现项目中类的管理，提供了包的概念
2. 使用 package 声明类或接口所属的包，声明在源文件的首行
3. 包属于标识符，遵循标识符的命名规则
4. 每.一个就代表一层文件目录

import 关键字

使用说明：

1. 在源文件中显示的使用 import 结构导入指定包下的类、接口
2. 声明在包的声明和类的声明之间
3. 如果需要导入对个结构，则并列写出即可
4. 可以使用xxx.*的方式，表示可以导入xxx包下的所有结构
5. 如果使用的类或接口是java.lang包下定义的，则可以略import结构
6. 如果使用的类或接口是本包下定义的，则可以略import结构
7. 如果在源文件中，使用不同包下的同名的类，则必须至少一个类需要以全类名的方式显示
8. 使用xxx.*方式表明可调用xxx包下的所有结构。但是如果使用其包的子包下的结构，仍需要显示导入
9. import static:导入指定类或接口中的静态结构(属性或方法)

super 关键字

super可以调用的结构：属性、方法、构造器

super调用属性、方法：

1. 我们可以在子类的方法或构造器中，通过使用super.属性或super.方法的方式，显示的调用父类中声明的属性或方法
2. 当子类和父类中定义了同名的属性时，我们要想在子类中调用父类中声明的属性时，必须显式的使用super.属性的方式
3. 当子类重写父类方法以后，我们要想在子类的方法中调用父类中被重写的方法时，必须显式的使用super.方法的方式

super调用构造器：

1. 我们可以在子类的构造器中显式的使用super(形参列表)的方式，调用父类中声明的指定的构造器
2. super(形参列表)的使用必须声明在子类的构造器的首行
3. 在类的构造器中，针对super(形参列表)和this(形参列表)只能二选一，不能同时出现
4. 在构造器的首行，没有显式的声明super(形参列表)和this(形参列表)，则默认调用的是父类中的空参的构造器super()
5. 在类的多个构造器中，至少有一个类的构造器中使用了super(形参列表)，用来调用父类的构造器

static关键字

可以用来修饰的结构：属性、方法、代码块、内部类

static修饰属性

1. 静态变量随着类的加载而加载，可以通过类.静态变量的方式调用
2. 静态变量的加载早于对象的加载
3. 由于类只会加载一次，则静态变量在内存中也只会存在一份，存在方法区的静态域中

static变量内存解析

static修饰方法

1. 随着类的加载而加载，可以通过类.静态方法的方式调用
2. 静态方法中，只能调用静态的方法或属性
3. 非静态方法中，既可以调用非静态的方法或属性，也可以调用静态的方法或属性
4. 修饰的方法不能被重写

单例模式：

//懒汉式
class Account{
	private static Account account = null;
	private Account(){}
	public Account getAccount(){
		if(account == null){
			account = new Account();
		}
		return account;
	}
}

//饿汉式
class Account{
	private static Account account = new Account();;
	private Account(){}
	public Account getAccount(){
		return account;
	}
}

final关键字

可以用来修饰：类、方法、变量

特点：

1. final用来修饰一个类，类不可以被其他类继承
2. final用来修饰方法，表明此方法不能被重写
3. final用来修饰变量，此时的"变量"就称为是一个常量
4. final修饰属性：可以考虑赋值的位置有显示初始化、构造器初始化、代码块初始化
5. final修饰局部变量，尤其是修饰形参时，表明此形参是一个常量。当我们调用此方法时，给常量形参赋值一个实参，一旦赋值以后没救只能在方法体内使用此形参，单不能进行重新赋值
6. static final用来修饰属性：表明这是全局常量

abstract 关键字

注意点：

1. abstract可用来修饰的类、方法
2. abstract不能用来修饰属性、构造器等结构
3. abstract不能用来修饰私有方法，静态方法、final修饰的方法、final修饰的类

abstract修饰类(使用前提继承性)：

1. 此类不能实例化
2. 抽象类中一定有构造器，便于子类实例化时调用
3. 开发中都会提供抽象类的子类，让子类对象实例化，完成相关操作

abstract修饰方法：

1. 抽象方法只有方法的声明，没有方法体
2. 包含抽象方法的类一定是抽象类。抽象类中可以没有抽象类
3. 若子类重写了父类中的所有的抽象方法后，此子类方可实例化
4. 若子类没重写父类中的所有的抽象方法，则子类也是一个抽象类，需要使用abstract修饰

模板方法的设计模式：

public class TemplateTest {
	public static void main(String[] args) {
		SubTemplate template = new SubTemplate();
		template.spendTime();
	}
}

abstract class Template{
	
	//计算某段代码需要花费的时间
	public void spendTime() {
		long start = System.currentTimeMillis();
		
		code();//不确定的部分，易变的部分
		
		long end = System.currentTimeMillis();
		
		System.out.println("花费的时间：" + (end - start));
	}
	
	public abstract void code();
}

class SubTemplate extends Template{
	public void code() {
		for(int i = 2;i <= 100;i++) {
			boolean flag = true;
			for(int j = 2;j <= Math.sqrt(i);j++) {
				if(i % j == 0) {
					flag = false;
					break;
				}
			}
			if(flag == true) {
				System.out.println(i + " ");
			}
		}
	}
}

interface 关键字

使用说明：

1. 接口使用interface来定义

2. 在Java中接口和类是两个并列的结构

3. JDK7 及其以前：只能定义全局常量和抽象方法

   全局常量：public static final修饰的，书写时可以省略
   抽象方法：public abstract的
   

4. JDK8：除了可以定义全局常量和抽象方法之外，还可以定义静态方法、默认方法

   1. 接口中定义的静态方法，只能通过接口来调用
   
   3. 通过实现类的对象，可以调用接口中的默认方法，如果实现类重写了接口中的默认方法，
   在调用时仍然调用的时重写以后的方法
   
   4. 如果子类(实现类)继承的父类和实现的接口中声明了同名同参数的默认方法，在子类没
   有重写此方法的情况下，默认调用的是父类中同名同参的方法(类优先原则)
   
   5. 如果实现类实现了多个接口，而这多个接口中定义了同名同参数的默认方法，那么在实
   现类每重写的情况下报错(接口冲突)，需要我们在实现类中重写此方法
   
   6. 在子类(实现类)的方法中调用父类、接口中被重写的方法
   public void myMethod(){
   	method3(); //调用自己定义的重写的方法
   	super.method3(); //调用的是父类中声明的
   	//调用接口中的默认方法
   	CompareA.super.method3();
   	CompareB.super.method3();
   }
   

5. 接口中不能定义构造器，意味着接口不能实例化

6. Java中接口通过让类去实现(implement)方式来使用，如果实现类覆盖了接口中所有抽象方法，则此类可以实例化。如果实现类灭有覆盖接口中所有的抽象方法，则实现类仍为一个抽象类

7. Java类可以实现对个接口平

8. 接口与接口之间可以继承，而且可以多继承

代理模式：

public class NetWorkTest {
	public static void main(String[] args) {
		Server server = new Server();
		ProxyServer proxyServer = new ProxyServer(server);
		proxyServer.browse();
	}
}
interface NetWork{
	public void browse();
}
//被代理类
class Server implements NetWork{
	@Override
	public void browse() {
		System.out.println("真实的服务器访问网络");
	}
}
//代理类
class ProxyServer implements NetWork{
	private NetWork work;
	public ProxyServer(NetWork work) {
		this.work = work;
	}
	public void check() {
		System.out.println("联网前的检查工作");
	}
	@Override
	public void browse() {
		check();
		work.browse();
	}
}