4. 面向对象的三大特征

面向对象的三大特征

背景:

传统的程序设计中存在的问题(不足):

程序的安全性不强: 一个变量声明,能被任何操作访问/调用 不安全

程序的重用性不强: 程序中存在大量重复的代码

程序的拓展性不强: 能够实现代码在升级的时候不影响其他相关的操作

三大特征:

封装

概念:

代码的整合

封装的层次:

• 函数的封装: 把一组操作整合在一起

• 类的封装: 把属性和方法整合在一起

• 结构的封装:根据操作的性质(模型/控制操作/交互视图)进行结构设计封装

操作:

1. 将属性设为private

2. 提供getter和setter

3. 基本数据类型的封装类型

Java中要保证所有的成员都是完全面向对象的,所以java为基本数据类型也设计了一套对象类型(单词一致,首字母大写)

byte – Byte

short-Short

int-Integer

long-Long

float-Float

double-Double

char-Character

boolean-Boolean

实际项目开发中, javabean中的成员(属性)的类型要求用封装类型

// 用户编号
		private  Integer id ;

		public Integer getId() {
			return id;
		}
		
		public void setId(Integer id) {
			this.id = id;
		}

赋值时,和基本类型无差别

// 要掌握的操作
		// 基本类型和封装类型之间的转换:
		// 1. 基本类型->封装类型   直接赋值
		int i = 10;
		Integer ii = i;
		Integer ii2 = 10;
		System.out.println(i*2);
		System.out.println(ii*2); //在1.5版本中增加了一个装箱和拆箱操作,使得封装类型也可以直接操作

封装类型转换为基本类型

int i2 = ii;  // 可以直接转换
		int i3 = ii.intValue();   // 也可以把Integer转换为int

封装类型和String之间的转换

		String string = "10";
		//System.out.println(string*10);  错
		int i4= Integer.parseInt(string);
		System.out.println("double:"+i4*2);
		
		double d1 = Double.parseDouble(string);
		System.out.println("double2:"+d1*2);
		
		//将一句话的首字母改成大写
		String str = "everyday is beautiful";
		char firstChar = str.charAt(0);
		
		char upper = Character.toUpperCase(firstChar);
		System.out.println("upper:"+upper);
		
		//基本类型(封装基本类型)-> 字符串
		int i5 = 10;
		String str2 = ""+i5;   //不建议
		String str3 = String.valueOf(i5);

作用:

从源头控制字段的赋值(setter)

把字段变为只读(只有getter, 但使用场景较少)

把字段的使用限制在类的内部(不加getter和setter,只加private)

		private Integer age;
		
		public Integer getAge() {
			return age;
		}
		public void setAge(Integer age) {
			this.age = age;
			/*
			 * if(age>0) { this.age = age; }else { this.age = 0; }
			 */
		}

拓展的封装思想:

把重要的数据限制在类的内部, 对外提供安全的访问和修改方式

// 最重要的数据就是 User[]
	// 从源头上,应该禁止它被其它类访问
	private User[] users;

	public UserDao() {
		users = new User[3];
	}
 public Boolean add(User user){}
 public void findById(Integer id){}
 ...

继承

问题:

1. 如果VIPUser是User的一类, 那么是否可以继续使用User的成员?
2. User[] 是否需要改变? User类型是否可以继续使用? 是否需要VIPUser[] ?
3. 如果能用User[] , 那么取出的元素如何区分是User还是VIPUser?

核心思想:

得到(VIPUser得到User的所有的成员)和扩展(vipId是VIPUser独有的特征)

public class VIPUser extends User {
	
	
	// 多了一个vip的id
	private Integer vipId;
	
	public Integer getVipId() {
		
		return vipId;
	}

	public void setVipId(Integer vipId) {
		this.vipId = vipId;
	}

	@Override
	public String toString() {
		return "VIPUser [vipId=" + vipId + ", getId()=" + getId() + ", getName()=" + getName() + ", getPhone()="
				+ getPhone() + ", getAge()=" + getAge() + "]";
	}

}

背景:

我们发现,一个类B中的操作都适用于另一个类A,但另一个类还多出了一些个性化的方法

我们希望: 能利用既有的类中的操作,再拓展出个性化 --重用的需要

