Java 类的高级特征2

1. static 关键字

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

(1) static修饰属性（类变量）:

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

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

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

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

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

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

(2) static修饰方法（类方法）:

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

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

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

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

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

 2. 单例 (Singleton)设计模式

设计模式是在大量的实践中总结和理论化之后优选的代码结构、编程风格、以及解决问题的思考方式。有23种。

单例的设计模式：
 * 1.解决的问题：使得一个类只能够创建一个对象。
 * 2.如何实现？见如下的4步

//饿汉式
public class TestSingleton {
	public static void main(String[] args) {
		Singleton s1 = Singleton.getInstance();
		Singleton s2 = Singleton.getInstance();
		System.out.println(s1 == s2);
	}
}
//只能创建Singleton的单个实例
class Singleton{
	
	//1.私有化构造器，使得在类的外部不能够调用此构造器
	private Singleton(){
	}
	//2.在类的内部创建一个类的实例
	private static Singleton instance = new Singleton();
	//3.私有化此对象，通过公共的方法来调用
	//4.此公共的方法，只能通过类来调用，因为设置为static的,同时类的实例也必须为static声明的
	public static Singleton getInstance(){
		return instance;
	}
}

 

//懒汉式:可能存在线程安全问题的
public class TestSingleton1 {
	public static void main(String[] args) {
		Singleton1 s1 = Singleton1.getInstance();
		Singleton1 s2 = Singleton1.getInstance();
		System.out.println(s1 == s2);
	}
}
class Singleton1{
	//1.
	private Singleton1(){
	}
	//2.
	private static Singleton1 instance = null;
	//3.
	public static Singleton1 getInstance(){
		if(instance == null){
			instance = new Singleton1();
		}
		return instance;
	}
}

 3. 类的成员之四：初始化块（或代码块）{}

　　1.代码块如果有修饰的话，那么只能使用static。

　　2.分类：

　　　　(1) 静态代码块：用static 修饰的代码块

　　　　　　1.里面可以有输出语句

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

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

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

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

　　　　(2) 非静态代码块：没有static修饰的代码块

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

　　　　　　2.里面可以有输出语句

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

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

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

　　　3. 关于属性赋值的操作：①默认的初始化②显式的初始化或代码块初始化(此处两个结构按照顺序执行) ③构造器中；④通过方法对对象的相应属性进行修改

例子：

class Root{
	static{
		System.out.println("Root的静态初始化块");
	}
	{
		System.out.println("Root的普通初始化块");
	}
	public Root(){
		System.out.println("Root的无参数的构造器");
	}
}
class Mid extends Root{
	static{
		System.out.println("Mid的静态初始化块");
	}
	{
		System.out.println("Mid的普通初始化块");
	}
	public Mid(){
		System.out.println("Mid的无参数的构造器");
	}
	public Mid(String msg){
		//通过this调用同一类中重载的构造器
		this();
		System.out.println("Mid的带参数构造器，其参数值：" + msg);
	}
}
class Leaf extends Mid{
	static{
		System.out.println("Leaf的静态初始化块");
	}
	{
		System.out.println("Leaf的普通初始化块");
	}	
	public Leaf(){
		//通过super调用父类中有一个字符串参数的构造器
		super("尚硅谷");
		System.out.println("执行Leaf的构造器");
	}
}
public class TestLeaf{
	public static void main(String[] args){
		new Leaf();
	}
}
/*执行结果
Root的静态初始化块
Mid的静态初始化块
Leaf的静态初始化块
Root的普通初始化块
Root的无参数的构造器
Mid的普通初始化块
Mid的无参数的构造器
Mid的带参数构造器，其参数值：尚硅谷
Leaf的普通初始化块
执行Leaf的构造器
*/

 4. 关键字：final

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

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

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

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

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

　　(4) 变量用static final修饰：全局常量

排错：

public class Something { 
	public int addOne(final int x) { 
		return ++x;             //不能被修改
	}  
}

 

public class Something {
	public static void main(String[] args) {
		Other o = new Other();
		new Something().addOne(o);
	}
	public void addOne(final Other o) {
		o.i++;　　　　//没错，final修饰的是对象o 
                // o = null   // 错误，o 不能修改
	}
}
class Other {
	public int i;
}

 5. 抽象类(abstract class)

抽象类是用来模型化那些父类无法确定全部实现，而是由其子类提供具体实现的对象的类。

abstract:抽象的,可以用来修饰类、方法
　　1.abstract修饰类：抽象类

　　　　1)不可被实例化

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

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

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

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

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

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

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

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

　　3. 不能用abstract修饰属性、私有方法、构造器、静态方法、final的方法。

