1.static关键字

1.static:静态的，可以用来修饰属性、方法、*代码块（或初始化块）、*内部类

2.

static修饰属性（类变量）:

* 1.由类创建的所有的对象，都共用这一个属性

* 2.当其中一个对象对此属性进行修改，会导致其他对象对此属性的一个调用。vs 实例变量（非static修饰的属性，各个对象各自拥有一套副本）

* 3.类变量随着类的加载而加载的，而且独一份

* 4.静态的变量可以直接通过“类.类变量”的形式来调用

* 5.类变量的加载是要早于对象。所以当有对象以后，可以“对象.类变量”使用。但是"类.实例变量"是不行的。

* 6.类变量存在于静态域中。

*

* static修饰方法（类方法）:

* 1.随着类的加载而加载，在内存中也是独一份

* 2.可以直接通过“类.类方法”的方式调用

* 3.内部可以调用静态的属性或静态的方法，而不能调用非静态的属性或方法。反之，非静态的方法是可以调用静态的属性或静态的方法

* >静态的方法内是不可以有this或super关键字的！

* 注：静态的结构(static的属性、方法、代码块、内部类)的生命周期要早于非静态的结构，同时被回收也要晚于非静态的结构

public class TestCircle {
	public static void main(String[] args) {
		Circle c1 = new Circle();
		Circle c2 = new Circle(2.3);
		System.out.println(c1);
		System.out.println(c2);
		System.out.println(Circle.getTotal());
	}
}
class Circle{
	private double radius;
	private static String info = "我是一个圆";
	private int id;//编号
	private static int init = 1001;//控制每个对象的id
	private static int total = 0;//记录创建了多少个对象
	
	public Circle(){
		this.id = init++;
		total++;
	}
	public Circle(double radius){
		this.radius = radius;
		this.id = init++;
		total++;
	}
	
	
	
	public double getRadius() {
		return radius;
	}
	public void setRadius(double radius) {
		this.radius = radius;
	}
	public static String getInfo() {
		return info;
	}
	public static void setInfo(String info) {
		Circle.info = info;
	}
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	} 

	public static int getTotal() {
		return total;
	}
	public static void setTotal(int total) {
		Circle.total = total;
	}
	@Override
	public String toString() {
		return "Circle [radius=" + radius + ", id=" + id + "]";
	}
	public static void show(){
		System.out.println(Circle.info);
	}
	
	public void desc(){
		System.out.println(this.info);
	}
}

单例模式

23种设计模式

单例模式：

解决的问题：如何只让设计的类只能创建一个对象

如何实现：饿汉式 & 懒汉式

//饿汉式1
class Bank{
	//1.私有化构造器
	private Bank(){}
	//2.创建类的对象，同时设置为private的，通过公共的来调用，体现封装性
	//4.要求此对象也为static的
	private static Bank instance = new Bank();
	//3.此公共的方法，必须为static  

	public static Bank getInstance(){
		return instance;	
	}
}
//饿汉式2
class Bank{
	//1.私有化构造器
	private Bank(){}
	//2.创建类的对象，同时设置为private的，通过公共的来调用，体现封装性
	//4.要求此对象也为static的
	private static Bank instance = null;
	static{
		instance = new Bank();	
	}
	//3.此公共的方法，必须为static 
	public static Bank getInstance(){
		return instance;	
	}
}
//懒汉式
class Bank{
	private Bank(){}
	
	private static Bank instance = null;
	
	public static Bank getInstance(){
		if(instance == null){//可能存在线程安全问题的！
			instance = new Bank();		
		}	
		return instance;
	}
}

2.main方法

public static void main(String[] args){

//方法体

}

//1.main()是一个方法，是主方法，为程序的入口

//2.权限修饰符：public protected 缺省 private ---面向对象的封装性

//3.对于方法来讲：static final abstract

//4.方法的返回值：void / 具体的返回值类型（基本的数据类型 & 引用数据类型），方法内部一定要有return

//5.方法名：命名的规则：xxxYyyZzz。给方法命名时，要见名之意