语法:

A继承B中的操作

class Father{}

class Son extends Father{}

extend: 得到,拓展 , java使用了动词形式 extends

Father作为父类

public class Father extends GrandFather{
	
	public int i = 1;
	
	// 当在继承中使用的访问权限: protected
	// 从封装的角度还是应该用private
	//protected String name;
	private String name;
	
	//分
	protected Integer myMoney = 1000;

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}
	
	// 如果父类中含有构造方法
	
	  public Father(String name) { this.name = name;
	  System.out.println("Father的构造方法"); }
	 
	
	/*
	 * public Father() {
	 * 
	 * }
	 */
	
	//定义一个父类的方法 say
	  public  void say() {
		  System.out.println("你好");
	  }
	  
}

Son作为子类

/**
 * @author bilei
 * @date 2021年8月3日
 */
// 得到Father的成员
// 子类内容> 父类
// 子类继承父类
// 父类派生子类
public class Son extends Father{
	
	public int i = 2;
	
	
	// 子类声明自己的字段 : 拓展
	private String phone;
	
	public String getPhone() {
		return phone;
	}
	public void setPhone(String phone) {
		this.phone = phone;
	}

	//在构造方法中测试从Father中获取的内容
	// 得到非私有的成员(private将成员的访问限制在Father中)
	public Son() {
		// 使用关键字super()来默认的调用父类的构造方法
		//super();  // 调用空参构造
		
		super("张无忌");
		
		// 非私有都可以访问
		//this.getName();
		System.out.println(this.myMoney);
		
		// 私有字段子类到底继承了吗?
		//this.setName("张无忌");
		System.out.println(this.getName());
	}
	
	
	public void f() {
		int i = 3;
		
		//输出三个不同的i: 父类/子类/方法局部的
		System.out.println("f() i:"+i);   //3  就近原则
		System.out.println("Son i:"+this.i);
		System.out.println("Father i:"+super.i);
	}
	
	// 子类发现父类的方法对自己不适用, 于是重新设计了方法的内容,方法的形式保持不变
	// 编译器在编译时就会检查是否真的在重新父类的方法
	@Override
	 public  void say() {
		  System.out.println("Hello");
	}
	
	//子类独有的方法
	public void play() {
		
	}
	
	public static void main(String[] args) {
		
		//父类的实例
		Father father = new Father("");
		
		// 子类的实例
		Son son =  new Son();
		son.f();
		
		
		// 直接调用父类的say
		son.say();
		
		/*
		 * 基本类型有自动转换的能力
		 * int i = 10; long l = i;
		 */
		System.out.println("-----------");
		// 创建了一个对象, 类型用父类声明, 用子类的构造方法调用创建实例
		// 我们把这种对象称为上转型对象
		// 上转型对象的方法参考实例化的内容
		// 上转型对象不能调用子类独有的方法(脱离了继承体系)
		Father f = new Son();
		// f调用say() 的结果?
		f.say();
		//f.play();
		
		
	}
}

作用:

Son:子类,派生类(subClass)

Father: 父类,超类,基类(superClass)

子类通过继承父类,得到了父类中的非私有的成员的访问 – 重用

注意:

• 调用顺序: 继承不能直接调用目标类中的私有成员

• 单继承思想: 父类可以派生多个子类(有利于重用 , 类的设计思想);子类不能继承多个父类(单继承体系,唯独接口可以多继承)

  Father再派生一个子类Daughter

  public class Daughter extends Father{
  	
  	public Daughter() {
  		// 调用父类的父类的方法, 是可以的
  		this.setLastName("王");
  	}
  }
  

  声明一个GrandFather类作为Father的父类

  /**
   * Father的父类
   * 可以显式继承Object, 也可以不用
   * 默认就是继承Object的
   * @author bilei
   * @date 2021年8月3日
   */
  public class GrandFather /* extends Object */ {
  	// 姓
  	private String lastName;
  
  	public String getLastName() {
  		return lastName;
  	}
  
  	public void setLastName(String lastName) {
  		this.lastName = lastName;
  	}
  	
  	
  }
  

