接口

接下来我跟大家分享一下我在Java学习中对于接口的认识

1.接口的定义

接口 interfance在java中相当于特殊的抽象类,定义一个接口如下:

interfance InterfanceDemo{
    
}

在接口的应用中,内部的成员属性被public static final(公共的静态的常量)修饰,通常默认省略public static final 内部方法格式为(public abstract可以省略):

public abstract  返回值类型  方法名();

2.接口的使用

接口的实现与类的继承非常像,但是内容不同,在子类继承父类就可以直接使用父类的内容
类只能单继承,接口可以多实现,一个类需要继承父类后实现接口
接口不能实例化
在java中接口与接口之间可以继承,类和接口之间只能实现,接口之间可以多继承,类与接口之间可以多实现

public interfance InterfaceDemo01{
    public static final int a=5;
    int b=10;
    
    //公共抽象方法
    public abstract void haha();
    int hehe();
}

interfance InterfanceDemo02{
    void heihei;
}

//A中就包含了继承的所有接口中的内容
interfance A extends InterfanceDemo01,InterfanceDemo02{}

实现使用关键字implements 继承使用关键字extends
实现类的接口,也拥有接口中的能力,但是需要实现类去自己实现这个功能.


public class Demo01  extends Fu implements  InterfanceDemo01,InfanceDemo02{
    @Override
    public void haha(){
        System.out.println("啥,哈哈哈");
    }
    @Override
    public int hehe(){
        System.out.println("我就呵呵");
    }
    @Override
    public void heihei(){
        System.out.println("我想嘿嘿嘿");
    }
    //新增方法
    public void houhou(){
        System.out.println("呼呼呼");
    }
}
//抽象实现类
abstract class Demo implements InferfanceDemo01{
    @Override
    public void haha(){
        System.out.println("hhhhhhh");
    }
}
class Fu{}

程序设计模式

1.单例模式

1.定义:

保证一个类只能有一个对象,这个特点形式的类成为单例模式,但是不影响类中原有的功能

2.单例

单例的实现:

1.构造器私有化

2.私有的,静态的该类的引用,存储创建唯一的对象的

3.公共的静态的访问方式

单例的方式很多,我们来说说主要的两种单例

懒汉式:在第一次调用的时候创建这个实例 ----线程不安全的,效率较高

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

饿汉式:在类第一次加载完成之后,就创建这个实例 ----线程安全的,效率较低

public class SingleTon{
    //2.私有的,静态的该类的引用,存储创建唯一的对象的
    private static SingleTon single=new SingleTon();
    //1.构造器的私有化
    private SingleTon(){
        
    }
    //3.公共的静态的访问方式
    //返回值:当前类型的对象  参数:没有
    public static SingleTon newInstance(){
        return single;
    }
}

2.工厂模式

public class Factory {
	Computer co=null;
	public static void main(String[] args) {
		Factory fc=new Factory();
		
		Computer c=fc.factory("Lenovo");
		c.play();
	}
	
	public  Computer factory(String str){
		
		if("Lenovo".equals(str) ){
			co=new Lenovo();	
		}else{
			co=new Hasee();
		}
		return co;
	
	}
}
//电脑接口
interface Computer{
	void play();
}

class Lenovo implements Computer{

	@Override
	public void play() {
		System.out.println("打游戏快的很");
	}
	
}
class Hasee implements Computer{
	
	@Override
	public void play() {
		System.out.println("打游戏卡卡卡");
		
	}
	
}

内部类

内部类即在类的内部再定义一个类,当一个类是类中成员,又是另一个事物时,它就被称为内部类

1.分类

成员内部类:当内部类作为外部类的成员的时候,就是成员内部类

静态内部类:用static修饰的内部类就是静态内部类

私有内部类:被private修饰的内部类

局部内部类:方法中的内部类

匿名内部类:有些实现类没有自己的功能,就是为了重写抽象类,为了不浪费类名,不让项目中的类过多,所以使用匿名类

2.成员内部类

是成员就具有成员的特点,就是可以使用成员修饰符来修饰

是类就有类的特点,可以继承,实现...

内部类中可以使用外部的类的内容,包括私有的

