2020.10.30——Java高级类特性二

五、高级类特性二：

5.1关键字static：

类变量、类方法：

单例设计模式：

饿汉式与懒汉式的区别在于对象创建的时间。

（1）饿汉式：

public class Single_model {
	
	//构造方法私有化，调用这个类时就不能直接使用new来创建对象
	private Single_model() {
		
	}
	
	//私有的Single_model类型的类变量
	private static Single_model single = new Single_model();
	
	public static Single_model getInstance() {
		return single;
	}
}

也就是说是s1,s2访问的都是同一个Single变量。

public class Test {
	public static void main(String[] args) {

		Single_model s1 = Single_model.getInstance();//通过访问静态方法获得Single变量
		Single_model s2 = Single_model.getInstance();
		
		if(s1 == s2) {
			System.out.println("s1 is equals to s2!");
		}
	}
}

（2）懒汉式：

package october31;
/**
 * 懒汉式单例模式
 * @author Ais Wallenstein
 *
 */
public class Single1 {
	private Single1() {
		
	}
	
	private static Single1 s1 = null;
	
	public static Single1 getIntance() {
		if(s1 == null) {
			s1 = new Single1();
		}
		return s1;
	}  
	
}

5.2main方法：

5.3类的成员之四：初始化块

非静态代码块：

静态代码块：

静态代码块中只能使用static修饰的属性和方法。

静态与非静态区别：在程序的运行中，非静态代码块每次new对象都要重新执行，而静态代码块只执行一次。

5.4关键字：final

final修饰类：

final修饰方法：

final修饰常量：

final修饰的变量是常量，常量必须显示赋值（就是不能用默认的值）。常量只能赋值一次，不能再改变。
final static 一起修饰变量，就是全局常量。常量的命名使用大写。

5.5抽象类：

就是说可能具体到某个子类的时候才去具体的实现方法体。其父类都没有具体的方法体。

abstract抽象类、抽象方法：

抽象类、抽象方法 用abstract修饰。
抽象方法：只有声明，没有具体的方法体。
抽象类不能被实例化，它是用来被继承的。

注意：（1）只要类中有一个抽象的方法，那么这个类就必须是一个抽象类。
（2）注意abstract的修饰范围。

public abstract class Animal {
	public abstract void test();//抽象类没有方法体
	
}

举例：
以下子类中若是只有一个抽象类的方法，那么他就必须是一个抽象类。在类前要用abstract修饰。

public abstract class Animal {
	public abstract void test();//抽象类没有方法体
	
	public abstract void move();
	
	
	
}

class Dog extends Animal{
	@Override
	public void move() {
		System.out.println("dog is run");
		
	}

	@Override
	public void test() {
		
	}
	
	
}

随便写写：

public abstract class Employee {
	public Employee(){
		
	}
	
	String name;
	int id;
	double salary;
	
	public abstract void work();
	
	
}


class CommonEmployee extends Employee{
	
	public void setCommonEmployeeInfo(int id, String name, double salary) {
		super.id = id;
		super.name = name;
		super.salary = salary;
	}
	
	public void getCommonEmployeeInfo() {
		System.out.println(super.id);
		System.out.println(super.name);
		System.out.println(super.salary);
	}
		
	@Override
	public void work() {
		System.out.println("这是一个普通员工");
		
	}
	
}

模板方法设计模式：

例子：

5.6接口：

接口基本知识：

一个类可以实现多个接口，接口可以继承接口！

package nov5;
/**
 * 子类继承父类，只能继承一个父类
 * 类可以实现多个接口，多个接口用，分隔
 * @author Ais Wallenstein
 *
 */
public class TestImpl implements TestIn,TestIn1 {

	@Override
	public void test() {
		
	}

	@Override
	public void test1() {	
		
	}
	
	
}

如果一个类既继承父类，又实现接口，那么先继承，再实现接口。

使用接口的原因：


如果实现接口的类中没有实现接口中的全部方法，必须将此类定义为抽象类。

工厂方法（FactoryMethod）：

例子：

package nov5;
/**
 * 宝马车的接口
 * @author Ais Wallenstein
 *
 */
public interface BWM {
	void showInfo();
}

//构建具体的车系
class BWM3 implements BWM{
	@Override
	public void showInfo() {
		System.out.println("这是宝马3系");
	}
}

class BWM5 implements BWM{
	@Override
	public void showInfo() {
		System.out.println("这是宝马5系");
	}
}

class BWM7 implements BWM{
	@Override
	public void showInfo() {
		System.out.println("这是宝马7系");
	}
}

package nov5;
/**
 * 汽车生产工厂接口
 */
public interface BWMFactory {
	BWM productBWM();//方法类型为BWM，将BWM接口和BWMFactory联系了起来 
}

