第十天的日常更新--抽象方法&接口&设计模式

今天继续更新日常

抽象方法

首先我们需要了解的是什么是方法.
抽象方法就是被abstract修饰的方法就是抽象方法.
它是没有方法体的.
它必须存在于抽象类中.
那什么又是抽象类呢?
被abstract修饰的类就是抽象类.
它有几个要注意的要点
1.抽象类是不能实例的,
2.抽象方法是一定要存在抽象类中
3.抽象方法一定要被重写才能使用
4.抽象类可以存在抽象方法也可以存在实例方法.
5.使用抽象类中的内容
通过子类
具体子类:重写抽象父类中的所有抽象方法+按需新增方法.
抽象子类:按需重写抽象方法+按需新增
6.一个抽象方法如果被重写过就不需要再次被重写了,但是也可以重写.
7.abstrac是不能和private,final,static.和native一起使用的.
具体的代码显示如下:

public abstract class Develop {
	//说不明白,讲不清楚的方法
	public abstract void work();
	public abstract void sleep();```	
	//普通方法
	public void test(){
		System.out.println("哈哈哈哈");
	}
}

class Java extends Develop{

	@Override
	public void work() {
		System.out.println("做后端开发");
	}

	@Override
	public void sleep() {
		System.out.println("边敲代码边睡觉");
	}
	
	//新增方法
	void hehe(){
		System.out.println("hhhhh");
	}
	
}

abstract class Web extends Develop{
	public void work(){
		System.out.println("前端开发");
	}
	
	//public abstract void sleep();
	
	void xixi(){
		System.out.println("xixi");
	}
}

class Demo extends Web{

	@Override
	public void sleep() {
		System.out.println("站着睡觉");
	}
	public void work(){
		System.out.println("前端开发");
	}
}

## 接口.interface
接口可以理解为是一种特殊的抽象类.
它是一个事物额外的功能.
接口与抽象类选择二者之间的选择,可以优先使用接口.
如果父类的功能是有功能体现实现的,也有只定义功能,子类可以具有的功能但是没有实现,可以抽象类.
接口有以下4大优点
1.提高代码的复用性
2.解耦
3.定义编程规范
4.接口多实现
我们用interface定义接口
它由以下几点组成
JDK1.7之前
属性:public   static final 公共的静态的常量
修饰符public static final可以省略,默认
  public interface Interface{
	public static final int A=5;
	int B=333; //可以省略修饰符
方法:public abstract 公共的抽象方法
修饰符public abstract是默认的,可以不写

	public abstract void haha();
	int hehe(); //抽象方法可以省略修饰符
这里面需要注意的是以下几点
1.接口不能实例化
2.接口需要实现,实现接口使用关键字implements,实现了接口就拥有了接口中的功能(与继承相似).
3.接口的具体使用
  具体的实现类:实现了接口.就要重写这个接口中的所有抽象方法+按需新增
  抽象的实现类:重写部分抽象功能+按需新增.
4.类只能实现接口,不能继承接口,但是类只能继承类,不能实现类,类单继承类,类多实现接口.
5.接口不能继承和实现类.接口只能继承接口,不能实现接口,接口可以多继承接口.
6.一个类要先继承之后实现.
jdk1.8新增的功能:
**1.静态方法:
使用:只能通过接口名字调用
2.默认的方法
使用::只能通过实现类的对象使用.
代码示例**

public interface InterfaceDemo {
	//抽象方法
	public abstract void haha();
	int hehe();
	
	//静态方法
	public static void houhou(){
		System.out.println("我是吼吼...");
	};
	
	//默认方法
	public default void xixi(){
		System.out.println("默认方法");
	}
}

//具有抽象的方法的实现类就是抽象的实现类
abstract class Test2 implements InterfaceDemo{
	@Override
	public void haha() {
		System.out.println("抽象子类中的hhhhhhh");
	}
}
//具体的实现类
class Test implements InterfaceDemo{

	@Override
	public void haha() {
		System.out.println("hhhhhhhh");
	}

	@Override
	public int hehe() {
		System.out.println("hehehehehe");
		return -1;
	}
	
	void h(){}
}

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

		InterfaceDemo.houhou();
		new Test().xixi();
	}
}

## 今天在多分享一些设计模式吧
分享3种
1.单例模式:保证一个类只能构建一个实例

分为3个步骤
1.构造器私有化
2.私有的静态的该类的引用
3.公共的静态的访问方式
饿汉式:在类第一次加载的时候就创建实例 -----线程是安全的
实例
public class Single {
	//2.私有的静态的该类的引用
	private static Single single=new Single();
	//1.构造器私有化
	private Single(){  //不允许随意再外部创建对象
	
	}
	//3.公共的静态的访问方式
	public static Single newInstance(){
		return single;
	}
	
}

懒汉式:第一次调用功能的时候创建实例. -------线程不安全,但效率较高
public class SingleTon {
	//2.私有的静态的该类的引用
	private static SingleTon single=null;
	//1.私有构造
	private SingleTon(){}
	//3.公共静态的访问方式
	public static SingleTon newInstance(){
		if(single==null){
			single=new SingleTon();
		}
		return single;
	}
}

调用方法
public class Test {
	public static void main(String[] args) {
		Single single1=Single.newInstance();
		Single single2=Single.newInstance();
		System.out.println(single1==single2);
		
		SingleTon s1=SingleTon.newInstance();
		SingleTon s2=SingleTon.newInstance();
		System.out.println(s1==s2);
	}
}

2.静态代理模式
1.真的角色和代理角色实现相同的接口|父类
2.代理角色持有真实角色的引用
3.代理行为
它的优势是降低了与真实角色的交流,减少代码的耦合度,便于后去维护和扩展.
下面以一个实例说明;
真实角色:项目经理
代理角色:hr
代理行为:招人
public class StaticProxy {
	public static void main(String[] args) {
		UserManager UserManager=new UserManager();
		Hr hr=new Hr(UserManager);
		hr.addUser();
	}
}

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

//真实角色:项目经理
class UserManager implements AddUser{

	@Override
	public void addUser() {
		System.out.println("项目经理录用人");
	}
	
}

//代理角色:hr
class Hr implements AddUser{
	//代理角色持有真实角色的引用
	private UserManager manager;
	
	public Hr() {
		// TODO Auto-generated constructor stub
	}
	
	public Hr(UserManager manager) {
		super();
		this.manager = manager;
	}

	@Override
	public void addUser() {
		System.out.println("------筛选简历---------");
		System.out.println("------通知面试---------");
		manager.addUser();
		System.out.println("---------------------");
	}
}

3.简单工厂模式
抽象产品角色:具体产品角色实现的接口|继承的父类

public class Factory {
	public static void main(String[] args) {
		//接口多态  接口指向不同的实现类
		Car car=factory("BMW");
		car.run();		
		new Zi();
	}
	
	//工厂
	public static Car factory(String type){
		Car car=null;
		if("Mes".equals(type)){ //比较字符串的内容使用equals方法
			car=new Mes();
		}else{
			car=new BMW();
		}
		return car;
	}
}

//抽象产品角色
interface Car{
	void run();
}

//具体产品角色
class BMW implements Car{

	@Override
	public void run() {
		System.out.println("坐在..哭");
	}
	
}
class Mes implements Car{
	
	@Override
	public void run() {
		System.out.println("坐在引擎盖上哭...");
	}
}

今天就先分享这么多吧,明天加油.