ASP.NET &&&&最新内容
ASP.NET &&&&相关内容他的最新文章
他的热门文章
您举报文章：
举报原因：
原文地址：
原因补充：
(最多只允许输入30个字)java详解final、多态、抽象类、接口原理
1:final关键字(掌握)
(1)是最终的意思，可以修饰类，方法，变量。
A:它修饰的类，不能被继承。
B:它修饰的方法，不能被重写。
C:它修饰的变量，是一个常量。
(3)面试相关：
A:局部变量
a:基本类型 值不能发生改变
b:引用类型 地址值不能发生改变，但是对象的内容是可以改变的
B:初始化时机
a:只能初始化一次。
b:常见的给值
定义的时候。(推荐)
构造方法中。
2:多态(掌握)
(1)同一个对象在不同时刻体现出来的不同状态。
(2)多态的前提：
A:有继承或者实现关系。
B:有方法重写。
C:有父类或者父接口引用指向子类对象。Fu f = new Zi();
多态的分类：
a:具体类多态
class Fu {}
class Zi extends Fu {}
Fu f = new Zi();
b:抽象类多态
abstract class Fu {}
class Zi extends Fu {}
Fu f = new Zi();
c:接口多态
interface Fu {}
class Zi implements Fu {}
Fu f = new Zi();
(3)多态中的成员访问特点
A:成员变量
编译看左边，运行看左边(看Fu中有没有，因为成员变量是表现一个对象的外在特征，而成员方法表现的是内在的)
B:构造方法
子类的构造都会默认访问父类无参构造，对父类的数据进行初始化
C:成员方法
编译看左边，运行看右边（编译看Fu中有没有，没有则报错，有就则访问Zi的方法，因为Zi类重写了Fu的方法）
D:静态方法
编译看左边，运行看左边（静态方法不叫重写，静态和类相关，算不上重写，所以，访问还是左边的）
(4)多态的好处：
A:提高代码的维护性(继承体现)
B:提高代码的扩展性(多态体现)
(5)多态的弊端：
父不能使用子的特有功能(即不能使用子类有而父类没有的方法，只能使用被重写了的方法)。
子可以当作父使用，父不能当作子使用。
我就想使用子类的特有功能?行不行?行。
A:创建子类对象调用方法即可。(可以，但是很多时候不合理，会重新创建出一个新的对象，而且，太占内存了，不要使用此方法)
B:把父类的引用强制转换为子类的引用。(向下转型)
对象间的转型问题：
向上转型：
Fu f = new Zi();
向下转型：
Zi z = (Zi)f; //要求该f必须是能够转换为Zi的。
3:抽象类(掌握)
(1)把多个共性的东西提取到一个类中，这是继承的做法。
& 但是呢，这多个共性的东西，在有些时候，方法声明一样，但是方法体。
& 也就是说，方法声明一样，但是每个具体的对象在具体实现的时候内容不一样。
& 所以，我们在定义这些共性的方法的时候，就不能给出具体的方法体。
& 而一个没有具体的方法体的方法是抽象的方法。
& 在一个类中如果有抽象方法，该类必须定义为抽象类。
(2)抽象类的特点
A:抽象类和抽象方法必须用关键字abstract修饰
B:抽象类中不一定有抽象方法,但是有抽象方法的类一定是抽象类
C:抽象类不能实例化，因为它不是具体的
D:抽象类的子类
a:是一个抽象类。
b:是一个具体类。这个类必须重写抽象类中的所有抽象方法。
(3)抽象类的成员特点：
A:成员变量
有变量，有常量
B:构造方法
有构造方法
C:成员方法
有抽象，有非抽象
(4)抽象类的几个小问题
A:抽象类有构造方法，不能实例化，那么构造方法有什么用?
用于子类访问父类数据的初始化
B:一个类如果没有抽象方法,却定义为了抽象类，有什么用?
为了不让创建对象
C:abstract不能和哪些关键字同时使用，即不能同时修饰一个方法
冲突（final 修饰的方法是不能被继承，而我们定义抽象方法就是希望子类继承实现它，这就相互冲突）
b:private 冲突（如上原因）
c:static 无意义 &（静态修饰的方法可以通过类名直接调用，如果也是抽象的，那么这个方法没有方法体，调用无意义，编译也会报错）
&span style=&font-size:18&&/*
具体事物：猫，狗
共性：姓名，年龄，吃饭
分析：从具体到抽象
成员变量：姓名，年龄
构造方法：无参，带参
成员方法：吃饭(猫吃鱼)
成员变量：姓名，年龄
构造方法：无参，带参
成员方法：吃饭(狗吃肉)
因为有共性的内容，所以就提取了一个父类。动物。
但是又由于吃饭的内容不一样，所以吃饭的方法是抽象的，
而方法是抽象的类，类就必须定义为抽象类。
抽象动物类：
成员变量：姓名，年龄
构造方法：无参，带参
成员方法：吃饭();
实现：从抽象到具体
成员变量：姓名，年龄
构造方法：无参，带参
成员方法：吃饭();
继承自动物类
重写吃饭();
继承自动物类
重写吃饭();
//定义抽象的动物类
abstract class Animal {
public Animal() {}
public Animal(String name,int age) {
this.name =
this.age =
public String getName() {
public void setName(String name) {
this.name =
public int getAge() {
public void setAge(int age) {
this.age =
//定义一个抽象方法
public abstract void eat();
//定义具体的狗类
class Dog extends Animal {
&span style=&color:#ff0000;&&public Dog() {}
public Dog(String name,int age) {
super(name,age);
public void eat() {
System.out.println(&狗吃肉&);
//定义具体的猫类
class Cat extends Animal {
public Cat() {}
public Cat(String name,int age) {
super(name,age);
public void eat() {
System.out.println(&猫吃鱼&);
class AbstractTest {
public static void main(String[] args) {
//测试狗类
Animal a = new Dog();
a.setName(&旺财1&);
a.setAge(3);
System.out.println(a.getName()+&---&+a.getAge());
Animal a2 = new Dog(&旺财2&,3);
System.out.println(a2.getName()+&---&+a2.getAge());
4:接口(掌握)
(1)回顾猫狗案例，它们仅仅提供一些基本功能。
& 比如：猫钻火圈，狗跳高等功能，不是动物本身就具备的，
& 是在后面的培养中训练出来的，这种额外的功能，java提供了接口表示。
(2)接口的特点：
A:接口用关键字interface修饰
interface 接口名 {}
B:类实现接口用implements修饰
class 类名 implements 接口名 {}
C:接口不能实例化
D:接口的实现类
a:是一个抽象类。
b:是一个具体类，这个类必须重写接口中的所有抽象方法。
(3)接口的成员特点：
A:成员变量
只能是常量
默认修饰符：public static final
B:构造方法
没有构造方法
C:成员方法
只能是抽象的
默认修饰符：public abstract
(4)类与类,类与接口,接口与接口
继承关系，只能单继承，可以多层继承
B:类与接口
实现关系，可以单实现，也可以多实现。
还可以在继承一个类的同时，实现多个接口
C:接口与接口
继承关系，可以单继承，也可以多继承
抽象类和接口的区别：
A:成员区别
成员变量：可以变量，也可以常量
构造方法：有
成员方法：可以抽象，也可以非抽象
成员变量：只可以常量
成员方法：只可以抽象
B:关系区别
继承，单继承
实现，单实现，多实现
接口与接口
继承，单继承，多继承
C:设计理念区别
抽象类 被继承体现的是：”is a”的关系。抽象类中定义的是该继承体系的共性功能。
接口 被实现体现的是：”like a”的关系。接口中定义的是该继承体系的扩展功能。
&span style=&font-size:18&&/*
猫狗案例,加入跳高的额外功能
分析：从具体到抽象
吃饭，睡觉
吃饭，睡觉
由于有共性功能，所以，我们抽取出一个父类：
猫：继承自动物
狗：继承自动物
跳高的额外功能是一个新的扩展功能，所以我们要定义一个接口
部分猫：实现跳高
部分狗：实现跳高
从抽象到具体
使用具体类
//定义跳高接口
interface Jumpping {
//跳高功能
public abstract void jump();
//定义抽象类
abstract class Animal {
public Animal() {}
public Animal(String name,int age) {
this.name =
this.age =
public String getName() {
public void setName(String name) {
this.name =
public int getAge() {
public void setAge(int age) {
this.age =
public abstract void eat();
//睡觉(){}
public void sleep() {
System.out.println(&睡觉觉了&);
//具体猫类
class Cat extends Animal {
public Cat(){}
public Cat(String name,int age) {
super(name,age);
public void eat() {
System.out.println(&猫吃鱼&);
//具体狗类
class Dog extends Animal {
public Dog(){}
public Dog(String name,int age) {
super(name,age);
public void eat() {
System.out.println(&狗吃肉&);
//有跳高功能的猫
class JumpCat extends Cat implements Jumpping {
public JumpCat() {}
public JumpCat(String name,int age) {
super(name,age);
public void jump() {
System.out.println(&跳高猫&);
//有跳高功能的狗
class JumpDog extends Dog implements Jumpping {
public JumpDog() {}
public JumpDog(String name,int age) {
super(name,age);
public void jump() {
System.out.println(&跳高狗&);
class InterfaceTest {
public static void main(String[] args) {
//定义跳高猫并测试
JumpCat jc = new JumpCat();
jc.setName(&哆啦A梦&);
jc.setAge(3);
System.out.println(jc.getName()+&---&+jc.getAge());
jc.sleep();
jc.jump();
System.out.println(&-----------------&);
JumpCat jc2 = new JumpCat(&加菲猫&,2);
System.out.println(jc2.getName()+&---&+jc2.getAge());
jc2.eat();
jc2.sleep();
jc2.jump();
看过本文的人也看了：
我要留言技术领域：
取消收藏确定要取消收藏吗？
删除图谱提示你保存在该图谱下的知识内容也会被删除，建议你先将内容移到其他图谱中。你确定要删除知识图谱及其内容吗？
删除节点提示无法删除该知识节点，因该节点下仍保存有相关知识内容！
删除节点提示你确定要删除该知识节点吗？在 SegmentFault，学习技能、解决问题
每个月，我们帮助 1000 万的开发者解决各种各样的技术问题。并助力他们在技术能力、职业生涯、影响力上获得提升。
问题对人有帮助，内容完整，我也想知道答案
问题没有实际价值，缺少关键内容，没有改进余地
1、问题描述如果类A继承了一个抽象类B（抽象类B已经实现了接口C），为什么还要实现接口C呢？
2、举例抽象类AbstractMap已经实现了接口Map，HashMap继承了AbstractMap为什么也还要实现接口Map？
public abstract class AbstractMap&K,V& implements Map&K,V& {
public class HashMap&K,V&
extends AbstractMap&K,V&
implements Map&K,V&, Cloneable, Serializable {
答案对人有帮助，有参考价值
答案没帮助，是错误的答案，答非所问
看了 牧曦之晨 给出的链接，感觉上面的回答也没有讲清楚这个问题，不过我基本同意这样写是为了清晰这个观点。但是在这里我想补充一点我的想法。
首先，在语法上，无论写不写implements Map&K, V&都是没有问题的，而且效果是一样的。所以剩下的可能性只有2个：
为了代码上和语义上更加清晰
HashMap的程序员一不小心多加了这么一句
先说结论：我以为，这两种可能性都有，但是(1)的可能性更大一些。
首先来看看(1)。为什么加了这一句才清晰？继承了AbstractMap还不够清晰吗？毕竟后者本身就是实现了Map的啊！
先来看看AbstractMap的文档，在该类文档的第一句就说：
此类提供 Map 接口的骨干实现，以最大限度地减少实现此接口所需的工作。
也就是说，这个类是一个便捷类，它的存在主要是为了方便使用者，以减少必须的编码工作的。类似的例子还有java.awt.event中的几个XXXAdapter类，但是它们更加纯粹——AbstractMap多少还有点语义，但XXXAdapter仅仅只是为了方便程序员而已（其的方法都是空的）。
另一方面，实现了Map以及Map的子接口的类有很多，包括HashMap、TreeMap、WeakHashMap、ConcurrentHashMap、LinkedHashMap等等，它们基本上都继承自AbstractMap或其子类，但同时却具有不同的特性。而这些决定了它们的应用场景和适用范围的特性主要并不是来自于AbstractMap，而是来自于它们实现的接口，以及自身的具体实现。
例如HashMap实现的是Map，配合它的名字，我们可以知道这是一个利用哈希表实现的Map；TreeMap实现的是NavigableMap，配合它的名字，我们可以知道这是一个利用树实现的可导航的（可遍历的）Map，等等。所以对于这些Map类，我们只需要看它的名字，再看看它们实现的接口，就能大概知道它们采用的数据结构和主要特性。而继承AbstractMap这件事在这种情况下则可以忽略，仅仅将其作为一种减少繁复劳动的手段即可。
再来看看(2)。
前面也说了，java.util包下面各种XXXMap类有很多，它们中绝大部分都继承自AbstractMap，同时又实现了Map接口的某个子接口。因此它们大部分都有如下这种共通的格式：
public class XXXMap&K,V&
extends AbstractMap&K,V&
implements YYYMap&K,V&, Cloneable, Serializable
作为程序员应该最能理解遇到这种情况时会如何处理了吧：C&P大法好啊！拷贝一下，改改类名和实现接口，多方便，呵呵。
当然前面也说了，这种猜测的可能性是比较小的，至少我是这么认为的。
答案对人有帮助，有参考价值
答案没帮助，是错误的答案，答非所问
虽然抽象类B implements C.但是，有可能B中的并没有真正实现C接口中的方法--因为B是抽象类，抽象类可以不实现接口中的方法，而是直接用 abstract 修饰。如 abstract void method();那么，由于A extends B, 而 A不是抽象类，那么A就得完全实现 method()方法了。
分享到微博？
关闭理由：
删除理由：
忽略理由：
推广（招聘、广告、SEO 等）方面的内容
与已有问题重复（请编辑该提问指向已有相同问题）
答非所问，不符合答题要求
宜作评论而非答案
带有人身攻击、辱骂、仇恨等违反条款的内容
无法获得确切结果的问题
非开发直接相关的问题
非技术提问的讨论型问题
其他原因（请补充说明）
我要该，理由是：
在 SegmentFault，学习技能、解决问题
每个月，我们帮助 1000 万的开发者解决各种各样的技术问题。并助力他们在技术能力、职业生涯、影响力上获得提升。