面向对象06

1内部类

1.5局部内部类

局部内部类需要注意:
*1.局部内部类等同于局部变量
2.局部内部类 在访问外部方法中的局部变量的时候需要加final修饰(1.8之前),从1.8开始 final可以省略
3.局部内部类中,不能有静态声明

成员方法中的局部内部类

可以访问外部类中所有 的属性
成员方法局部内部类不能使用权限修饰符
调用,只能在该成员方法中调用

静态方法中局部内部类,

1.不能有静态声明,有直接报错
2.不可以直接访问外部类的成员属性
3.需要创建对象才能够打点访问外部类的成员属性
4.静态方法中 局部内部类声明 可以使用权限修饰符
5.调用局部内部类 的时候 可以直接 创建内部类对象, (不必先去创建外部类对象)
代码示例
package _01_InnerClass;

/**

• 局部内部类需要注意:
• 1.局部内部类等同于局部变量
• 2.局部内部类 在访问外部方法中的局部变量的时候需要加final修饰(1.8之前),从1.8开始 final可以省略
• 3.局部内部类中,不能有静态声明
• 4.如果是成员方法中的局部内部类,可以访问外部类中所有 的属性
  *5. 如果是静态方法中局部内部类, 不可以直接访问外部类的成员属性
• @author prisident

*/

public class _03_OuterClass {

private static String s1 = "静态变量";
private String s2 = "成员局部变量";


public static void main(String[] args) {
	_03_OuterClass oc = new _03_OuterClass();
	//成员方法 先初始化在调用
	 oc.m1();
	 
	 //静态方法直接调用
	m2();
	
	//不能再外部调用成员方法的局部内部类
//	InnerClass ic = new InnerClass();
//	ic.m4();
	
	//不能再外部调用静态方法的局部内部类
//	InnerClass ic = new InnerClass();
	//ic.m3();
}

// 静态方法
	public static void m2() {
		int i = 0;
		//加不加finall都行,,可以不加final修饰,但是 值依然不能更改
	//	final	int i = 2;
		
		
		
		// 局部内部类,
		class InnerClass {
			// 不能有静态声明,有直接报错
			// public static void m3(){}
			
			
			//静态方法中   局部内部类声明      可以使用权限修饰符
			public void m3() {
				System.out.println(s1);
				// 静态方法中 的内部类,不能直接访问外部类的成员属性
				// System.out.println(s2);
				//需要创建对象才能够打点访问外部类的成员属性
				_03_OuterClass oc = new _03_OuterClass();
				System.out.println(oc.s2);
				System.out.println(new _03_OuterClass().s2);
				// 1.8之后,访问局部变量的时候,可以不加final修饰,但是 值依然不能更改
				System.out.println(i);
			}
		}	


		// 调用局部内部类 的时候 可以直接 创建内部类对象, (不必先去创建外部类对象)
		InnerClass ic = new InnerClass();
		ic.m3();
		

	}
	
	

	// 成员方法
	public void m1() {
		final int i = 10;
		
		class InnerClass {
			// 成员方法局部内部类不能使用权限修饰符
			// public static void m3(){}
			public void m4() {
				System.out.println(s1);
				// 成员方法中的局部内部类,所以可以直接访问外部类中的所有属性
				System.out.println(s2);
				// 1.8开始,访问局部变量的时候,可以不加final修饰,但是 值依然不能更改
				System.out.println(i);
			}
		}
		// 调用,只能在方法中调用
		InnerClass ic = new InnerClass();
		ic.m4();
	}

}

1.6 匿名内部类

匿名内部类 : 指在方法调用时,实参需要传入某个接口对象的时候,不传入对象,传入一个匿名的实现类,如果方法定义形参一般是个接口,调用的时候,就需要传入其实现类的对象
注意:
1.这个类 没有名字 , 也就无法创建对象,但是传入匿名内部类的 时候回自动创建一个对象
2.默认的匿名内部类类名 : 外部类类名$1 依次类推