6. 模板方法设计模式(TemplateMethod)

抽象类体现的就是一种模板模式的设计，抽象类作为多个子类的通用模板，子类在抽象类的基础上进行扩展、改造，但子类总体上会保留抽象类的行为方式。

解决的问题：

　　当功能内部一部分实现是确定，一部分实现是不确定的。这时可以把不确定的部分暴露出去，让子类去实现。

　　编写一个抽象父类，父类提供了多个子类的通用方法，并把一个或多个方法留给其子类实现，就是一种模板模式。

7. 接口

有时必须从几个类中派生出一个子类，继承它们所有的属性和方法。但是，Java不支持多重继承。有了接口，就可以得到多重继承的效果。

(1) 接口（interface）  是与类并行的一个概念。

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

　　　　接口中的所有成员变量都默认是由public static final修饰的。

　　　　接口中的所有方法都默认是由public abstract修饰的。

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

　　3.接口定义的就是一种功能。此功能可以被类所实现（implements）。比如：class CC extends DD implements AA （先写extends，后写implements）

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

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

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

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

(2) 接口与具体的实现类之间也存在多态性

public class TestInterface {
	public static void main(String[] args) {
		Duck d = new Duck();
		TestInterface.test1(d);
		TestInterface.test2(d);
		TestInterface.test3(d);
	}
	public static void test1(Runner r){//Runner r = new Duck();
		r.run();//虚拟方法调用
	}
	public static void test2(Swimmer s){//Swimmer s = new Duck();
		s.swim();
	}
	public static void test3(Flier f){//Flier f = new Duck();
		f.fly();
	}
}
interface Runner{
	public abstract void run();
}
interface Swimmer{
	void swim();
}
interface Flier{
	void fly();
}

class Duck implements Runner,Swimmer,Flier{
	@Override
	public void fly() {
		System.out.println("丑小鸭也可以变成白天鹅！");
	}
	@Override
	public void swim() {
		System.out.println("红掌拨清波");
	}
	@Override
	public void run() {
		System.out.println("鸭子屁股扭扭的走路");
	}
}

 (3) 接口用法总结

　　通过接口可以实现不相关类的相同行为，而不需要考虑这些类之间的层次关系。

　　通过接口可以指明多个类需要实现的方法，一般用于定义对象的扩张功能。

　　接口主要用来定义规范。解除耦合关系。

(4) 接口和抽象类之间的关系

8. 工厂方法(FactoryMethod)

概述：

　　定义一个用于创建对象的接口，让子类决定实例化哪一个类。FactoryMethod使一个类的实例化延迟到其子类。

适用性：

　　1. 当一个类不知道它所必须创建的对象的类的时候

　　2. 当一个类希望由它的子类来指定它所创建的对象的时候

　　3. 当类将创建对象的职责委托给多个帮助子类中的某一个，并且你希望将哪一个帮助子类是代理者这一信息局部化的时候

工厂方法举例:

　　　　　　　　　

//接口的应用：工厂方法的设计模式
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("老师批改作业");
	}
}

 9. 代理模式(Proxy)

概述：

　　为其他对象提供一种代理以控制对这个对象的访问。

　　　　　　

//接口的应用：代理模式
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("=====被代理类执行完毕======");
	}
 }

10. 类的成员之五：内部类

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

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

　　 3.成员内部类：

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

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

　　 4.局部内部类：

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

　　　　①如何创建成员内部类的对象

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

　　　　③局部内部类的使用

例子

public class TestInnerClass {
	public static void main(String[] args) {
		//创建静态内部类的对象：可以直接通过外部类调用静态内部类的构造器
		Person.Dog d = new Person.Dog();//Person.new Dog();
		//Person.Bird b = new Person.Bird();
		//创建非静态的内部类的对象：必须先创建外部类的对象，通过外部类的对象调用内部类的构造器
		Person p = new Person();
		Person.Bird b = p.new Bird();//new p.Bird();
		b.info();
		b.setName("杜鹃");
	}
}

class Person{
	String name = "韩梅梅";
	int age;
	//成员内部类(非static的)
	class Bird{
		String name = "黄鹂";
		int id;
		public Bird(){
		}
		public void setName(String name){
			System.out.println(name);//杜鹃
			System.out.println(this.name);//黄鹂
			System.out.println(Person.this.name);//韩梅梅
		}
		public void info(){
			show();
		}
	}
	//成员内部类(静态内部类)
	static class Dog{
	}
	
	public void show(){
		System.out.println("我是show()方法");
	}
	
	public void method1(){
		class A{
		}
	}
}

 局部内部类的例子

//关于局部内部类的使用
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;
			}
		};
	}
}

 面向对象内容总结