接口（9.23）——————————课后练习

package exception;
/*
按要求编写Java程序：
（1）编写一个接口：InterfaceA，只含有一个方法int method(int n)；
（2）编写一个类：ClassA来实现接口InterfaceA，实现int method(int n)接口方
法时，要求计算1到n的和；
（3）编写另一个类：ClassB来实现接口InterfaceA，实现int method(int n)接口
方法时，要求计算n的阶乘（n!）；
（4）编写测试类E，在测试类E的main方法中使用接口回调的形式来测试实现
接口的类。
*/

//接口A
public interface InterfaceA
{
int method(int n) ;
}

class A  implements  InterfaceA
{
@Override
public int method(int n)
{
int i ;
int sum = 0 ;
for( i=1 ; i<n+1 ; i++ )
{
sum += i ;
}
return sum ;
}

}

class B  implements  InterfaceA
{

@Override
public int method(int n)
{
int i ;
int sum = 1 ;
for( i=1 ; i<n+1 ; i++ )
{
sum *= i ;
}
return sum ;
}
}

package exception;

public class E {

public static void main(String[] args)
{
A a = new A( ) ;
System.out.println("1到10和=" );
InterfaceA b = a ;
System.out.println(b.method(10));

B c = new B( ) ;
System.out.println("1到10乘积=" );
InterfaceA d = c ;
System.out.println(d.method(10)) ;
}

}

package exception;
/*
编写2个接口：InterfaceA和InterfaceB；在接口InterfaceA中有个方法void
printCapitalLetter()；在接口InterfaceB中有个方法void printLowercaseLetter()；然
后写一个类Print实现接口InterfaceA和InterfaceB，要求printCapitalLetter()方法
实现输出大写英文字母表的功能，printLowercaseLetter()方法实现输出小写英文
字母表的功能。再写一个主类E，在主类E的main方法中创建Print的对象并赋
值给InterfaceA的变量a，对象a调用printCapitalLetter方法；最后再在主类E
的main方法中创建Print的对象并赋值给InterfaceB的变量b，对象b调用
printLowercaseLetter方法。
*/

//接口A
public interface InterfaceA
{
void printCapitalLetter( ) ;
}

//接口B
interface InterfaceB
{
void printLowercaseLetter( ) ;
}

class Print  implements  InterfaceA,InterfaceB
{

@Override
public void printLowercaseLetter()
{
System.out.println("ABCDEFGHIJKLMNOPQRSTUVWXYZ");
}

@Override
public void printCapitalLetter()
{
System.out.println("abcdefghijklmnopqrstuvwxyz");
}

}

package exception;

public class E {

public static void main(String[] args)
{
Print a = new Print( ) ;

System.out.println("A接口：" );
InterfaceA b = a ;
b.printCapitalLetter();

System.out.println("B接口：" );
InterfaceB c = a ;
c.printLowercaseLetter();
}

}

package exception;
/*
中国特色社会主义的体制中有这样的现象：地方省政府要坚持党的领导和按
照国务院的指示进行安全生产。请编写一个java应用程序描述上述的体制现象。
要求如下：
（1）该应用程序中有一个“党中央”接口：CentralPartyCommittee，该接口中
有个“坚持党的领导”方法：void partyLeader()
（2）该应用程序中有一个“国务院”抽象类：StateCouncil，该抽象类中有个“安
全生产”的抽象方法：abstract void safetyInProduction()
（3）该应用程序中有一个“省政府”类：Province，该类继承StateCouncil抽象
类并且实现CentralPartyCommittee接口；在实现partyLeader()方法时输出“我们
各省人民一定坚持党的领导！”；在重写safetyInProduction()方法时输出“我们各
省人民一定按照国务院的指示进行安全生产！”。
（4）该应用程序中有一个主类E1，在主类E的main方法中创建Province类的对
象，来测试Province类的功能。
*/
public interface CentralPartyCommittee
{
void partyLeader( );
}

abstract class StateCouncil
{
abstract void safetyInProduction( ) ;
}

class Province extends StateCouncil implements CentralPartyCommittee
{

@Override
public void partyLeader()
{
System.out.println("我们各省人民一定坚持党的领导！");
}

@Override
void safetyInProduction()
{
System.out.println("我们各省人民一定按照国务院的指示进行安全生产！");
}

}

package exception;

public class E1 {

public static void main(String[] args)
{
Province a = new Province( ) ;
a.safetyInProduction();

CentralPartyCommittee b = a ;
b.partyLeader();
}

}

package exception;
/*
利用接口做参数，写个计算器，能完成加减乘除运算
（1）定义一个接口Compute含有一个方法int computer(int n,int m);
（2）设计四个类分别实现此接口，完成加减乘除运算
（3）设计一个类UseCompute，含有方法：
public void useCom(Compute com, int one, int two)
此方法要求能够：1．用传递过来的对象调用computer方法完成运算
2．输出运算的结果
*/

//接口
public interface Compute
{
public int computer(int n,int m) ;
}

//加法类
class Jia implements  Compute
{

@Override
public int computer(int n, int m)
{
return n+m;
}

}

//减法类
class Jian implements  Compute
{

@Override
public int computer(int n, int m)
{
return n-m;
}

}

//乘法类
class Cheng implements  Compute
{

@Override
public int computer(int n, int m)
{
return n*m;
}

}

//除法类
class Chu implements  Compute
{

@Override
public int computer(int n, int m)
{
if(m==0)
{
System.out.println("被除数不能为0");
}
return n/m;
}

}

//新建类实现调用
class UseCompute
{
public void useCom(Compute com, int one, int two)
{
System.out.println(com.computer(one,two) );
}

}

package exception;

import javax.naming.InsufficientResourcesException;

public class CeShiUseCompute {

public static void main(String[] args)
{
UseCompute a = new UseCompute( ) ;
System.out.print("2+3=");
a.useCom(new Jia(), 2, 3);
System.out.print("2-3=");
a.useCom(new Jian(), 2, 3);
System.out.print("2*3=");
a.useCom(new Cheng(), 2, 3);
System.out.print("3/2=");
a.useCom(new Chu(), 3, 2);
System.out.print("2/3=");
a.useCom(new Chu(), 2, 3);
System.out.println("这里因为是 int 型 ，所以除法的话就是取整运算");
System.out.print("3/0=");
a.useCom(new Chu(), 6, 0);
}
}

package exception;

//接口
public interface CanSwim
{
public void swim( ) ;
}

//接口
interface CanFly
{
public void fly( ) ;
}

//抽象父类
abstract class ActionCharacter
{
//抽象方法
public abstract void fight(String emp);

//成员方法
public void speak(String s)
{
System.out.println(s);
}
}

//建一个新的类，先继承后实现多个接口
class Hello extends ActionCharacter implements CanFly , CanSwim
{
//成员属性
public String name ;

//无参、有参构造方法
Hello( )
{

}

Hello( String name )
{
this.name = name ;
}
@Override
public void swim()
{
System.out.println(name + "游泳");
}

@Override
public void fly()
{
System.out.println(name + "飞");
}

@Override
public void fight(String emp)
{
System.out.println(name + "用"+emp+"打小日本");
}

}

package exception;

public class Adventure {

public static void main(String[] args)
{
Hello hb1 = new Hello( "啄木鸟" ) ;
hb1.fly();
hb1.speak("叽叽喳喳");

Hello hb2 = new Hello( "小明" ) ;
hb2.swim();
hb2.speak("嘻嘻哈哈");

CanFly cf = hb1 ;
cf.fly();

CanSwim cs = hb2 ;
cs.swim();

ActionCharacter ac = hb2 ;
ac.fight("手枪");
}

}