//6.形参列表：同一个方法名不同的形参列表的诸多个方法间构成重载。 形参 & 实参---方法的参数传递机制：值传递

//7.方法体：方法定义的是一种功能，具体的实现由方法体操作。

3.代码块

代码块：是类的第4个成员

作用：用来初始化类的属性

分类：只能用static来修饰。

* 静态代码块：

* 1.里面可以有输出语句

* 2.随着类的加载而加载，而且只被加载一次

* 3.多个静态代码块之间按照顺序结构执行

* 4.静态代码块的执行要早于非静态代码块的执行。

* 5.静态的代码块中只能执行静态的结构(类属性，类方法)

*

* 非静态代码块：

* 1.可以对类的属性(静态的 & 非静态的)进行初始化操作，同时也可以调用本类声明的方法(静态的 & 非静态的)

* 2.里面可以有输出语句

* 3.一个类中可以有多个非静态的代码块，多个代码块之间按照顺序结构执行

* 4.每创建一个类的对象，非静态代码块就加载一次。

* 5.非静态代码块的执行要早于构造器

*

* 关于属性赋值的操作：

①默认的初始化

②显式的初始化或代码块初始化(此处两个结构按照顺序执行)

③构造器中；

—————————以上是对象的属性初始化的过程—————————————

④通过方法对对象的相应属性进行修改

4.final关键字

/*

* final:最终的 ，可以用来修饰类、属性、方法

*

* 1.final修饰类：这个类就不能被继承。如：String类、StringBuffer类、System类

*

* 2.final修饰方法：不能被重写。如：Object类的getClass()

*

* 3.final修饰属性：此属性就是一个常量，一旦初始化后，不可再被赋值。习惯上，常量用大写字符表示。

* 此常量在哪里赋值：①此常量不能使用默认初始化 ②可以显式的赋值、代码块、构造器。

*

* 变量用static final修饰：全局常量。比如：Math 类的PI

*

* >与finally finalize()区分开

*

*/

class D{

final int I = 12;

final double PI;

final String NAME;

public void m1(){

System.out.println(I);

// I = 10;

}

{

PI = 3.14;

}

public D(){

NAME = "DD";

}

public D(String name){

this();

//NAME = name;

}

}

5.抽象：abstract

重点！

abstract：抽象的，可以用来修饰类、方法

* 1.abstract修饰类：抽象类

* 1)不可被实例化

* 2)抽象类有构造器 (凡是类都有构造器)

* 3)抽象方法所在的类，一定是抽象类。

* 4)抽象类中可以没有抽象方法。

* >当我们设计一个类，不需要创建此类的实例时候，就可以考虑将其设置为抽象的，由其子类实现这个类的抽象方法以后，就行实例化

*

* 2.abstract修饰方法：抽象方法

* 1)格式：没有方法体，包括{}.如：public abstract void eat();

* 2)抽象方法只保留方法的功能，而具体的执行，交给继承抽象类的子类，由子类重写此抽象方法。

* 3)若子类继承抽象类，并重写了所有的抽象方法，则此类是一个"实体类",即可以实例化

* 4)若子类继承抽象类，没有重写所有的抽象方法，意味着此类中仍有抽象方法，则此类必须声明为抽象的！

模板方法设计模式

//模板方法设计模式

public class TestTemplate {

public static void main(String[] args) {

new SubTemplate().spendTime();

}

}

abstract class Template {

public abstract void code();

public void spendTime() {

long start = System.currentTimeMillis();

this.code();

long end = System.currentTimeMillis();

System.out.println("花费的时间为：" + (end - start));

}

}

class SubTemplate extends Template {

public void code() {

boolean flag = false;

for(int i = 2;i <= 10000;i++){

for(int j = 2;j <= Math.sqrt(i);j++){

if(i % j == 0){

flag = true;

break;

}

}

if(!flag){

System.out.println(i);

}

flag = false;

}

}

}

6.接口interface

* 接口（interface） 是与类并行的一个概念

* 1.接口可以看做是一个特殊的抽象类。是常量与抽象方法的一个集合，不能包含变量、一般的方法。