代码示例
public class _04_InnerClass {
public static void main(String[] args) {
//创建接口实现类的对象
ICustomerService cs = new CustomerServiceImpl();
// 把接口实现类对象传入 m1 方法
m1(cs);

// 匿名内部的类写法
// 少定义一个类,意味着没有名字,   但是无法重复使用
// m1 方法 中的参数中创建一个类 
m1(new ICustomerService() {
	int i = 2;
	// 这里必须重写 接口的方法, 不重写报错
	@Override
	public void logout() {
		System.out.println("已退出登陆" + this);
	}
});

m2(new A(){
	// 相当于等于是创建了一个A的子类,并覆写了m3方法
	public void m3(){
		System.out.println("相当于复写m3");
		super.m3();
	}
});

}
//m1 静态方法
public static void m1(ICustomerService cs) {
cs.logout();
// m2 静态方法 把A类传过来 ,调用A类中的m3方法
}
public static void m2(A a) {
a.m3();

}
}

//接口
interface ICustomerService {
public void logout();
}

// 接口的的实现类
class CustomerServiceImpl implements ICustomerService {
@Override
public void logout() {
System.out.println(“登陆”);
}
}

class A{
public void m3(){
System.out.println(“我是m3”);
}}

2设计模式

2.1概述

代表了最佳的实现方式,是一些有经验的开发人员,通过开发中总结出来的一些经验和错误,用来解决一系列问题,是前辈们对代码开发经验的总结,不是特定的语法结构,而是一套用来提供可复用性,可维护性,可读性,健壮性,安全性的解决方案
就是在编码实践中发现很多的编码方式经常会被用到,于是就总结出来 形成固定的结构

如果开发中,用到了一些设计模式的话,就等于使用了他人总结的经验成果,可以避免很多问题

目前比较成熟的设计模式 有23种

2.2单例模式

目的 : 让某个类只创建一个对象
实现思路:
要想只让某个类创建一个对象,我们应该控制创建对象的数量,不能让用户去创建,这样才能保证只能创建一个对象

1. 构造方法私有化
   外部不能直接访问我们的构造方法,不能使用该构造方法就不能创建对象了
   这时候,我们要创建一个对象给用户, -->需要对外提供一个静态方法,调用该方法就能返回一个对象
   2.创建一个公共的静态方法来返回当前对象,并且保证只能实例化一次
   当调用处它的方法获得它的对象的时候, 先判断它是否已经创建了对象,如果没有就创建一个,如果有就返回该对象
   3 创建一个私有化的静态变量,用于存储当前类的对象(变量的类型,是当前类类型)
   为什么私有化静态变量?
   1.如果是一个局部变量的话,方法每次调用,都会重新初始化局部变量,所以 每次都会创建对象
   2.如果是个成员变量,静态方法中不能直接操作成员变量
   所以 只能是静态变量,并且这个变量要私有化不能被外部访问---->防止用户直接更改变量的值.

懒汉模式

package _01_Singleton;
// 懒汉模式: 第一次获取对象的时候,再创建对象
public class _01_Singleton {

// 私有化构造方法,使外部不能访问
private  _01_Singleton(){}

// 声明私有化静态变量, 用来存储当前对象,变量的类型,是当前类类型

private static _01_Singleton s;

// 对外提供一个获取当前对象的方法

public static _01_Singleton getInstance() {
	// 判断s是否为空,如果为空 说明没有创建过对象,就创建一个
	if (s == null) {
		s = new _01_Singleton();
	}
	// 不为空就说明创建过对象,就直接返回该对象
	return s;
}

}

饿汉模式

/**

• 饿汉模式: 加载完后 立刻创建对象
• @author prisident

*/
public class _02_Singleton {

//  构造方法私有化
	private _02_Singleton() {

	}
// 静态变量再类加载阶段初始化, 程序生命周期只执行一次
	//在进行类加载的时候就实例化本类, 创建对象
	private static _02_Singleton s = new _02_Singleton();
	
	// 返回该对象
	
	public static _02_Singleton getInstance() {
		return s;
	
	
	
	
	}

}

2.3工厂模式

工厂模式 : 把创建对象的语句单独封装成一个工厂模式.
这样 所有用到这个对象的地方,都去工厂中获取,把类之间强依赖关系变弱,灵活度更高

• 好代码要, 高内聚低耦合