• 单继承体系中, 所有类的根父类被java指定为Object类

  /**
   * Father的父类
   * 可以显式继承Object, 也可以不用
   * 默认就是继承Object的
   */
  public class GrandFather /* extends Object */ {
  }
  

• 不能双向: 父类不能再继承子类(会导致循环调用构造方法)

• 构造方法在继承中的要求: 子类在实例化的时候会主动调用父类的构造方法

  	//在构造方法中测试从Father中获取的内容
  	// 得到非私有的成员(private将成员的访问限制在Father中)
  	public Son() {
  		// 使用关键字super()来默认的调用父类的构造方法
  		//super();  // 调用空参构造
  		
  		super("张无忌");
  		
  		// 非私有都可以访问
  		//this.getName();
  		System.out.println(this.myMoney);
  		
  		// 私有字段子类到底继承了吗?
  		//this.setName("张无忌");
  		System.out.println(this.getName());
  	}
  

如果父类没有对应的构造方法,就提示super constructor Employee() is undefined

Java是用super关键字作为调用父类操作的对象

和this对比 , this.字段(类自己的) super.字段(父类的)

this(参数)调用类中的其他构造方法, super()调用父类的构造方法,作用,java要求子类继承父类的时候必须从父类的构造获得基本特征

super用于区分: 局部变量a/当前类的成员变量a/父类中声明a

​ super() 调用构造方法必须在代码的首行

一个使用this和super的示例:

public void f() {
		int i = 3;
		
		//输出三个不同的i: 父类/子类/方法局部的
		System.out.println("f() i:"+i);   //3  就近原则
		System.out.println("Son i:"+this.i);  //2 当前类的
		System.out.println("Father i:"+super.i); //1  父类的
	}

• 关于Object

父类派生子类,子类派生子类(一脉相承)

Object是java声明的默认的根父类

作用:让所有的java中的类一旦声明就默认具备一组方法(getClass/toString/hashCode)

也可以用来表示任意的对象类型

• 关于final , 终态

修饰变量 -> 常量

修饰类 -> 不可被继承

例如: 不需要被拓展的类

• protected 继承中的访问权限

关于Object中的方法

clone() 克隆对象,

面试: java中获取对象的方法? new/clone

equals() 比较两个对象是否相同

finalize() 垃圾回收的操作

垃圾: 声明完不用了的对象

垃圾回收: java自动完成的 – jvm自己判断,程序员不需要主动操作

当jvm执行垃圾回收的时候就会去调用finalize方法(final / finalize / finally)

getClass() 获取对象的Class(运行时Object),为反射操作提供的

hashCode() 对象的哈希码值

notify()

notifyAll()

wait()

wait(long timeout)

wait(long timeout, int nanos)

上述5个方法自成一组,属于线程(Thread)操作,线程操作要求所有对象对具备,所以他们也声明在了Object中

toString() 返回对象的字符串形式

笔试题:

public class A{

//成员语句块
 {
		System.out.println("1");
 }

 // 静态语句块

static{
	System.out.println("2");
 }

 // 构造方法
 public A(){
	System.out.println("3");
 }


public class B extends A{
 public B(){
	System.out.println("4");
 }

 public static void main(String[] args){
  // A a = new A();
	 B b= new B();
 }
}

多态

概念

父类引用指向子类对象

多种形态

Java不允许声明重名的字段/方法(如何判断调用了谁?)

从设计的角度,java的设计思想是名字用一样的,体现不同的功能(区分?)

方法的多态

• 重载:

在一个类中,存在一组方法,它们的方法名一致,但参数各不相同(数量或类型),这一组方法就构成了重载,用单词overload表示

• 作用: 让一个同名的方法组通过参数就可以完成不同的调用

• 重载和返回值无关

• 构造方法和实例方法都可以实现重载

  例如,在User类中把构造方法进行重载:

  public User(Integer id, String name, String phone, String pwd, Integer age) {
  			this.id = id;
  			this.name = name;
  			this.phone = phone;
  			this.pwd = pwd;
  			this.age = age;
  		}
  		
  		public User() {
  			
  		}
  		
