接口是一种程序结构,是特殊的抽象类。接口中的方法必须都是公开的抽象方法(public abstract),接口中的属性都是公开静态常量(public static final)。
声明一个接口用 interface 关键字,接口也是一种类型,编译之后也有生成相应字节码,他的声明规范也要符合类型的定义(一个源文件中只能有一个public interface,接口名和源文件名相同,有public interface,就不能在写public class了)。接口中的属性可以不加修饰符,方法也不用加修饰符。
接口也可以继承,但是只能由接口继承,在用类去继承时要换用 implements 关键字,这时类和接口也不叫做继承关系,而是实现关系,但其实质也是继承。
一个类可以继承也只能继承另外一个类,但是可以实现多个接口,其语法是在implements后面写接口名,多个接口以“,”分隔。
接口之间是可以多继承的,其语法和类的继承语法是相同的,在接口多继承时,在extends后写接口名如果要继承多个接口,接口名以“,”分隔,接口的继承关系只是把其父接口中的抽象方法继承到子接口中。要实现接口就必须实现接口中的所有方法。
一个类可以在继承一个类的同时,也可以实现一个或多个接口。采用接口就绕开了单继承限制。
接口类型也可以做为编译时类型使用,但其实际的运行时类型必须是完全实现接口的类的对象实例,这样就使多态变得很灵活了,
注意:实现接口时,在实现(覆盖)抽象方法时,注意必须要在方法的返回值类型前加public修饰符。如果没有完全实现接口中的方法,那么这个类就只能够是个抽象类,不能创建对象。接口的是实质就是特殊的抽象类。接口没有构造方法。
接口的意义:
1,接口可以实现多继承。
2,用接口可以实现混合类型(主类型,副类型),java中可以通过接口分出主次类型。主类型使用继承,副类型,使用接口实现。
3,接口进一步深化了标准的思想,接口本身就是一个标准,他起到了降低耦合性的作用,接口可以使方法的定义和实现相分离,也就是将接口的定义者和实现者相分离,接口也可以用于降低模块间或系统间的耦合性。针对接口编程可以屏蔽不同实现间的差异,看到的只是实现好的功能,
接口:定义标准,
接口的实现:实现标准
接口的使用:标准的使用
针对接口编程原则,也就是按照标准实现。
先有接口的定义,再有接口使用者,最后把接口的是先对象川入接口的使用者中,接口的使用者会通过接口来调用接口实现者的方法。
接口的定义者定义好了标准,接口的使用者先写好了使用代码,接口的实现者写好实现之后把实现对象传入接口的使用者中。他会回调接口中的方法。这种过程叫做接口的回调。
尽量使用接口类型作为编译时类型,尽量将抽取到的共性行为写在接口中。
用若干个小接口取代一个大接口。(接口隔离原则)
把一个类的功能作成接口,只暴露想暴露的方法,接口隔离原则可以实现更高层次的封装,针对的对象不同,暴露的方法也不同。
java中的根类Object
java中所有的类的父类或直接或间接的或隐含的都是Object类。
java不允许循环继承,也就是互相继承是不可以的。
Object类中的finalize()一个对象被垃圾收集的时候,
Object类中有一个String toString()方法,返回该对象的字符串表示。Object类中的toString()方法他返回的是类名加上他的地址的一个字符串。在子类中推荐覆盖toString()方法。
Object类中的boolean equals(Object o)方法是用来比较对象的内容是否相等,其返回值是boolean类型的值,相同为真,不同则为假。实际上还是比较对象地址是否相同。String类覆盖了equals()方法,他比较是对象中的内容是否相同。子类中也推荐覆盖Object类中继承的equals()方法
equals()的覆盖原则,
自反性 x.equals(x) 为true
对称性 y.equals(x) 和 x.equals(y) 的值要相同,要么都为true,要么都为false。
传递性 x.equals(y)为true, y.equals(z)也为true ,那么x.equals(z)一定也为true。
覆盖equals()方法的步骤
boolean equals(Object o){
if(this==o) return true;//1,看看是不是一个对象
if(o==null) return true;//2,看看对象是不是空
if(!(o instanceof 本类类名)) return false;//看看是不是本类对象
......//根据本类设计。
=============
声明一个接口用 interface 关键字,接口也是一种类型,编译之后也有生成相应字节码,他的声明规范也要符合类型的定义(一个源文件中只能有一个public interface,接口名和源文件名相同,有public interface,就不能在写public class了)。接口中的属性可以不加修饰符,方法也不用加修饰符。
接口也可以继承,但是只能由接口继承,在用类去继承时要换用 implements 关键字,这时类和接口也不叫做继承关系,而是实现关系,但其实质也是继承。
一个类可以继承也只能继承另外一个类,但是可以实现多个接口,其语法是在implements后面写接口名,多个接口以“,”分隔。
接口之间是可以多继承的,其语法和类的继承语法是相同的,在接口多继承时,在extends后写接口名如果要继承多个接口,接口名以“,”分隔,接口的继承关系只是把其父接口中的抽象方法继承到子接口中。要实现接口就必须实现接口中的所有方法。
一个类可以在继承一个类的同时,也可以实现一个或多个接口。采用接口就绕开了单继承限制。
接口类型也可以做为编译时类型使用,但其实际的运行时类型必须是完全实现接口的类的对象实例,这样就使多态变得很灵活了,
注意:实现接口时,在实现(覆盖)抽象方法时,注意必须要在方法的返回值类型前加public修饰符。如果没有完全实现接口中的方法,那么这个类就只能够是个抽象类,不能创建对象。接口的是实质就是特殊的抽象类。接口没有构造方法。
接口的意义:
1,接口可以实现多继承。
2,用接口可以实现混合类型(主类型,副类型),java中可以通过接口分出主次类型。主类型使用继承,副类型,使用接口实现。
3,接口进一步深化了标准的思想,接口本身就是一个标准,他起到了降低耦合性的作用,接口可以使方法的定义和实现相分离,也就是将接口的定义者和实现者相分离,接口也可以用于降低模块间或系统间的耦合性。针对接口编程可以屏蔽不同实现间的差异,看到的只是实现好的功能,
接口:定义标准,
接口的实现:实现标准
接口的使用:标准的使用
针对接口编程原则,也就是按照标准实现。
先有接口的定义,再有接口使用者,最后把接口的是先对象川入接口的使用者中,接口的使用者会通过接口来调用接口实现者的方法。
接口的定义者定义好了标准,接口的使用者先写好了使用代码,接口的实现者写好实现之后把实现对象传入接口的使用者中。他会回调接口中的方法。这种过程叫做接口的回调。
尽量使用接口类型作为编译时类型,尽量将抽取到的共性行为写在接口中。
用若干个小接口取代一个大接口。(接口隔离原则)
把一个类的功能作成接口,只暴露想暴露的方法,接口隔离原则可以实现更高层次的封装,针对的对象不同,暴露的方法也不同。
java中的根类Object
java中所有的类的父类或直接或间接的或隐含的都是Object类。
java不允许循环继承,也就是互相继承是不可以的。
Object类中的finalize()一个对象被垃圾收集的时候,
Object类中有一个String toString()方法,返回该对象的字符串表示。Object类中的toString()方法他返回的是类名加上他的地址的一个字符串。在子类中推荐覆盖toString()方法。
Object类中的boolean equals(Object o)方法是用来比较对象的内容是否相等,其返回值是boolean类型的值,相同为真,不同则为假。实际上还是比较对象地址是否相同。String类覆盖了equals()方法,他比较是对象中的内容是否相同。子类中也推荐覆盖Object类中继承的equals()方法
equals()的覆盖原则,
自反性 x.equals(x) 为true
对称性 y.equals(x) 和 x.equals(y) 的值要相同,要么都为true,要么都为false。
传递性 x.equals(y)为true, y.equals(z)也为true ,那么x.equals(z)一定也为true。
覆盖equals()方法的步骤
boolean equals(Object o){
if(this==o) return true;//1,看看是不是一个对象
if(o==null) return true;//2,看看对象是不是空
if(!(o instanceof 本类类名)) return false;//看看是不是本类对象
......//根据本类设计。
=============
1. 接口作为副类型
public class TestEmployee{
public static void main(String[] args){
Employee[] es=new Employee[4];
es[0]=new SalariedEmployee("Liucy",8,5000);
es[1]=new HourlyEmployee("Chenzq",2,40,200);
es[2]=new SalesEmployee("DuBin",8,0.03,80000);
es[3]=new BasePlusSalesEmployee("Winnie",10,0.08,150000,8000);
for(int i=0;i<es.length;i++){
System.out.println(es[i].getName()+": "+es[i].getSalary(
8));
}
//判断对象是否是Plusable对象,可以加班的对象
//强制转成Plusable,计算加班费
double d=0;
for(int i=0;i<es.length;i++){
if (es[i] instanceof Plusable){
Plusable p=(Plusable)es[i];
d+=p.getPlusSalary();
}
}
System.out.println(d);
}
}
class Employee{
private String name;
private int month;
public Employee(String name, int month) {
this.name = name;
this.month = month;
}
public String getName() {
return name;
}
//一般员工的共性部分,判断生日
public double getSalary(int month){
if(this.month==month) return 100;
else return 0;
}
}
interface Plusable{
double getPlusSalary();
}
class SalariedEmployee extends Employee implements Plusable{
private double salary;
//构造参数设置父类属性
public SalariedEmployee(String name, int month,double salary) {
super(name, month);
this.salary=salary;
}
public double getSalary(int month){
return salary+super.getSalary(month)+getPlusSalary();
}
public double getPlusSalary(){
return 1000;
}
}
class HourlyEmployee extends Employee{
private double salaryPerHour;
private int hours;
public HourlyEmployee(String name, int month, double salaryPerHour, int hours) {
super(name, month);
this.salaryPerHour = salaryPerHour;
this.hours = hours;
}
public double getSalary(int month){
double r=0;
if (hours>160){
r=160*this.salaryPerHour+(hours-160)*1.5*this.salaryPerHour;
}
else {
r=this.hours*this.salaryPerHour;
}
return r+super.getSalary(month);
}
}
class SalesEmployee extends Employee implements Plusable{
private double rate;
private int sales;
public SalesEmployee(String name, int month, double rate, int sales) {
super(name, month);
this.rate = rate;
this.sales = sales;
}
public double getSalary(int month){
return rate*sales+super.getSalary(month)+getPlusSalary();
}
public double getPlusSalary(){
return 100;
}
}
class BasePlusSalesEmployee extends SalesEmployee{
private double baseSalary;
public BasePlusSalesEmployee(String name, int month, double rate, int sales, double baseSalary) {
super(name, month, rate, sales);
this.baseSalary = baseSalary;
}
public double getSalary(int month){
return baseSalary+super.getSalary(month);
}
}
=================
2. 相当于一个标准,实现解藕合,把接口的使用者与实现者分开
//判断一个数是不是合数,是合数的打印出其质数积的形式
// 定义了两个接口
// Prime.java
public interface Prime{
boolean isPrime(int i);
}
// FenJie.java
public interface FenJie{
void print(int i);
}
// FenJieImpl.java 实现接口 FenJie
public class FenJieImpl implements FenJie{
Prime p;
public FenJieImpl(Prime p){
this.p=p;
}
public void print(int i){
for(int j=2;j<=i/2;j++){
if (i%j==0 && p.isPrime(j)){
int k=i/j;
if (p.isPrime(k)){
System.out.println(j+"*"+k);
}
else{
System.out.print(j+"*");
print(k);
}
break;
}
}
}
}
//PrimeImpl.java 实现接口Prime
public class PrimeImpl implements Prime{
public boolean isPrime(int i){
for(int j=2;j<i;j++){
if (i%j==0) return false;
}
return true;
}
}
// Print.java 使用接口
public class Print{
public static void main(String[] args){
Prime p=new PrimeImpl();
FenJie f=new FenJieImpl(p);
MyClass mc=new MyClass(p,f);
mc.business();
}
}
// 使用接口
class MyClass{
Prime p;
FenJie f;
public MyClass(Prime p,FenJie f){
this.p=p;
this.f=f;
}
public void business(){
for(int i=2;i<=100;i++){
if (!(p.isPrime(i))){
System.out.print(i+"=");
f.print(i);
}
}
}
}
=================
public class TestEmployee{
public static void main(String[] args){
Employee[] es=new Employee[4];
es[0]=new SalariedEmployee("Liucy",8,5000);
es[1]=new HourlyEmployee("Chenzq",2,40,200);
es[2]=new SalesEmployee("DuBin",8,0.03,80000);
es[3]=new BasePlusSalesEmployee("Winnie",10,0.08,150000,8000);
for(int i=0;i<es.length;i++){
System.out.println(es[i].getName()+": "+es[i].getSalary(
8));
}
//判断对象是否是Plusable对象,可以加班的对象
//强制转成Plusable,计算加班费
double d=0;
for(int i=0;i<es.length;i++){
if (es[i] instanceof Plusable){
Plusable p=(Plusable)es[i];
d+=p.getPlusSalary();
}
}
System.out.println(d);
}
}
class Employee{
private String name;
private int month;
public Employee(String name, int month) {
this.name = name;
this.month = month;
}
public String getName() {
return name;
}
//一般员工的共性部分,判断生日
public double getSalary(int month){
if(this.month==month) return 100;
else return 0;
}
}
interface Plusable{
double getPlusSalary();
}
class SalariedEmployee extends Employee implements Plusable{
private double salary;
//构造参数设置父类属性
public SalariedEmployee(String name, int month,double salary) {
super(name, month);
this.salary=salary;
}
public double getSalary(int month){
return salary+super.getSalary(month)+getPlusSalary();
}
public double getPlusSalary(){
return 1000;
}
}
class HourlyEmployee extends Employee{
private double salaryPerHour;
private int hours;
public HourlyEmployee(String name, int month, double salaryPerHour, int hours) {
super(name, month);
this.salaryPerHour = salaryPerHour;
this.hours = hours;
}
public double getSalary(int month){
double r=0;
if (hours>160){
r=160*this.salaryPerHour+(hours-160)*1.5*this.salaryPerHour;
}
else {
r=this.hours*this.salaryPerHour;
}
return r+super.getSalary(month);
}
}
class SalesEmployee extends Employee implements Plusable{
private double rate;
private int sales;
public SalesEmployee(String name, int month, double rate, int sales) {
super(name, month);
this.rate = rate;
this.sales = sales;
}
public double getSalary(int month){
return rate*sales+super.getSalary(month)+getPlusSalary();
}
public double getPlusSalary(){
return 100;
}
}
class BasePlusSalesEmployee extends SalesEmployee{
private double baseSalary;
public BasePlusSalesEmployee(String name, int month, double rate, int sales, double baseSalary) {
super(name, month, rate, sales);
this.baseSalary = baseSalary;
}
public double getSalary(int month){
return baseSalary+super.getSalary(month);
}
}
=================
2. 相当于一个标准,实现解藕合,把接口的使用者与实现者分开
//判断一个数是不是合数,是合数的打印出其质数积的形式
// 定义了两个接口
// Prime.java
public interface Prime{
boolean isPrime(int i);
}
// FenJie.java
public interface FenJie{
void print(int i);
}
// FenJieImpl.java 实现接口 FenJie
public class FenJieImpl implements FenJie{
Prime p;
public FenJieImpl(Prime p){
this.p=p;
}
public void print(int i){
for(int j=2;j<=i/2;j++){
if (i%j==0 && p.isPrime(j)){
int k=i/j;
if (p.isPrime(k)){
System.out.println(j+"*"+k);
}
else{
System.out.print(j+"*");
print(k);
}
break;
}
}
}
}
//PrimeImpl.java 实现接口Prime
public class PrimeImpl implements Prime{
public boolean isPrime(int i){
for(int j=2;j<i;j++){
if (i%j==0) return false;
}
return true;
}
}
// Print.java 使用接口
public class Print{
public static void main(String[] args){
Prime p=new PrimeImpl();
FenJie f=new FenJieImpl(p);
MyClass mc=new MyClass(p,f);
mc.business();
}
}
// 使用接口
class MyClass{
Prime p;
FenJie f;
public MyClass(Prime p,FenJie f){
this.p=p;
this.f=f;
}
public void business(){
for(int i=2;i<=100;i++){
if (!(p.isPrime(i))){
System.out.print(i+"=");
f.print(i);
}
}
}
}
=================
3. 接口的回调
// WorldCupCountry.java 定义接口
public interface WorldCupCountry{
void kaimushi();
void xiaozusai();
void taotaisai();
void juesai();
}
// WorldCupCountry.java 实现接口
public class USA implements WorldCupCountry{
public void kaimushi(){
System.out.println("德国-玻利维亚");
}
public void xiaozusai(){
System.out.println("沙特黑马");
}
public void taotaisai(){
System.out.println("保加利亚");
}
public void juesai(){
System.out.println("巴西");
}
}
// Germany.java 实现接口
public class Germany implements WorldCupCountry{
public void kaimushi(){
System.out.println("德国-哥斯达黎加");
}
public void xiaozusai(){
System.out.println("强者恒强");
}
public void taotaisai(){
System.out.println("四强全欧");
}
public void juesai(){
System.out.println("意大利");
}
}
// IFFO.java 使用接口
public class FIFA{
public static void main(String[] args){
WorldCupCountry c=new USA();
act(c);
}
public static void act(WorldCupCountry c){
c.kaimushi();
c.xiaozusai();
c.taotaisai();
c.juesai();
}
}
public interface WorldCupCountry{
void kaimushi();
void xiaozusai();
void taotaisai();
void juesai();
}
// WorldCupCountry.java 实现接口
public class USA implements WorldCupCountry{
public void kaimushi(){
System.out.println("德国-玻利维亚");
}
public void xiaozusai(){
System.out.println("沙特黑马");
}
public void taotaisai(){
System.out.println("保加利亚");
}
public void juesai(){
System.out.println("巴西");
}
}
// Germany.java 实现接口
public class Germany implements WorldCupCountry{
public void kaimushi(){
System.out.println("德国-哥斯达黎加");
}
public void xiaozusai(){
System.out.println("强者恒强");
}
public void taotaisai(){
System.out.println("四强全欧");
}
public void juesai(){
System.out.println("意大利");
}
}
// IFFO.java 使用接口
public class FIFA{
public static void main(String[] args){
WorldCupCountry c=new USA();
act(c);
}
public static void act(WorldCupCountry c){
c.kaimushi();
c.xiaozusai();
c.taotaisai();
c.juesai();
}
}