正文：
举个例子：如果现在要想定义一个动物，那么动物肯定是一个公共的标准，而这个公共标准就可以通过接口来完成。
在动物中又分为两类：哺乳动物、卵生动物，而这个标准属于对动物的标准进一步细化，应该称为子标准，所以此种关系可以使用接口的继承来表示。
而不如动物i可以继续划分为人、狗、猫等不同的类型，由于这些类型不表示具体的事物标准，所以可以使用抽象类进行表示。
如果要表示处工人或者学生这样的概念，则肯定是一个具体的定义，则使用类的方式。
然后每个学生或者每个工人都是具体的，那么就通过对象来表示；
由下面的图可知，所有的设计中，接口应该是最先被设计出来的，被子类所继承。
代码实例化：
package Java从入门到项目实战.抽象类与接口;//动物interface animal{ public abstract String breathe();
}//哺乳动物---接口继承extend//类实现的话--implementsinterface mammals extends animal {// 全局方法// 抽象方法}//卵生动物interface Egg_laying_animals extends animal {// 全局方法// 抽象方法}//定义人类抽象类(属于哺乳动物)abstract class peopel implements mammals{
}//定义非人类抽象类(输入哺乳动物)abstract class small_animal implements mammals{
}//学生 属于人类中class student extends peopel{ @Override
public String breathe() { return null;
}
}public class 接口综合 { public static void main(String[] args) {// 对象：类的实例化
student std = new student();
System.out.println(std.breathe());
}
}
接口：接口的基本定义：package Java从入门到项目实战.抽象类与接口;interface IMessageF{ //在接口可以定义全局变量、抽象方法(public权限)、default方法以及static方法；
//如果接口中有抽象方法，那么接口必须需要子类进行实例化
public static final String INFO = "xbhog"; //全局变量
public abstract String getInfo(); //抽象方法}class MessageIpml implements IMessageF{ @Override
public String getInfo(){ //方法覆写
return "hello xbhog!"; //获取消息
}
}public class 接口的基本使用 { public static void main(String[] args) { //接口的调用 实例化
IMessageF msg = new MessageIpml(); //子类实例化父类接口
System.out.println(msg.getInfo());
}
}
子类实现多个父接口与实例转换package Java从入门到项目实战.抽象类与接口;interface Imessage1{ public static final String INFO = "xbhog"; public abstract String getInfo();
}interface IChannel{ public abstract boolean connect();
}//实现多个接口，继承了两个，所以在子类中需要进行覆写父类中的抽象方法class MessageImpl1 implements Imessage1,IChannel{ @Override
public String getInfo(){ if(this.connect()){ return "博客地址：www.cnblogs.com/xbhog/";
} return "【默认消息】"+ Imessage1.INFO;
} @Override
public boolean connect(){ return true;
}
}public class 子类实现多个父接口 { public static void main(String[] args) {
Imessage1 msg = new MessageImpl1();
System.out.println(msg.getInfo()); //--------观察接口实例转换-------------
Imessage1 msg1 = new MessageImpl1();
Object obj = msg1; //向上转型
IChannel channel = (IChannel) obj; //对象强制转换成IChannel接口实例
System.out.println(channel.connect());
}
}
子类继承抽象类同时实现接口package Java从入门到项目实战.抽象类与接口;//消息接口interface IMessage1{ public static final String INFO = "xbhog"; public abstract String getInfo();
}//通道接口interface IChannel1{ public abstract boolean connect();
}//定义一个抽象类abstract class DatabaseAbstract{ public abstract boolean getDatabaseConnection();
}//继承于抽象类，同时实现接口class MessageImpl2 extends DatabaseAbstract implements IMessage1,IChannel1{ @Override
public String getInfo() { if (this.connect()){ if(this.getDatabaseConnection()){ return "【数据库消息】博客地址：https://www.cnblogs.com/xbhog/";
}else { return "数据库消息无法访问！";
}
} return "【默认消息】："+IMessage1.INFO;
} @Override
public boolean connect() { return true;
} @Override
public boolean getDatabaseConnection() { return true;
}
}public class 子类继承抽象类并实现接口 { public static void main(String[] args) {
IMessage1 msg = new MessageImpl2();
System.out.println(msg.getInfo());
}
}
extends继承多个父接口
关于接口的简化：在定义接口时，对于全局常量和抽象方法可以省略static final与 abstract关键字;package Java从入门到项目实战.抽象类与接口;interface Imessage3{ public static final String INFO = "xbhog"; public abstract String getInfo();
}interface IChannel3{ public boolean connect(); //抽象方法，省略了abstract;}interface IService extends Imessage3,IChannel3{ public String service(); //抽象方法，省略了abstract;}class MessageService implements IService{ @Override
public String getInfo() { return Imessage3.INFO;
} @Override
public boolean connect() { return false;
} @Override
public String service() { return "【数据库消息服务】：https://www.cnblogs.com/xbhog/";
}
}public class 使用extends继承多个父接口 { public static void main(String[] args) {
}
}
接口的加强
为什么需要加强接口：首先需要明白，在接口下的子类需要覆写父类的方法，如果该接口下有1000多个子类，不巧的是接口需要增加方法，那么每个子类都要覆写一遍新添的方法，想想都很恐怖；在此基础上增加了弥补的方法增加default定义普通方法：便于扩充接口同时简化设计结构package Java从入门到项目实战.抽象类与接口;interface IMessage{// 必须覆写
public String message(); //抽象类
public default String messageSmple(){ return "null";
};// 定义接口普通方法，增加了接口的灵活性// 当子类过多是，增加一个新的方法，那么需要每个子类都需要覆写一边// default的普通方法解决了该问题，当子类需要的时候覆写，不需要时放置
public default boolean connect(){
System.out.println("建立关注xbhog的通道...."); return true;
}
}class MessageImpl implements IMessage{ public String message(){ return "xbhog";
}
}public class 接口定义加强使用default定义普通方法 { public static void main(String[] args) {
IMessage msg = new MessageImpl(); if(msg.connect()){
System.out.println(msg.message());
}
}
}
default缺点：必须通过接口实例化对象才能调用，为了避免实例化对象的依赖，可以使用static方法，隐藏接口调用的细节package Java从入门到项目实战.抽象类与接口;interface ImessageS{ public String message();// 定义公共方法，被所有子类继承
public default boolean connect(){
System.out.println("建立订阅xbhog博客的通道....."); return true;
}// 建立static静态方法，可以通过接口名称直接调用
public static ImessageS getInstance(){// 获得子类对象
return new MessageImple();
}
}class MessageImple implements ImessageS{ public String message(){ if(this.connect()){
return "www.cnblogs.com/xbhog";
} return "null";
}
}public class 在接口中定义static方法 { public static void main(String[] args) {// 实例化子类接口对象
ImessageS msg = ImessageS.getInstance();
System.out.println(msg.message());
}
}
抽象类：
抽象类的特点：含有抽象方法的类一定是抽象类
抽象类不一定还有抽象方法
抽象类中既可以有抽象方法也可以有非抽象放方法
如果子类继承了抽象方法，要么重写抽象类中的抽象方法，要么子类就声明为抽象类
不能创建对象，因为方法没有具体实现，创建对象没有作用，抽象类是用来继承的
基本定义abstract class Message{
private String type;
public abstract String getConnectInfo();//抽象方法
public void setType(String type){ //普通方法
this.type = type;
}
}
抽象类的构造方法package Java从入门到项目实战.抽象类与接口;//构造抽象方法abstract class abMessage{
private String type; //此时抽象类中没有提供无参构造方法，所以在子类必须明确调用单参构造方法
public abMessage(String type){ this.type = type;
} public abstract String getContentInfo(); public String getType() { return type;
} public void setType(String type) { this.type = type;
}
}class Database extends abMessage{ //子类构造
public Database(String type) { //调用父类单参构造方法
super(type);
}//覆写抽象类方法
@Override
public String getContentInfo() {
return "【"+super.getType()+"】数据库连接信息";
}
}public class 构造方法 { public static void main(String[] args) {
abMessage demo = new Database("xbhog");
System.out.println(demo.getContentInfo());
}
}
抽象类中定义static 方法：该类方法不受到抽象类实例化对象的限制package Java从入门到项目实战.抽象类与接口;abstract class message{
public abstract String getInfo(); public static message getInstance(){ return new datamessage();
}
}class datamessage extends message{ @Override
public String getInfo() { return "xbhog数据库连接";
}
}public class 抽象类定义static { public static void main(String[] args) { //因为该方法被static修饰，全局使用message.getInstance相当于new datamessage();
message mes = message.getInstance();
System.out.println(mes.getInfo());
}
}
模板设计模式package Java从入门到项目实战.抽象类与接口;//抽象三个公共行为abstract class Action{
static final int EAT = 1; //吃饭指令
static final int SLEEP = 5; //睡觉指令
static final int WORK = 10; //工作指令
public abstract void eat(); public abstract void sleep(); public abstract void work(); public void command(int code){
switch (code){
case EAT:{ this.eat(); break;
} case SLEEP:{ this.sleep(); break;
} case WORK:{ this.work(); break;
} case EAT+SLEEP+WORK:{ this.eat(); this.sleep();
this.work(); break;
}
}
}
}//具象化 机器人class Rebot extends Action{ @Override
public void eat() {
System.out.println("机器人需要接通电源充电");
} @Override
public void sleep() { } //机器人不需要睡觉
@Override
public void work() {
System.out.println("机器人按照固定的设置进行工作");
}
}//具象化 人class Person extends Action{ @Override
public void eat() {
System.out.println("人需要吃五谷杂粮来维持生命力");
} @Override
public void sleep() {
System.out.println("不睡觉会死的");
} @Override
public void work() {
System.out.println("每天工作996");
}
}//具象化 猪class pig extends Action{ @Override
public void eat() {
System.out.println("使劲吃，养肥了卖钱");
} @Override
public void sleep() {
System.out.println("不睡觉，养不肥");
} @Override
public void work() {
}
}public class 模板设计模式 { public static void main(String[] args) {
Action rebotAction = new Rebot();
Action personAction = new Person();
Action pigAction = new pig();
System.out.println("机器人行为---------");
rebotAction.command(Action.SLEEP);
rebotAction.command(Action.WORK);
System.out.println("人类行为----------");
personAction.command(Action.WORK+Action.SLEEP+Action.EAT);
System.out.println("猪的行为-------");
pigAction.command(Action.SLEEP);
}
}
综合案例练习：
实现相关代码：
package Java从入门到项目实战.抽象类与接口;//定义人这个类abstract class people{
private String name; private String age; public people() {} public people(String name,String age){ this.name = name; this.age= age;
} public abstract void eats(); //定义抽象方法
public void setName(String name) { this.name = name;
} public void setAge(String age) { this.age = age;
} public String getName() { return name;
} public String getAge() { return age;
}
}//定义运动员抽象类abstract class athletes extends people{ public athletes(){} public athletes(String name, String age){
super(name,age);
}// 抽象方法
public abstract void study();
}interface speakEnglish{ public abstract void speak();
}//定义教练的抽象类abstract class coach extends people{ public coach(){} public coach(String name,String age){ super(name,age);
} public abstract void teach();
}//篮球运动员class Basketball_player extends athletes{ public Basketball_player(String name, String age){ super(name,age);
} @Override
public void eats() {
System.out.println("篮球运动员正在吃饭....");
} @Override
public void study() {
System.out.println("篮球运动员正在学习......");
}
}//乒乓球远动员class pingpang extends athletes implements speakEnglish{ public pingpang(String name, String age){ super(name,age);
} @Override
public void eats() {
System.out.println("乒乓球运动员正在吃饭....");
} @Override
public void study() {
System.out.println("乒乓球运动员正在学习......");
} @Override
public void speak() {
System.out.println("乒乓球运动员练习英语口语......");
}
}//乒乓球教练class pingpangCoach extends coach implements speakEnglish{ public pingpangCoach(String name, String age){
super(name,age);
} @Override
public void eats() {
System.out.println("乒乓球教练正在吃饭.....");
} @Override
public void teach() {
System.out.println("乒乓球教练正在授课....");
} @Override
public void speak() {
System.out.println("乒乓球教练练习英语口语.....");
}
}//篮球教练class BasketballCoach extends coach{
public BasketballCoach(String name, String age){ super(name, age);
} @Override
public void eats() {
System.out.println("篮球教练正在吃饭");
} @Override
public void teach() {
System.out.println("篮球教练正在授课......");
}
}public class 综合案例实现 { public static void main(String[] args) {
}
}
结束：
整理最近学习Java的相关概念，理清思路。
如果有错误欢迎指正，感谢各位看到最后！
616
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