/**
 * 实现具体车型的宝马生产工厂
 * @author Ais Wallenstein
 *
 */

class BWM3Factory implements BWMFactory{
	@Override
	public BWM productBWM() {
		System.out.println("生产宝马3系");
		return new BWM3();
	}
}

class BWM5Factory implements BWMFactory{
	@Override
	public BWM productBWM() {
		System.out.println("生产宝马5系");
		return new BWM5();
	}
}

class BWM7Factory implements BWMFactory{
	@Override
	public BWM productBWM() {
		System.out.println("生产宝马7系");
		return new BWM7();
	}
}

package nov5;

public class Test2 {
	public static void main(String[] args) {
		
		//new对象然后调用方法，实质上是new BWM
		BWM b3 = new BWM3Factory().productBWM(); //productBWM()方法的类型为BWM
		BWM b5 = new BWM5Factory().productBWM();
		BWM b7 = new BWM7Factory().productBWM();
		
		b3.showInfo();
		b5.showInfo();
		b7.showInfo();
		
		
	}
}

5.7类的成员之五：内部类

基本概念：

内部类的作用：内部类主要是解决Java不能多重继承的问题。
可以使用内部类来变相的实现类的多重继承，可以同时继承多个类。

（1）成员内部类：

• 该类像是外部类的一个成员，可以无条件的访问外部类的所有成员属性和成员方法（包括private成员和静态成员）
• 成员内部类中拥有与外部类同名的成员变量时，会发生隐藏现象，即默认情况下访问的是成员内部中的成员；若要访问外部类中的成员需要【外部类.this.成员变量 或 外部类.this.成员方法】
• 如果要创建成员内部类的对象，前提必须存在一个外部类的对象

（2）局部内部类：

• 定义在一个方法或者一个作用域中的类，他和成员内部类的区别在于局部内部类的访问权限仅限于方法内或者该作用域内
• 局部内部类就像是方法里面的一个局部变量一样，是不能有public， protected， private以及static修饰符

（3）匿名内部类：

• 一般使用匿名内部类的方法来编写事件监听代码
• 匿名内部类是不能有访问修饰符和static修饰符的
• 匿名内部类时唯一一种没有构造器的类
• 匿名内部类用于继承其他类或者是实现接口，并不需要增加额外的方法，只是对集成方法的实现或者是重写

内部类的简单测试：

package nov6;
/**
 * 内部类的测试
 * @author Ais Wallenstein
 *
 */
public class Test {
	int i;
	private int i1;
	public int i2;
	
	class A{
		int i;
		public void set() {
			Test.this.i = 1;
			Test.this.i1 = 2;
			Test.this.i2 = 3;
		}
		
	}
	
	//外部类要调用内部类（A）中的方法，要先new内部类的 获得对象，通过 对象名.方法名 调用
	public void setInfo() {
		new A().set();
	}
	
	public void showInfo() {
		System.out.println(i);
		System.out.println(i1);
		System.out.println(i2);
	}
	
	public static void main(String[] args) {
		Test t = new Test();
		t.setInfo();
		t.showInfo();
	}
}

通过内部类变相的实现多继承：

package nov6;
/**
 * 利用内部类变相的实现多继承。
 * 需求：类A想实现对类B，C方法的重写，Java不能多继承，那么利用内部类实现。
 * @author Ais Wallenstein
 *
 */
public class Test1 {
	public static void main(String[] args) {
		A a = new A();
		a.testB();
		a.testC();
	}
}


class A{
	
	//调用内部类中的改写后的方法
	public void testB() {
		new InnerB().funB();
	}
	
	public void testC() {
		new InnerC().funC();
	}
	
	
	//设计第一个内部类
	private class InnerB extends B{
		@Override
		public void funB() {
			System.out.println("这是重写之后的funB方法");
		}
		
	}
	
	//设计第二个内部类
	private class InnerC extends C{
		@Override
		public void funC() {
			System.out.println("这是重写之后的funC方法");
		}
	}
	
}


class B{
	public void funB() {
	}
}

class C{
	public void funC() {
		
	}
}

匿名内部类：

• 匿名内部类直接使用new来生成一个对象的引用
• 存在缺陷：它仅能被使用一次，创建匿名内部类时会立即创建一个该类的实例，该类的定义会立即消失，所以匿名内部类不能够被重复使用
• 使用匿名内部类时，必须是继承一个类或者实现一个接口（不能是抽象的），两者不可兼得
• 匿名内部类中不能定义构造函数，匿名内部类中不能存在任何的静态成员变量和静态方法
• 匿名内部了初始化：使用构造代码块，利用构造代码块能够达到为匿名内部类创建一个构造器的效果

外部类与内部类访问权限：

总结：面向对象