正文：
举个例子：如果现在要想定义一个动物，那么动物肯定是一个公共的标准，而这个公共标准就可以通过接口来完成。
在动物中又分为两类：哺乳动物、卵生动物，而这个标准属于对动物的标准进一步细化，应该称为子标准，所以此种关系可以使用接口的继承来表示。
而哺乳动物可以继续划分为人、狗、猫等不同的类型，由于这些类型不表示具体的事物标准，所以可以使用抽象类进行表示。
如果要表示出工人或者学生这样的概念，则肯定是一个具体的定义，则使用类的方式。
然后每个学生或者每个工人都是具体的，那么就通过对象来表示；
由下面的图可知，所有的设计中，接口应该是最先被设计出来的，被子类所继承。
代码实例化：
package java从入门到项目实战.抽象类与接口;
//动物
interface animal{
public abstract string breathe();
}
//哺乳动物---接口继承extend
//类实现的话--implements
interface 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());
}
}
接口：
1.接口的基本定义：
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());
}
}
2.子类实现多个父接口与实例转换
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());
}
}
3.子类继承抽象类同时实现接口
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());
}
}
4.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) {
}
}
5.接口的加强
为什么需要加强接口：首先需要明白，在接口下的子类需要覆写父类的方法，如果该接口下有1000多个子类，不巧的是接口需要增加方法，那么每个子类都要覆写一遍新添的方法，想想都很恐怖；在此基础上增加了弥补的方法
5.1 增加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());
}
}
}
5.2 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;
}
}
7.抽象类的构造方法
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());
}
}
8.抽象类中定义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());
}
}
9.模板设计模式
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中的对象、类、抽象类、接口、继承之间的联系的文章就介绍到这了,更多相关java中的对象、类、抽象类、接口、继承之间的联系内容请搜索www.887551.com以前的文章或继续浏览下面的相关文章希望大家以后多多支持www.887551.com！
黄山市民网：https://www.huangshanshimin.com/
