java抽象类、接口，equals重写

abstract抽象类

学习抽象类：

​ 1、父类中定义的方法不需要具体的实现步骤、没有方法体。

​ 2、父类中定义这个方法的目的是告诉子类 一定要保证存在该方法。

对于类的要求：

​ 1：父类中不需要定义方法的实现步骤

​ 2：子类必须要重写父类的抽象方法

抽象类：

​ 1、包含了抽象方法的的类称之为抽象类。

​ 2、被abstract修饰的类称之为抽象了

抽象方法：

​ 1、只要方法的声明，没有方法体。 通过abstract修饰的方法称之为抽象方法。

为什么需要抽象类？

1、避免子类的随意设计

2、提高了代码可读性

3、提高了子类的健壮

final

1、final修饰的变量称之为最终常量

2、在程序运行期间其值不可发生改变

3、final修饰的类不可以被继承

4、final修饰的方法不可以被重写

接口

接口：

1、接口是一个规范 是一套标准 比抽象了还抽象

2、接口如何定义：

​ 修饰符 interface 接口名{}

3、接口中的变量都是公开的，静态的最终常量值，默认情况下变量都是public static final修饰

4、接口中可以定义静态方法(不建议1.8之后才可以)

5、接口中定义的对象方法都是抽象方法 接口中的方法默认就是通过abstract修饰的

6、接口中的默认方法从1.8之后才开始被使用，允许在接口中定义default方法 而且存在方法体

重写equals方法

重写的原因：

​ 在object中，只有String引用类型在比较的时候可以比较里面的具体内容，而其他变量再比较时，用的也是“==”，不能满足我们的需求，所以需要进行重写。

​

public boolean equals(Object obj) {
	if(obj instanceof Person) {//先比较对象类型是否相同
		Person s = (Person)obj;//强制转换
		if(s.name.equals(this.name)&&s.age==this.age&&s.sex==this.sex) {//一一比较
			return true;
		}
		return false;
	}
	return false;
}

重写equals方法，比较对象Person中的成员变量。

面向对象写一个计算器

接口

package Calculator;

interface Calculator{
	public double Calculation();
}

实现类

加“+”

package Calculator;

public  class sum implements Calculator {
	double numA;
	double numB;
	@Override
	public double Calculation() {
		// TODO Auto-generated method stub
		return this.numA+this.numB;
	}
	public sum() {
		
	}
	public sum(double numA,double numB) {
		this.numA=numA;
		this.numB=numB;
	}

}

减“-”

package Calculator;

public class reduce implements Calculator {
	double numA;
	double numB;
	public double Calculation() {
		// TODO Auto-generated method stub
		return this.numA-this.numB;
	}
	public reduce() {
		
	}
	public reduce(double numA,double numB) {
		this.numA=numA;
		this.numB=numB;

	}

}

乘“*”

package Calculator;

public class ride implements Calculator {
	double numA;
	double numB;

	@Override
	public double Calculation() {
		// TODO Auto-generated method stub
		return this.numA*this.numB;
	}
	public ride() {
		
	}
	public ride(double numA,double numB){
		this.numA=numA;
		this.numB=numB;
	}

}

除“/”

package Calculator;

public class except implements Calculator {
	double numA;
	double numB;
	

	public double Calculation() {
		return this.numA/this.numB;		
	}
	public except() {
		
	}
	public except(double numA,double numB) {
		this.numA=numA;
		this.numB=numB;
	}

}

运行

package Calculator;

public class Function {
	Calculator cal;
	public double Fun(Calculator cal) {
		return cal.Calculation();
	}
}

测试类

package Calculator;

import java.util.Scanner;

public class Text01 {

	public static void main(String[] args) {
		double result=0;
		Scanner input=new Scanner(System.in);
		System.out.println("请输入你要计算的numA:");
		double numA=input.nextInt();
		System.out.println("请输入你要计算的numB:");
		double numB=input.nextInt();
		System.out.println("请输入你要计算的符号（+）（-）（*）（/）:");
		String F=input.next();
		Function Fun=new Function();
		switch(F) {
		case "+":
			result=Fun.Fun(new sum(numA,numB));
			break;
		case "-":
			result=Fun.Fun(new reduce(numA,numB));
			break;
		case "*":
			result=Fun.Fun(new ride(numA,numB));
			break;
		case "/":
			result=Fun.Fun(new except(numA,numB));
			break;
		default:
			System.out.println("输入的运算符号错误！");
			return;
		}
		System.out.println("结果是"+result);
	}

}