  		public User(String name, String phone, String pwd, Integer age) {
  			this.name = name;
  			this.phone = phone;
  			this.pwd = pwd;
  			this.age = age;
  		}
  

• 重写

在继承过程中,如果子类声明了一个方法,和父类的方法声明完全一致,只有操作不同,父类和子类的方法就构成了重写

• 重写时,方法的声明部分(访问权限/返回类型/参数/方法名)都必须完全一致

• 用单词override表示,也被叫做覆盖

• 作用: 让子类和父类具有相同的行为,但,执行方式却不同,为对象的多态准备

• @Override 重写的注解,作用是检查是否符合重写格式

重写toString方法:

@Override
		public String toString() {
			return "User [id=" + id + ", name=" + name + ", phone=" + phone + ", age=" + age + "]";
		}

对象的多态

• 上转型对象

声明为高级类型(父类),传递引用的时候赋值为低级类型(子类), 声明对象就是上转型对象

• 上转型对象在执行到有重写的方法时,会执行子类(重写)

• 上转型对象可以调用父类中声明的方法(继承)

• 上转型对象不可以调用子类独有的方法

  Animal父类类型

  public class Animal {
  	
  	public void shout() {
  		System.out.println("动物的吼叫");
  	}
  	
  	@Override
  	public String toString() {
  		return "不知名的生物";
  	}
  
  }
  

  Cat子类类型

  public class Cat extends Animal{
  	
  	// 子类独有的方法
  	public void eatFish() {
  		System.out.println("吃鱼");
  	}
  	
  	// 重写父类的方法
  	public void shout(int i) {
  		System.out.println("喵喵喵");
  	}
  	
  	@Override
  	public String toString() {
  		return "大橘";
  	}
  }
  

  

  声明Animal类型的数组:

