内部类,3种设计模式,数组

内部类

成员内部类

成员内部类可以无条件访问外部类的所有成员属性和成员方法(包括private成员和静态成员)

成员内部类和外部类有同名的成员变量或者方法是,会发生隐藏现象,即默认情况下访问的是成员内部类的成员,如果要访问外部类的同名成员,需要:
外部类.this.成员变量;
外部类.this.成员方法

外部类要访问成员内部类的成员,必须先创建一个成员内部类对象,再通过指向对这个对象的引用来访问.

成员内部类是依附外部类而存在的,如果要创建成员内部类的对象,前提是必须存在一个外部类的对象,

public class Test {
    public static void main(String[] args)  {
        //第一种方式：
        Outter outter = new Outter();
        Outter.Inner inner = outter.new Inner();  //必须通过Outter对象来创建
         
        //第二种方式：
        Outter.Inner inner1 = outter.getInnerInstance();
    }
}
 
class Outter {
    private Inner inner = null;
    public Outter() {
         
    }
     
    public Inner getInnerInstance() {
        if(inner == null)
            inner = new Inner();
        return inner;
    }
      
    class Inner {
        public Inner() {
             
        }
    }
}

局部内部类

局部内部类是定义在一个方法或者一个作用域里面的类，它和成员内部类的区别在于局部内部类的访问仅限于方法内或者该作用域内

class People{
    public People() {
         
    }
}
 
class Man{
    public Man(){
         
    }
     
    public People getWoman(){
        class Woman extends People{   //局部内部类
            int age =0;
        }
        return new Woman();
    }
}

匿名内部类

package com.shsxt.inner01;
/*
 * 匿名内部类
 * 	当有些类没有自己的作用,只是对有些方法进行重写,可以简略的使用匿名内部类的形式
 */
public class AnonymousDemo02 {
	public static void main(String[] args) {
		//new Test().smoke();
		//匿名内部类  new的是实现类的对象
		//直接调用 只能使用一次,不能复用
		new Smoking(){//实现类的类体|子类的类体-->继承|实现了 前面的接口|父类  eg:Smoking

			@Override
			public void smoke() {
				System.out.println("不会吐烟圈的吸烟人!!!");
			}

			@Override
			public void tangtou() {
				System.out.println("抽烟,喝酒,烫头...");
			}
			
		}.smoke();
		
		//引用调用   接口多态
		Smoking s=new Smoking(){

			@Override
			public void smoke() {
				System.out.println("不会吐烟圈的吸烟人!!!");
			}

			@Override
			public void tangtou() {
				System.out.println("抽烟,喝酒,烫头...");
			}
			
		};
		s.smoke();
		s.tangtou();
		
		//方法的参数
		test(new Smoking(){

			@Override
			public void smoke() {
				
			}

			@Override
			public void tangtou() {
				System.out.println("徐企业");
			}
			
		});
		
		test(new Smoking(){

			@Override
			public void smoke() {
				
			}

			@Override
			public void tangtou() {
				System.out.println("徐企业2");
			}
			
		});
		
	}
	
	public static void test(Smoking s){
		s.tangtou();
	}
}

//吸烟接口,定义功能
interface Smoking{
	 void smoke();
	 void tangtou();
}

//定义一个实现类,实现Smoking接口,重写smoke方法,才能调用这个抽象方法的实现
//本身test类是没有任何自己的作用,这是为了重写一个抽象方法的方法体
/*class Test implements Smoking{

	@Override
	public void smoke() {
		System.out.println("不会吐烟圈的吸烟人!!!");
	}

三种设计模式

单例模式

1.创建私有构造器
2.创建静态的私有化引用,用来存储未来创建的实例
3.创建公共的静态的访问方式,以给出对象
单个实例,某个类只能创建一个对象
懒汉式
在第一次获取的时候创建对象,线程不安全 ,相对效率较高

public class SingleDemo {
	//2.提供一个静态的私有的该类的引用  用来存储未来创建的当前的实例
	private static SingleDemo singleTon=null;
	//1.构造器私有
	private SingleDemo(){
		
	}
	//3.提供一个公共的静态的访问方式->给你对象
	/*public static SingleDemo newInstance(){
		if(singleTon==null){
			singleTon=new SingleDemo();
		}
		return singleTon;
	}*/
	//多线程环境控制单例安全,在方法上加锁
	public static synchronized SingleDemo newInstance(){
		if(singleTon==null){
			singleTon=new SingleDemo();
		}
		return singleTon;
	}
	
}

饿汉式
类第一次加载以后就创建对象,线程安全的,相对效率较低

public class Single {
	//2静态的私有的该类的引用
	private static Single single=new Single();
	//1.构造器私有
	private Single(){}
	//3.公共的静态的访问方式
	public static Single newInstance(){
		return single;
	}
}

代理模式

静态代理
真实角色:
真实角色和代理角色实现相同的接口|父类

代理角色:帮助真实角色做事情的
代理角色必须持有真实角色的引用

代理行为
在代理之前存在真实角色,是真实觉得的需求

优点:减少与真实觉得的沟通,解耦,便于后期修改与维护

public class StaticProxy {
	public static void main(String[] args) {
		Manager manager=new Manager("林老师");
		Hr hr=new Hr("卢妹妹",manager);
		hr.addUser();
	}
}

//相同的接口  路用人
interface AddUser{
	void addUser();
}

//真实角色  项目经理
class Manager implements AddUser{
	String name;
	
	public Manager(String name) {
		this.name=name;
	}

	@Override
	public void addUser() {
		System.out.println("....录用了");
	}
	
}

//代理角色  Hr
class Hr implements AddUser{
	String name;
	//持有真实觉得的引用
	Manager manager= null;
	
	public Hr(String name,Manager manager) {
		this.name=name;
		this.manager=manager;
	}
	
	@Override
	public void addUser() {
		System.out.println("发布招聘信息..");
		manager.addUser();
		System.out.println("谈薪资录用...");
	}
}

工厂模式

简单工厂模式

抽象产品角色:是具体产品角色继承的父类|实现的父接口
具体产品角色:具体产品的属性和功能
工厂角色:生产具体产品

public class FactoryDemo {
	public static void main(String[] args) {
		//接口多态
		Car car=factory("Me");
		car.run();
	}
	
	//工厂角色
	public static Car factory(String name){
		Car car=null;
		if("Ms".equals(name)){
			car=new Ms();
		}else{
			car=new Me();
		}
		
		return car;
	}
}
//抽象产品角色
interface Car{
	void run();
}
//具体产品角色
class Ms implements Car{

	@Override
	public void run() {
		System.out.println("一辆红色的玛莎拉蒂跑...");
	}
	
}
//具体产品角色
class Me implements Car{

	@Override
	public void run() {
		System.out.println("一辆奔驰在跑..");
	}
	
}

数组