* 2.接口是没有构造器的。

* 3.接口定义的就是一种功能。此功能可以被类所实现（implements）。

* 比如：class CC extends DD implements AA

* 4.实现接口的类，必须要重写其中的所有的抽象方法，方可实例化。若没有重写所有的抽象方法，则此类仍为一个抽象类

* 5.类可以实现多个接口。----java 中的类的继承是单继承的

* 6.接口与接口之间也是继承的关系，而且可以实现多继承

* >5,6描述的是java中的继承的特点。

* 7.接口与具体的实现类之间也存在多态性

* 8.面向接口编程的思想：

工厂方法的设计模式

//接口的应用：工厂方法的设计模式

public class TestFactoryMethod {

public static void main(String[] args) {

IWorkFactory i = new StudentWorkFactory();

i.getWork().doWork();

IWorkFactory i1 = new TeacherWorkFactory();

i1.getWork().doWork();

}

}

interface IWorkFactory{

Work getWork();

}

class StudentWorkFactory implements IWorkFactory{

@Override

public Work getWork() {

return new StudentWork();

}

}

class TeacherWorkFactory implements IWorkFactory{

@Override

public Work getWork() {

return new TeacherWork();

}

}

interface Work{

void doWork();

}

class StudentWork implements Work{

@Override

public void doWork() {

System.out.println("学生写作业");

}

}

class TeacherWork implements Work{

@Override

public void doWork() {

System.out.println("老师批改作业");

}

}

代理模式

//接口的应用：代理模式（静态代理）

public class TestProxy {

public static void main(String[] args) {

Object obj = new ProxyObject();

obj.action();

}

}

interface Object{

void action();

}

//代理类

class ProxyObject implements Object{

Object obj;

public ProxyObject(){

System.out.println("代理类创建成功");

obj = new ObjctImpl();

}

public void action(){

System.out.println("代理类开始执行");

obj.action();

System.out.println("代理类执行结束");

}

}

//被代理类

class ObjctImpl implements Object{

@Override

public void action() {

System.out.println("=====被代理类开始执行======");

System.out.println("=====具体的操作======");

System.out.println("=====被代理类执行完毕======");

}

}

7.内部类

* 类的第5个成员：内部类

* 1.相当于说，我们可以在类的内部再定义类。外面的类：外部类。里面定义的类：内部类

* 2.内部类的分类：成员内部类（声明在类内部且方法外的） vs 局部内部类(声明在类的方法里)

* 3.成员内部类：

* 3.1是外部类的一个成员：①可以有修饰符（4个）②static final ③可以调用外部类的属性、方法

*

* 3.2具体类的特点：①abstract ②还可以在其内部定义属性、方法、构造器

*

* 4.局部内部类：

*

* 5.关于内部类，大家掌握三点：

* ①如何创建成员内部类的对象（如：创建Bird类和Dog类的对象）

* ②如何区分调用外部类、内部类的变量(尤其是变量重名时)

* ③局部内部类的使用

/*
 * 关于局部内部类的使用
 */
public class TestInnerClass1 {
	
}
class OuterClass{
	//局部内部类
	//如下的使用方式较少
	public void method1(){
		
		class InnnerClass{
			
		}
	}
	//常常使用一个方法，使其返回值为某个类或接口的对象。而这个类或接口在方法内部创建
	//使用方式一
	public Comparable getComparable(){
		//1.创建一个实现Comparable接口的类:局部内部类
		class MyComparable implements Comparable{
			@Override
			public int compareTo(java.lang.Object o) {
				return 0;
			}
			
		}
		//2.返回一个实现类的对象 

		return new MyComparable();
	}
	//使用方式二
	public Comparable getComparable1(){
		//返回一个实现Comparable接口的匿名内部类的对象
		return new Comparable(){
			@Override
			public int compareTo(java.lang.Object o) {
				// TODO Auto-generated method stub
				return 0;
			}
			
		};
	}
}

閱讀更多 異現場調查科 的文章

關鍵字: 设计模式 静态 设计