  public static void main(String[] args) {
  		
  		// 养了一群小动物
  		Animal[] animals = new Animal[3];
  		
  		// 添加小动物
  		animals[0] = new Animal();//动物的实例
  		animals[1] = new Cat();  //猫的实例
  		animals[2] = new Dog();  //狗的实例
  		...
  

• 下转型对象

  • 声明为低级类型(子类),传递引用的时候赋值为高级类型(父类)

  • 装箱和拆箱

  • 调用方法的时候,需要用强转还原原本类型(必须和原类型一致)

    // 声明的类型是父类类型, 实例化使用的是子类的构造
    		// a就叫做上转型对象
    		Animal a = new Cat();
    		Object o = new Cat();
    		
    		// 利用上转型对象,在集合List设置为可以添加任意类型
    		List<Object> list = new ArrayList<Object>();
    		list.add(1);
    		list.add("abc");
    		list.add(a);
    		list.add(o);
    		
    		// 上转型对象调用子类独有的方法, 不能
    		// 只能调用父类的或重写的方法
    		// a.eatFish();
    		
    		// 本质上是一个父类对象,强转为子类对象(下转型)可以编译通过,
    		//但执行就会抛出异常:ClassCastException
    		/*
    		 * Animal animal = new Animal(); ((Cat)animal).eatFish();
    		 */
    		
    		// 安全的下转型操作: 判断实例化时的对象类型
    		Animal animal2 = new Cat();
    		((Cat)animal2).eatFish();
    

• 使用场景

当代码中的数据类型是高级类型的时候(返回类型/参数类型/声明对象类型),程序会按照实际的引用来执行子类自己的重写方法

多态的使用思想

1. 先构建父子的类型的体系

2. 在使用类型的时候用父类作为高级的类型声明(兼容性,拓展)

3. 只要声明新的子类类型,它和原有操作就完全兼容

抽象(abstract)

问题

1. 如果UserManager的CRM管理程序中, 需不需要工作人员角色?
2. 是否需要设计一个实体类Manager?
3. 程序需不需要添加一个注册/登录环节, 谁作为注册和登录的主体? Manager
4. 如果增加的Manager和User之间是否存在相同的特征和方法? 存在

概念:

含有抽象方法的类

分析:

经过改造, 我们发现现在的User仅仅是作为BaseUser和Manager的共同父类(类的模板)

User在程序中不需要实例化, 甚至还要防止User被实例化

可否假设: 设计User的时候, 只要保证有基础字段和方法存在即可,甚至方法内容都不需要

改造过程:

改造1: 只保留User中最通用的操作 , 并添加abstract修饰符

abstract是用来修饰类/方法的表示抽象的修饰符

/**
 * abstract是一个修饰符,可以修饰类/方法
 * 经过abstract修饰的类成为抽象类
 * 用户类型: 通用的用于描述银行储户和工作人员的共同类型
 * @author bilei
 * @date 2021年7月28日  
 */
public abstract class User  {
	
	// 用户编号
		private  Integer id ;
		public Integer getId() {
			return id;
		}
		public void setId(Integer id) {
			this.id = id;
		}
		// 用户姓名
		private String name;
		
		public String getName() {
			return name;
		}
		public void setName(String name) {
		
			this.name = name;
		}
		
		// 用户手机
		private String phone;
		
		// 用户密码
		private String pwd;
		
		public String getPhone() {
			return phone;
		}

		public void setPhone(String phone) {
			this.phone = phone;
		}

		public String getPwd() {
			return pwd;
		}

		public void setPwd(String pwd) {
			this.pwd = pwd;
		}

		public User(Integer id, String name, String phone, String pwd) {
			this.id = id;
			this.name = name;
			this.phone = phone;
			this.pwd = pwd;
		}
		
		public User() {
			
		}
		
		public User(String name, String phone, String pwd) {
			this.name = name;
			this.phone = phone;
			this.pwd = pwd;
		}
		
		
		@Override
		public String toString() {
			return "User [id=" + id + ", name=" + name + ", phone=" + phone + "]";
		}
}

经过抽象声明的类不能实例化, 否则会在编译时报错

抽象类的作用

• 从派生的角度: 抽象类作为高级的父类类型,引导了子类该重写哪些方法

  

• 从使用的角度: 抽象类作为使用中一个高级(共同的)数据类型, 但,使用的时候,传递的一定是该抽象类的子类类型的引用 – 多态

• 发挥桥梁和纽带的作用 – 标准

  举例: 现实中: 卫生许可

  解读: 卫生局颁发给餐馆卫生许可,食客到餐馆吃饭

  抽象类: 卫生标准

  实现类(子类): 海底捞, 刘娘小面馆

  使用者: 食客

  

卫生许可标准Hygienism作为抽象类:

public abstract class Hygienism {
	
	protected String name;
	
	
	// 作为一个卫生标准, 自身不需要实现任何操作, 
	//作用是用于要求餐厅实现
	// 是否可以把方法体直接舍弃? 能, 该方法必须被声明为抽象方法
	// 抽象方法: 没有方法体的方法,必须用abstract修饰
	// 抽象方法所在的类也必须是抽象类
	
	public String getName() {
		return name;
	}


	public void setName(String name) {
		this.name = name;
	}


	// health相当于一个规范(标准)
	// 需要子类来遵守并实现
	public abstract  void health();

}

火锅类hotpot

/**
 * 火锅类
 * @author bilei
 * @date 2021年8月4日
 */
public abstract class Hotpot extends Hygienism {

	// 为什么火锅类也需要声明为抽象
	// 火锅类既要继承卫生的要求(此时还没实现)
	// 同时要提出新的要求: 火锅的好吃方式
	
	/*
	 * @Override public void health() { System.out.println("火锅店实现了卫生标准"); }
	 */
	
	public abstract void delicious();

}

海底捞子类:

public class HaiDiLao extends Hotpot{
	
	public HaiDiLao() {
		this.name = "海底捞";
	}

	@Override
	public void delicious() {
		
	}

	@Override
	public void health() {
		System.out.println("海底捞火锅实现了卫生标准");	
	}
}

选择美食-作为使用方, 应用卫生标准

public class ChoiseFood {
	
	//最重要的条件之一: 判断餐馆有没有实现卫生
	public static void judgeHealth(Hygienism hygienism) {
		
		// 用参数调用health方法
		hygienism.health();
		System.out.println("我选择的是:"+hygienism.getName());
	}
}

Main:

public static void main(String[] args) {
		
		// 选择饭店(必须满足卫生许可)
  	// 我们发现, 只要是Hygienism的子类, 都可以满足ChoiseFood方法judgeHealth的要求
		Hygienism h1 = new LaMian();
		
		Hygienism h2 = new HaiDiLao();
		
		LaMian l1 = new LaMian();
		
  // 当程序拓展, 增加了新的子类, 也可以直接融入到先前的程序结构中
		Hygienism c1 = new Chicken();
		
		//ChoiseFood.judgeHealth(h1);
		//ChoiseFood.judgeHealth(h2);
		
		//ChoiseFood.judgeHealth(l1);
		ChoiseFood.judgeHealth(c1);

	}

耦合度: 操作时的依赖程度(在编程的时候,耦合度)

解耦(解除耦合度): 在表达时抽象,在操作时具体

开发中的例子:

每次在控制台中输入操作的时候,使用Scanner类的构造方法之一:

Scanner中从控制台输入,实际使用的构造方法:

InputStream实际上是一个抽象类

当我们使用System.in作为参数, 作为符合参数要求的方式之一

Scanner s = new Scanner(System.in);

实际上, 还有很多其他的方式来满足该参数类型的要求(多态):

在网络程序的学习环节, 要学习另一种方式: 通过net捕获内容

FileInputStream extends InputStream

FileInputStream 是InputStream的子类

FileInputStream fis = new FileInputStream(new File("")); // 该操作目前不需要掌握

Scanner s2 = new Scanner(fis);

​

抽象父类: InputStream

子类: System.in / FileInputStream

使用方: Scanner(InputStream is)

特点

1. 抽象类自身不能实例化

2. 抽象类的抽象体系: 有没有可能,抽象类的子类没有实现抽象方法?

   当子类也是抽象类的时候,可以不实现抽象父类的抽象方法

   最终的实现类(非抽象的)得把整个体系中的抽象方法统统实现(重写)

3. 抽象类能不能没有抽象方法?如果能,作用?

   可以的,可以防止当前抽象类被实例化(该类不应该直接实例化使用,而是靠子类)

   子类直接从抽象父类中选择适合自己的方法直接使用,同时还拓展了新的方法

4. 抽象类和普通类比较: 成员(字段/方法/构造)? 和普通类没有区别

5. 构造方法在抽象类中的作用?

   可以为子类提供构造方法实现的模板: super()

6. 抽象类中的静态?

   可以, 类名.静态成员

   类和类之间的关系

   1. 继承
   2. 聚合: 一个类中的成员字段是对象类型
   3. 依赖: 一个类中的方法的参数是对象类型

   作业讲解

   1. 包的分工

      entity: 实体类(javabean: 包括私有字段/公共的getter和setter/ 公共的构造方法包括空参和全参 / toString())

      dao(Data Access Object): 包括针对某一个实体类的增删改查方法,方法中用参数体现输入的数据, 用返回值体现输出的数据

      view: 和用户交互的内容()

接口

思路: 和抽象类对比

问题:

1.  抽象类中如果抽象方法是最核心的内容, 属性不重要
2.  如果可以用接口改造, 是否还是用子类继承?

背景

抽象类,声明了可以被子类继承的成员变量/bean方法/构造 , 要求子类要实现的约束-抽象方法

如果一个类型中,存在的方法全部都是抽象方法(java.sql) , 且没有需要后代继承的成员

这样的类型的声明和class加以区分

概念

用interface声明的类型, 叫做接口类型 , 接口中只包含抽象方法和静态成员变量

和类相比,接口也是一种对象类型,接口没有构造方法

public interface Hygienism {
  void health();
}

示意图

使用

接口自身不能实例化对象

// 接口不能实例化, 编译会报错
		// Hygienism hygienism = new Hygienism();

接口需要通过实现类完成方法的实现,通过关键字 implements

格式: class 实现类 implements 接口名{ }

​ 类在实现对应的接口的时候,必须把接口中所有的抽象方法都实现

public class LaMian implements  Hygienism{
	
	private String name;
	public LaMian() {
		this.name = "兰州拉面";
	}
	// 子类继承重写父类,必须实现(重写)父类的抽象方法
	public void health() {
		System.out.println("兰州拉面馆实现了卫生标准");
	}
}

​ 实现时没有在方法中声明具体的操作 – 也算实现,叫做空实现,适配器模式中会应用, 在接口中方法比较多的情况下,我们只需要用到其中的个别方法,利用适配器类减少代码

public class LaMian implements  Hygienism{
	// 空实现也是实现的一种
	public void health() {		
	}
}

如果实现接口的是抽象类,那么抽象类可以不实现接口的方法,通常还会增加抽象方法

public abstract class Hotpot implements Hygienism {
	
	// 为什么火锅类也需要声明为抽象
		// 火锅类既要继承卫生的要求(此时还没实现)
		// 同时要提出新的要求: 火锅的好吃方式
		
	//单独定义一个当前抽象类需要的抽象方法
		public abstract void delicious();
}

​

接口如何实例化对象(利用多态)

接口类型 对象 = new 实现类类型();

// 接口的实例化要通过实现类创建
		Hygienism hygienism1 = new LaMian();
		Hygienism hygienism2 = new HaiDiLao();
		Hygienism hygienism3 = new Chicken();
		Hotpot hygienism4 = new HaiDiLao();

接口中还可以包含静态方法

//接口中可以声明static方法
	public static void f1() {
		System.out.println("Hygienism f1");
	}

调用时:

// 接口名直接调用
Hygienism.f1();

接口中还可以包含默认方法

// 接口中的默认方法: 用default
	public default void f2() {
		System.out.println("Hygienism f2");
	}

调用时:

// 调用接口中的默认方法: 
//通过多态方式实现的接口的实例化对象来调用
		hygienism4.f2(); 

接口中还可以包含常量

// 在接口中如果要声明成员字段,必须是常量,还默认是static, 还是public
	/* public static final */ String NAME = "卫生标准";

调用接口中的常量

// 调用接口中的成员字段name
		System.out.println("name:"+Hygienism.NAME);
		System.out.println("name:"+Hotpot.NAME);
		System.out.println("name:"+HaiDiLao.NAME);

final的使用:

修饰变量->常量(禁止被修改)

public static final double PI = 3.14;

修饰方法->禁止该方法被重写

public class Father {
  // 声明一个带有final修饰的终态方法
	public final void f() {
		System.out.println("Father f");
	}
}

public class Son extends Father {
	
	@Override
	public void f() {
		System.out.println("Son f");   //编译会报错, final方法不允许重写
	}
}

修饰类->禁止类被继承(终态类, String)

public final class String{}

作用:

1. 标准, 实现类都需要遵守的一套规范

2. 在实现类和使用方之间建立了一个联系的纽带(标准)

抽象类和接口的区别和联系?

相同点

• 含有抽象方法
• 都可以继承/派生
• 自身都不能直接实例化
• 都可以作为数据类型
• 功能: 都是作为实现(子类)和使用方的联系纽带 多态

不同点

• 继承的方式不同(接口通过实现implements / 抽象类通过继承extends)
• 声明的内容 接口中只能包含抽象方法(1.8后增加了静态方法和默认方法), 抽象类可以包含类能包含的所有内容
• 接口没有构造
• 抽象类有根父类(Object)
• 访问权限 , 抽象类中可以用4种 接口只能是public
• 为什么接口是public(现实中 USB接口规范)
• 抽象类之间可以继承且是单继承; 接口之间可以产生多继承关系(java唯一一种多继承)

接口操作的特殊性

接口可以继承接口

//父接口
public interface A {
	public void a();
}

//子接口
public interface B extends A {
	public void b();
}

实现类要实现所有的方法:

public class BB implements B {

	@Override
	public void a() {
	}
	@Override
	public void b() {
	}
}

接口可以多继承(java中唯一)

/**
 * 在java中只有一种多继承机制: 接口可以多继承
 * @author bilei
 * @date 2021年8月5日
 */
public interface D extends A,A2{
	public void d();
}

实现时所有的方法都要实现:

public class DD implements D {

	@Override
	public void a() {
	}

	@Override
	public void a2() {
	}

	@Override
	public void d() {
	}

}

类可以在继承父类的基础上再实现其他接口(多实现)

```java
public class EE extends DD implements A,A2 {

	/*
	DD父类已经实现了接口方法, 故这里不用实现了
	 * @Override public void a() { // TODO Auto-generated method stub
	 * 
	 * }
	 */

}
```

使用的选择: 当涉及到抽象的时候,到底该用谁 ?

从实操角度(抽象方法的使用): 接口是主导 解耦(降低耦合 Spring框架)

如果存在 “是…” 的关系 用抽象类

如果存在 “有…” 的关系 用接口

例如:

​ 防盗门 继承 门(父类,抽象)

​ 防盗门 有 指纹识别功能(接口 )

程序中如何使用？
抽象类：实体类（entity/factory AbstractFactory）
接口：dao/service(UserService/UserServiceImpl)

在UserManager程序中使用接口实现程序之间的解耦应用

运用接口重新设计ManagerDao

public interface ManagerDao {
	Manager login(Integer id, String pwd) ;
}

设计ManagerDaoImpl

public class ManagerDaoImpl implements ManagerDao {
	
	// 创建一个添加管理员对象的数组
		private Manager[] managers = new Manager[3];
		
		// 注册环节省略(内置)
		{
			Manager manager = new Manager();
			manager.setId(101);
			manager.setName("admin");
			manager.setPwd("123456");

			Manager manager2 = new Manager();
			manager2.setId(102);
			manager2.setName("root");
			manager2.setPwd("123321");

			managers[0] = manager;
			managers[1] = manager2;
		}
	
	
	/**
	 * 登录方法
	 * 
	 * @param id
	 * @param pwd
	 * @return 返回登录成功后的对象
	 */
	public Manager login(Integer id, String pwd) {
		for (Manager manager : managers) {
			if (manager != null && id.equals(manager.getId()) && pwd.equals(manager.getPwd())) {
				return manager;
			}
		}
		return null;
	}
}

在Main中创建UserDao的实例(多态方式,实现类创建)

// 创建ManagerDao的实例,通过实现类ManagerDaoImpl实例化(多态)
	private static ManagerDao managerDao = new ManagerDaoImpl();
 
//.....

// 使用
// 管理员登录,登录成功才执行储户操作
		System.out.println("请输入管理员id");
		Integer id = scanner.nextInt();
		
		System.out.println("请输入管理员密码"); // pwd: password
		String pwd = scanner.next();
		Manager manager =  managerDao.login(id, pwd);

使用): 接口是主导 解耦(降低耦合 Spring框架)

如果存在 “是…” 的关系 用抽象类

如果存在 “有…” 的关系 用接口

例如:

​ 防盗门 继承 门(父类,抽象)

​ 防盗门 有 指纹识别功能(接口 )

在UserManager程序中使用接口实现程序之间的解耦应用

[外链图片转存中…(img-mEcdvreI-1628159414228)]

运用接口重新设计ManagerDao

public interface ManagerDao {
	Manager login(Integer id, String pwd) ;
}

设计ManagerDaoImpl

public class ManagerDaoImpl implements ManagerDao {
	
