接口(下)
承接接口(上)
接口可以写:
1.抽象方法(实现类必须重写)
2.静态变量
3.静态方法 static修饰
4.默认方法(可选择重写) default修饰
(在实现类中 不强制要求你重写默认方法)
实现类中可以重写默认方法 但是不能用default修饰
默认方法可以参考 多态的使用
// 默认方法的调用
接口.super.默认方法名
// 举例: 接口
interface Inter{
// 抽象方法
public abstract void abstractfun();
// 静态方法
public static void staticfun(){
System.out.println("我是接口中的 静态方法");
}
// 默认方法
public default void defaultfun(){
System.out.println("我是接口中的 默认方法");
}
}
// 实现类
class Interimpl implements Inter{
// 重写抽象方法
@Override
public void abstractfun(){
System.out.println("我是实现类中的 重写的抽象方法");
}
// 选择重写默认方法
@Override
public void defaultfun() {
System.out.println("我是实现类中 重写的默认方法");
}
// 静态方法
public static void staticfun() {
System.out.println("我是实现类中的 静态方法");
}
// 实现类中的特有成员方法
public void test() {
// 调用接口中的静态方法
Inter.staticfun();
// 调用接口中的默认方法
Inter.super.defaultfun();
}
}抽象类与接口的区别
1.使用方式:
抽象类: 继承 extends
接口: 实现 implements
2.成员变量
抽象类: 变量 常量
接口: 只有常量(默认public static final 修饰)
3.成员方法
抽象类: 抽象方法 成员方法
接口: 抽象方法(静态方法 和 默认方法)
4.构造方法
抽象类: 有构造
接口: 没构造
类与类之间的关系
单继承 (多层继承,如爷,父,孙)
类与接口之间的关系
实现 ( 可以实现多个接口[规则] )
接口与接口之间的关系
单继承 多继承
// 测试 类与接口多实现
interface InterA{
public abstract void fun1();
}
interface InterB{
public abstract void fun2();
}
class ClassA implements InterA,InterB{
@Override
public void fun2() {
// TODO Auto-generated method stub
}
@Override
public void fun1() {
// TODO Auto-generated method stub
}
}
// 测试接口和接口之间的关系
interface InterC{
public abstract void fun1();
}
interface InterD extends InterC{
}
class ClassB implements InterD{
@Override
public void fun1() {
// TODO Auto-generated method stub
}
}// 缺省适配器模式( 选择性实现接口中抽象方法 )
/*
* 缺省适配器模式
* 1.使用一个适配器类 实现接口 实现接口中所有方法
* 方法使用空实现
* 2.用户类 再来继承这个适配器类
* 3.用户类可以选择性重写
*
* 健身房(规则) 接口
* 跑步机
* 卧推
* 游泳
*
* 适当性选择几个
* 跑步
*/
// 接口
interface JSF{
public abstract void woTui();
public abstract void running();
public abstract void swimming();
}
// 适配器类Adapter,实现接口
// 当类没有实际意义,不需要创建该类的对象时
// 可以声明为抽象类
abstract class Adapter implements JSF{
public void woTui() {};
public void running() {};
public void swimming() {};
}
// 用户类
class WangJun extends Adapter{
@Override
public void running() {
// TODO Auto-generated method stub
System.out.println("慢跑10分钟");
}
} // 接口练习一
/*
* 经过国际主板研究协会讨论
* 最终要求 主板生产商 要按规则生产可插卡的主板(插卡的方法)
* 所有的卡都要有 开始和停止的方法
*
* 设计完成 生产 大力牌主板
* 主板接口(插卡方法)
* 抽象卡类(开始和停止的方法)
* 声卡 继承抽象类
* 大力牌主板 实现接口
*/
// 声明接口
interface UserCard{
// 多态插卡方法
public abstract void userCard(Card card);
}
// 声明主板类
class MainBoardImpl implements UserCard{
@Override
public void userCard(Card card) {
// TODO Auto-generated method stub
card.start();
card.stop();
}
}
// 声明 抽象卡类
abstract class Card{
public abstract void start();
public abstract void stop();
}
// 声明 声卡类
class SongCard extends Card{
@Override
public void start() {
// TODO Auto-generated method stub
System.out.println("开始唱歌");
}
@Override
public void stop() {
// TODO Auto-generated method stub
System.out.println("结束唱歌");
}
}// 接口练习二(仅作示例,可观察在本类创建其他类对象作为成员变量的过程)
/* 需求:
* 1.人类 吃 姓名 性别
* 2.男人类 姓名 性别 有女朋友 吃肉 (介绍女朋友是谁和性别 并介绍自己是谁)
* 3.女人类 姓名 性别 有男朋友 吃素 (介绍男朋友是谁和性别 并介绍自己是谁)
* 4.男人可以挣钱给女朋友花 接口 男人类实现
* 5.女的特有方法 整容 开眼角 丰唇
* (要求构造方法/set/get方法)
* 6.写测试类测试
*/
// 1.人类 吃 姓名 性别
// 人类
abstract class Person{
private String name;
private String gender;
// 无参构造方法
public Person() {
super();
}
// 有参构造方法
public Person(String name, String gender) {
super();
this.name = name;
this.gender = gender;
}
// set/get方法
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getGender() {
return gender;
}
public void setGender(String gender) {
this.gender = gender;
}
// 声明抽象方法
public abstract void eat();
}
// 2.男人类 姓名 性别 有女朋友 吃肉
// (介绍女朋友是谁和性别 并介绍自己是谁)
//男人类
public class Man extends Person implements Cost{
// 使用其他类的对象,来当做自己类的成员变量
// (女朋友)
private Women gF ;
// 构造方法 无参
public Man() {
}
// 有参构造方法
public Man(String name,String gender,Women gF) {
// 先调用父类的有参构造方法
super(name,gender);
// 给自己特有的成员变量 赋值
this.gF = gF;
}
// set/get方法
public Women getgF() {
return gF;
}
public void setgF(Women gF) {
this.gF = gF;
// return this,这样后面可以直接修改其他属性
}
// 吃 方法重写
@Override
public void eat() {
// TODO Auto-generated method stub
System.out.println("男吃肉");
}
// 介绍方法
public void sayHi() {
// 现获取女朋友的对象 对象.get方法获取名字性别
System.out.println("我的女朋友是:" + this.getgF().getName());
System.out.println("性别:" + this.getgF().getGender());
System.out.println("我是" + this.getName());
}
// 实现接口中的方法
@Override
public void makeMoney() {
// TODO Auto-generated method stub
System.out.println("挣钱给女朋友花");
}
}
// 3.女人类 姓名 性别 有男朋友 吃素
// (介绍男朋友是谁和性别 并介绍自己是谁)
//女人类
class Women extends Person{
// 使用其他类的对象,作为自己的成员变量
// 男朋友
private Man bF;
// 无参构造方法
public Women() {
super();
// TODO Auto-generated constructor stub
}
// 有参构造方法
public Women(String name, String gender,Man bF) {
super(name, gender);
this.bF = bF;
}
// set/get方法
public Man getbF() {
return bF;
}
public void setbF(Man bF) {
this.bF = bF;
}
// 吃 方法重写
@Override
public void eat() {
// TODO Auto-generated method stub
System.out.println("吃素");
}
// 整容方法
public void changeFace(String body) {
System.out.println("整容部位是:" + body);
}
// 介绍方法
public void sayHi() {
System.out.println("我的男朋友是" + this.getbF().getName());
System.out.println("性别:" + this.getbF().getGender());
System.out.println("我是" + this.getName());
}
}
// 4.接口 挣钱
public interface Cost {
public void makeMoney();
}
// 5.测试运行
public class Test {
public static void main(String[] args) {
// 创建一个男生对象
Man man = new Man();
Women women = new Women();
// 男的赋值
man.setName("张三");
man.setGender("男");
man.setgF(women);
// 女的赋值
women.setName("翠花");
women.setGender("女");
women.setbF(man);
man.sayHi();
women.sayHi();
// 拥有一个其他类的对象 当做成员变量
// 可以用get方法调出来 其他类的对象
// 取出来之后 这个类的所有方法我都能调用
// 取出对象women
man.getgF().changeFace("拉双眼皮");
// 取出对象man
women.getbF().makeMoney();
}
}