在外部类中可以通过内部类的对象使用其成员

成员内部类中不能定义静态的内容,除了静态的常量

public class Outer01 {
	public static void main(String[] args) {
		Outer01 outer01=new Outer01();
		outer01.outer();
		
		
	}
	int a =5;
	
	class Inner extends Fu implements A{
		String name="小明";
		static final int  age=18;
		int a=10;
		
		public void inner(){
			int a=20;
			System.out.println("我是成员类中的成员方法");
			System.out.println(name);
			//外部类中
			System.out.println(Outer01.this.a);
			//内部类中
			System.out.println(this.a);
			//局部类中
			System.out.println(a);
		}
	}
	public void outer(){
		System.out.println("我是外部类中的成员方法");
		Inner in=new Inner();
		in.inner();
		System.out.println(in.name);
		System.out.println(Inner.age);
	}
}
class Fu{}
interface A{}

3.私有内部类

私有内部类可以使用外部类中的私有内容

外部类使用私有内部类中的私有内容,需要通过内部类对象使用

私有内部类只能在外部类中使用,不能在其它类中使用

public class Outer02 {
	public static void main(String[] args) {
		Outer02 outer02=new Outer02();
		outer02.outer();
		
	}
	private int a=5;
	//私有内部类
	private class Inner{
		private int b=10;
		
		private void inner(){
			System.out.println("我是私有内部类中的私有方法");
			System.out.println(a);
			System.out.println();
		
		}
	}

	private void outer(){
		System.out.println("我是外部类中的私有方法");
		Inner in=new Inner();
		in.inner();
		System.out.println(in.b);
	}
}

3.静态内部类

静态内部类使用外部类中的成员,需要通过外部类的对象使用,因为内部类是静态的

在几种内部类中,只有静态内部类才可以定义静态的内容.除了静态的常量

public class Outer03 {
	public static void main(String[] args) {
		Outer03.Inner in=new Outer03.Inner();
		in.inner();
		in.inner2();
		Outer03 a=new Outer03();
		a.outer();
	}
	
	
	private static String haha="外部类中的静态变量";
	private String hehe="外部类中的成员变量";
	
	//静态内部类
	static class Inner{
		static int a=5;
		int b=10;
		
		static void inner(){
			System.out.println(a);
			System.out.println(new Inner().b);
			System.out.println(haha);
			System.out.println(new Outer03().hehe);
		}
		void inner2(){
			System.out.println(a);
			System.out.println(b);
			System.out.println(haha);
			System.out.println(new Outer03().hehe);
			
		}
	}
	public void outer(){
		System.out.println(Inner.a);
		System.out.println(new Inner().b);
	}
}

4.匿名内部类

匿名内部类的唯一目的只是为了实现接口

匿名内部类有三种使用方式:

1.接口多态

2.没有应用接收匿名内部类的对象地址,只能在当前行使用

3.做方法的参数

public class AnonymousDemo {
	public static void main(String[] args) {
		//1.匿名内部类  接口多态
		Smoke s=new Smoke() {
			
			@Override
			public void smoke() {
				System.out.println("吐星星");	
			}
			
			@Override
			public void haha() {
				System.out.println("哈哈");
				
			}
		};
		s.smoke();
		s.haha();
		//2.没有应用接收匿名内部类的对象地址,只能在当前行使用
		new Smoke() {
			
			@Override
			public void smoke() {
				System.out.println("吐宝宝");
				
			}
			
			@Override
			public void haha() {
				System.out.println("呵呵呵");
				
			}
		}.haha();
		
		new Demo().smoke();
		
		//3.做方法的参数
		test(new Smoke() {
			
			@Override
			public void smoke() {
				System.out.println("变星星变宝宝");
				
			}
			
			@Override
			public void haha() {
				System.out.println("哈哈哈呵呵呵");
				
			}
		});
		
	}
	public static void test(Smoke s){
		s.smoke();
	}
}

interface Smoke{
	void smoke();
	void haha();
}
class Demo implements Smoke{

	@Override
	public void smoke() {
		System.out.println("我会吐烟圈");
		
	}

	@Override
	public void haha() {
	
		
	}
	
}

JAVA的接口与程序设计模式

接口