	// 创建一个添加管理员对象的数组
		private Manager[] managers = new Manager[3];
		
		// 注册环节省略(内置)
		{
			Manager manager = new Manager();
			manager.setId(101);
			manager.setName("admin");
			manager.setPwd("123456");

			Manager manager2 = new Manager();
			manager2.setId(102);
			manager2.setName("root");
			manager2.setPwd("123321");

			managers[0] = manager;
			managers[1] = manager2;
		}
	
	
	/**
	 * 登录方法
	 * 
	 * @param id
	 * @param pwd
	 * @return 返回登录成功后的对象
	 */
	public Manager login(Integer id, String pwd) {
		for (Manager manager : managers) {
			if (manager != null && id.equals(manager.getId()) && pwd.equals(manager.getPwd())) {
				return manager;
			}
		}
		return null;
	}
}

在Main中创建UserDao的实例(多态方式,实现类创建)

// 创建ManagerDao的实例,通过实现类ManagerDaoImpl实例化(多态)
	private static ManagerDao managerDao = new ManagerDaoImpl();
 
//.....

// 使用
// 管理员登录,登录成功才执行储户操作
		System.out.println("请输入管理员id");
		Integer id = scanner.nextInt();
		
		System.out.println("请输入管理员密码"); // pwd: password
		String pwd = scanner.next();
		Manager manager =  managerDao.login(id, pwd);