Java从零开始学十八(抽象类和接口)
一、什么是抽象类和接口
抽象类、接口与类是一个层次的概念，是java中极其重要的概念。
抽象类是从多个类中抽象出来的公共模板，提供子类均具有的功能。
接口是从多个类中抽象出来的规范，体现的是规范和实现分离的原则，同时也有效的解决了java单重继承的缺陷
二、抽象类
2.1、抽象类与普通类的区别
- 抽象类的class前面有abstract关键字，而普通类没有
/*
* 抽象类
*/
public abstract class Person1 {} /*
* 普通类
*/
public class Person {}
- 抽象类中可以有抽象方法和普通方法，而普通类中只能有普通方法
- 普通类可以实例化使用new，而抽象类不能实例化
2.2、抽象方法与普通方法区别
- 抽象方法的前面有abstract关键字，而普通方法没有
- 抽象方法没有方法体，而普通方法有方法体
/*
* 抽象方法
*/
public abstract void show();
//没有方法体 /*
* 普通方法
*/
public void show(){
System.out.println("这是个普通方法");
}
/*
* 普通类中不能有抽象方法
*/
2.3、完整对比2个类
package com.pb.demo3;
/*
* 普通类
*/
public class Person {
private String name; //名称
private int age ; //年龄 /*
* 普通方法
*/
public void show(){
System.out.println("这是个普通方法");
}
/*
* 普通类中不能有抽象方法
*/ //setter/getter方法
public String getName() {
return name;
} public void setName(String name) {
this.name = name;
} public int getAge() {
return age;
} public void setAge(int age) {
this.age = age;
} }
package com.pb.demo3;
/*
* 抽象类
*/
public abstract class Person1 {
private String name; //名称
private int age ; //年龄 /*
* 抽象方法
*/
public abstract void show();
//没有方法体 //抽象类中可以有普通方法
public void printSelf(){
System.out.println("这是个抽象类中的普通方法"); }
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
} }
2.4、如果抽象类被继承
- 如果子类不是抽象类，则必须重写父类抽象类的全部抽象方法。(普通方法选择重写或者不写)
package com.pb.demo3;
/*
* 学生类继承Person1抽象类
*/
public class Student extends Person1 { //继承时，会强制要求重写父类的抽象方法
@Override
public void show() {
System.out.println("重写父类的抽象方法"); } }
2.5 、一些注意事项
- abstract不能与final关键字一起使用
- private 关键字不能修饰抽象方法
- abstract修饰的抽象方法没有方法体
2.6、图像对比
三、接口
3.1、接口定义
接口使用interface关键字来定义
简单的说，接口是一个不能实例化，且只能拥有抽象方法的类型
public interface 接口名称{
抽象方法
}
public interface Person {
}
package com.pb.demo4;
public interface Person {
/*
* 定义2个抽象方法
*/
public void run();
public void say();
}
3.2.为什么接口中的抽象方法不用使用abstract关键字?
因为接口中只能有抽象方法，所以不必专门使用abstract关键字来修饰，当然也可以加上不过完全没有必要
3.3、接口的抽象方法
接口的抽象方法只能由public来修饰
四、使用抽象类和接口
4.1、抽象类使用继承来实现
/*
* 抽象类
*/
public abstract class Person { /*
* 普通方法
*/
public void run(){
System.out.println("抽象类的普通方法! 走一走");
} /*
* 抽象方法
*/
public abstract void say();
}
/*
* 继承抽象类
*/
public class Student extends Person{ @Override
public void say() {
System.out.println("实现父类的抽象方法!说一说"); } }
public class Test {
public static void main(String[] args) {
//声明子类对象
Student stu=new Student();
//调用子类重写的方法
stu.say();
//调用父类的普通方法
stu.run();
}
}
结果:
实现父类的抽象方法!说一说
抽象类的普通方法! 走一走
4.2、接口的使用
使用implements来实现接口，解决java中单继承的关系，接口可以是多个
package com.pb.demo4;
public interface Person {
/*
* 定义2个抽象方法
*/
public void run();
public void say();
}
package com.pb.demo4; /*
* 实现接口Person
*/
public class PersonImp implements Person { /*
* 必须重写接口的全部抽象方法
*/
@Override
public void run() {
System.out.println("实现接口的走一走抽象方法"); } @Override
public void say() {
System.out.println("实现接口的说一说抽象方法"); } }
package com.pb.demo4;
public class Test {
public static void main(String[] args) {
//声明对象
PersonImp p=new PersonImp();
//调用实现的方法
p.run();
p.say();
}
}
结果:
实现接口的走一走抽象方法
实现接口的说一说抽象方法
4.3 、对比实现
五、抽象类和接口的简单区别
5.1、区别
- 抽象类使用abstract声明，接口使用interface声明
- 抽象类可以有抽象方法也可以有普通方法,接口只能有抽象方法
- 实现方式不同:抽象类使用继承extends来实现，接口使用implements来实现
5.2、相同点
- 抽象类和接口都不能实例化
5.3、图形对比
5.4、使用规则
- 抽象类和接口都不能实例化
- 抽象类与接口分别被继承与实现的场合，其子类必须实现其中的抽象方法
- 抽象类中的抽象方法访问修饰符不能为private，接口中的抽象方法访问修饰符必须为public
六、简单实现抽象类
package com.pb.demo5;
/*
* 鸟类抽象类
*/
public abstract class Bird { /*
* 飞的普通方法
*/
public void fly(){
System.out.println("弹射飞!");
}
/*
* 攻击抽象方法
*/
public abstract void attack(); }
package com.pb.demo5;
/*
* 火箭鸟
*/
public class RocketBird extends Bird { /*
* 重写攻击方法
*/
@Override
public void attack() {
System.out.println("火箭鸟攻击方式：加速冲撞！"); } }
package com.pb.demo5;
/*
* 分裂鸟
*/
public class SplittBird extends Bird { /*
* 重写攻击方法
*/
@Override
public void attack() {
System.out.println("分裂鸟攻击方式：分裂攻击！");
} }
package com.pb.demo5;
public class Test {
public static void main(String[] args) {
/*
* 多态的应用
*/
//创建鸟类对象，实例化为分裂鸟对象
Bird splitbird=new SplittBird();
//创建鸟类对象，实例化为火箭鸟对象
Bird rocketbird=new RocketBird();
//分别调用鸟类的普通飞的方法
//分别调用子类重写后的叫方法
//分别调用子类重写后的攻击方法
splitbird.fly();
splitbird.attack();
rocketbird.fly();
rocketbird.attack();
}
}
结果:
弹射飞!
分裂鸟攻击方式：分裂攻击！
弹射飞!
火箭鸟攻击方式：加速冲撞！
从上例子中可以看出：子类相同的方法，如：飞的方法 可以放在父类的抽象类中使用普通方法实现，实现代码的重用，而不同的部分，使用抽象方法，子类来实现自己的方法，简单来讲：抽象类就是抽取公共的部分在抽象来中来实现
如：完全没有相同的方法，但都有这此方法，该怎么实现呢？这时候就需要接口大神出场
七、简单接口实现
还是以上例为例，比如，连有叫的方法，但每种 鸟的叫声都不一样呢？有的会叫，有的不会叫，
package com.pb.demo5;
/*
* 叫的接口
*/
public interface Shout {
/*
* 叫的方法
*/
public void shout();
}
package com.pb.demo5; public class AoShoutImpl implements Shout { @Override
public void shout() {
System.out.println("嗷嗷叫！"); } }
package com.pb.demo5; public class ZhaShoutImpl implements Shout { @Override
public void shout() {
System.out.println("喳喳叫！"); } }
package com.pb.demo5; public class NoCanShoutImpl implements Shout { @Override
public void shout() {
System.out.println("不会叫！"); } }
package com.pb.demo5;
/*
* 鸟类抽象类
*/
public abstract class Bird {
Shout shout; /*
* 构造方法
*/ public Bird(Shout shout) {
super();
this.shout = shout;
}
/*
* 叫的普通方法
*/
public void shout(){
//调用自身叫的方法
shout.shout();
} /*
* 飞的普通方法
*/
public void fly(){
System.out.println("弹射飞!");
} /*
* 抽象攻击方法
*/
public abstract void attack(); }
package com.pb.demo5; /*
* 炸弹鸟
*/
public class Bombbird extends Bird { public Bombbird(Shout shout) {
super(shout);
} @Override
public void attack() {
System.out.println("炸弹鸟攻击方式：炸弹攻击"); } @Override
public void shout() {
System.out.println("炸弹鸟：喳喳叫!"); } }
package com.pb.demo5; /*
* 胖子鸟
*/
public class Fatbird extends Bird { public Fatbird(Shout shout) {
super(shout); } @Override
public void attack() {
System.out.println("胖子鸟攻击方式：下蛋攻击"); } @Override
public void shout() {
System.out.println("胖子鸟：不会叫!"); } }
package com.pb.demo5; /*
* 红色鸟
*/
public class Redbird extends Bird { public Redbird(Shout shout) {
super(shout); } @Override
public void attack() {
System.out.println("红色鸟攻击方式：普通攻击"); } @Override
public void shout() {
System.out.println("红色鸟：喳喳叫!"); } }
package com.pb.demo5; import com.pb.demo5.Bird; /*
* 火箭鸟
*/
public class RocketBird extends Bird { public RocketBird(Shout shout) {
super(shout); } /*
* 重写攻击方法
*/
@Override
public void attack() {
System.out.println("火箭鸟攻击方式：加速冲撞！"); } /*
* 重写叫的方法
*/
@Override
public void shout() {
System.out.println("火箭鸟：嗷嗷叫！"); } }
package com.pb.demo5; /*
* 分裂鸟
*/
public class SplittBird extends Bird { public SplittBird(Shout shout) {
super(shout); }
/*
* 重写攻击方法
*/
@Override
public void attack() {
System.out.println("分裂鸟攻击方式：分裂攻击！");
}
/*
* 重写叫的方法
*/
@Override
public void shout() {
System.out.println("分裂鸟：嗷嗷叫！"); } }
package com.pb.demo5;
import com.pb.demo5.Bird;
public class Test {
public static void main(String[] args) {
/*
* 创建接口对象
*/
Shout aoshout=new AoShoutImpl();
Shout zhashout=new ZhaShoutImpl();
Shout noshout=new NoCanShoutImpl();
/*
* 多态的应用
*/
//创建鸟类对象，实例化为分裂鸟对象
Bird splitbird=new SplittBird(aoshout);
Bird rocketbird=new RocketBird(aoshout);
Bird bomb=new Bombbird(zhashout);
Bird redbird=new Redbird(zhashout);
Bird fatbird=new Fatbird(noshout);
splitbird.fly();
splitbird.attack();
splitbird.shout();
rocketbird.fly();
rocketbird.shout();
rocketbird.attack();
bomb.fly();
bomb.shout();
bomb.attack();
redbird.fly();
redbird.shout();
redbird.attack();
fatbird.fly();
fatbird.shout();
fatbird.attack();
}
}
结果:
弹射飞!
分裂鸟攻击方式：分裂攻击！
分裂鸟：嗷嗷叫！
弹射飞!
火箭鸟：嗷嗷叫！
火箭鸟攻击方式：加速冲撞！
弹射飞!
炸弹鸟：喳喳叫!
炸弹鸟攻击方式：炸弹攻击
弹射飞!
红色鸟：喳喳叫!
红色鸟攻击方式：普通攻击
弹射飞!
胖子鸟：不会叫!
胖子鸟攻击方式：下蛋攻击
由上可以看出：抽象类方便代码复用，接口方便代码维护
Java从零开始学十八(抽象类和接口)的更多相关文章
- 夯实Java基础（十）——抽象类和接口
转载自:http://cmsblogs.com/ 该博主的网站上干货非常!非常!非常多(说三遍),强烈推荐大家前去学习. 接口和内部类为我们提供了一种将接口与实现分离的更加结构化的方法 抽象类与接口是 ...
- Java从零开始学十九(异常)
一.什么是异常 从字面上讲,就是不正常的现实就是异常. 程序中的异常也是要在程序运行中才会偶尔发生.如果程序还没有运行,编译就报错,这种不叫异常,这种叫编译错误,通常是语法上的错误 二.java中异常 ...
- Java从零开始学二十三(集合Map接口)
一.Map接口 Collection.Set.List接口都属于单值的操作,即:每次只能操作一个对象,而Map与它们不同的是,每次操作的是一对对象,即二元偶对象,Map中的每个元素都使用key à v ...
- Java从零开始学二十一(集合List接口)
一.List接口 List是Collection的子接口,里面可以保存各个重复的内容,此接口的定义如下: public interface List<E> extends Collecti ...
- Java从零开始学十四(包和访问控制)
一.java中的包 Java文件的组织形式Windows中的文件功能类似 在开发比较大的项目时,不可能只涉及到一个java文件,可能要创建几十,甚至几百个java文件,这个时候,我们就可以使用包,把相 ...
- Java从零开始学十六(多态)
一.什么是多态 多态性是指允许不同类的对象对同一消息作出响应.多态性包括参数化多态性和包含多态性.多态性语言具有灵活.抽象.行为共享.代码共享的优势,很好的解决了应用程序函数同名问题.多态有两种表现形 ...
- Java从零开始学十五(继承)
一.继承作用 继承使用复用以前的代码非常容易,能够大大的缩短开发周期,降低开发成本,同时增加程序的易维护性 继承使重一个类A能够直接使用另外一个类B的属性和方法的一种途径 类A可以有自己的属性和方法 ...
- Java从零开始学十(Arrays类对数组的常用方法)
一.Arrays类常用方法 二.简单例子 package com.pb.demo1; import java.util.Arrays; /* * Arrays工具类的中的几个常用方法 * 1.copy ...
- Java从零开始学十二(构造方法)
一.构造方法 构造方法的主要目的是为类中的属性初始化 二.构造方法的定义格式 class 类名称{ 访问权限 类名称(类型1 参数1,类型2 参数2,…){ 程序语句 ; … // 构造方法没有 ...
随机推荐
- Codeforces Round #259 (Div. 1) A. Little Pony and Expected Maximum 数学公式结论找规律水题
A. Little Pony and Expected Maximum Time Limit: 1 Sec Memory Limit: 256 MB 题目连接 http://codeforces.c ...
- Codeforces Round #296 (Div. 1) A. Glass Carving Set的妙用
A. Glass Carving time limit per test 2 seconds memory limit per test 256 megabytes input standard in ...
- wikioi 1017 乘积最大
dp[i][j]=max(dp[i][j],dp[t][k-1]*mapn[t+1][i]); dp[i][j]代表从0-i之间有j个乘号,mapn[i][j]表示第i位到第j位的数究竟是多少 #in ...
- UVALive 6662 TheLastAnt
#include <iostream> #include <cstdio> #include <cstring> #include <algorithm> ...
- Alpha冲刺(2/10)——追光的人
1.队友信息 队员学号 队员博客 221600219 小墨 https://www.cnblogs.com/hengyumo/ 221600240 真·大能猫 https://www.cnblogs. ...
- SMACH（五）----用户数据UserData类和重映射Remapper类的原理和例子
用户数据UserData类和重映射Remapper类包含在smach中的user_data.py文件中实现,该博文主要介绍其原理和例子 UserData主要用于状态之间的数据传递,包括数据的输入inp ...
- DDos与CC攻击的简单个人理解
DDos简单来说就是向指定IP发送大量无用的数据包,造成网卡堵塞. CC理解成模拟表单提交,真实模拟业务,但量大之后也会造成网络堵塞. 参考: http://www.enkj.com/idcnews/ ...
- redis-py说明文件(转)
转自:http://blog.sina.com.cn/s/blog_6262a50e0101574h.html 原文:https://github.com/andymccurdy/redis-py r ...
- Image.Save()发生“GDI+ 中发生一般性错误”
从数据库中读取的图片是byte[]类型,将其转换成Image可以正常显示,但是调用image.Save()时会发生“GDI+ 中发生一般性错误”.public static System.Drawin ...
- MVC无限级分类02,增删改查
继上一篇"MVC无限级分类01,分层架构,引入缓存,完成领域模型与视图模型的映射",本篇开始MVC无限级分类的增删改查部分,源码在github. 显示和查询 使用datagrid显 ...