黑马程序员 面向对象--抽象类、接口、内部类总结

-----------android培训、java培训、java学习型技术博客、期待与您交流！
------------

抽象类：
抽象：模糊，不具体。
特点：
1.方法只有声明没有实现时，该方法就是抽象方法，需要被abstract修饰。抽象方法必须定义在抽象类中。该类必须也被abstract修饰。
2.抽象类不可以被实例化。为什么？因为调用抽象方法没有意义。
3.抽象类必须由其子类覆盖所有的抽象方法后，该子类才可以实例化。否则，这个子类还是抽象类。

抽象类的小细节

1.抽象类中有构造函数吗？
有，用于给子类对象初始化。

2.抽象类可以不定义抽象方法吗？
可以的，但是很少见，目的就是不让该类创建对象。AET的适配器对象就是这种类。

通常这个类中的方法有方法体，但是却没有内容。
class DemoB{
void show(){}
}

3.抽象关键字不可以和哪些关键字共存？
private 不行，私有后无法被覆盖。
static 不行。
final 不行。抽象并必须要被覆盖，final修饰后不能被覆盖。

4.抽象类和一般类区别。
相同点:抽象类和一般类都是用来描述事物的，都在内部定义了成员。
不同：
1.一般类有足够的信息描述事物，抽象类描述事物的信息有可能不足。
2.一般类中不能定义抽象方法，只能定义非抽象方法。抽象类中既可以定义抽象方法也可以定义非抽象方法。
3.一般类可以被实例化，抽象类不可以被实例化。

5.抽象类一定是个父类吗？
是的。因为需要子类覆盖其方法后才可以对子类实力话。

abstract class Demo{//函数声明相同，函数体不同，抽取了方法的声明
abstract void show();//抽象函数所在的类也必须标示成抽象的
}
class DemoA extends Demo{
void show(){
System.out.println("demo a show");
}
}
class DemoB{
void show(){
System.out.println("demo b show");
}
}

抽象类雇员示例：

需求：公司中程序员有姓名，工号，薪水，工作内容。
项目经理除了有姓名，工号，薪水，还有奖金，工作内容。
对给胡需求进行数据建模。
分析：
在这个问题领域中，涉及的对象。(通过名词提炼法)
程序员：
属性：姓名，工号，薪水。
行为：工作。
经理：
属性：姓名，工号，薪水，奖金。
行为：工作。

经理并不是程序员的一种，所以不存在直接继承关系。
但是程序员和经理却具有着共性的内容，可以进行抽取。因为他们都是公司的雇员。

可以讲程序员和经理进行抽取，建立体系。

//描述雇员
abstract class Employee{
private String name;
private String id;
private double pay;
public Employee(String name,String id,double pay) {
this.name = name;
this.id = id;
this.pay = pay;
}
public abstract void work();
}
//描述程序员
class Programmer extends Employee{
Programmer(String name,String id,double pay) {
super(name,id,pay);
}
public void work(){
System.out.println("codeing...");
}
}
class Manager extends Employee{
private int bonus;
Manager(String name,String id,double pay,int bonus){
super(name,id,pay);
this.bonus = bonus;
}
public void work(){
System.out.println("manage...");
}
}

-----------------------------------------------------------------
当一个抽象类中的方法都是抽象的时候，这时可以将该抽象类用另一种形式定义和表示，就是 接口 Interface

定义接口使用的关键字不是class，是interface。
对于接口当中常见的成员：而且这些成员都有固定的修饰符，如果不写会自动加上。
1.全局常量。public static final
2.抽象方法。public abstract

由此得出结论，接口中的成员都是公共的权限。

interface Demo2{//编译后生成的还是class文件。
public static final int NUM = 3;
public abstract void show1();
public abstract void show2();
}

类与类之间是继承关系，类与接口之间是实现关系。
接口不可以实力化，只能由实现了接口的子类覆盖了接口中所有的抽象方法后，该子类才可以实例化。
否则这个子类就是一个抽象类。

class DemoImpl implements Demo2{
//想要实例化必须覆盖接口中所有的方法
public void show1(){}
public void show2(){}
}
public class InterfaceDemo {
public static void main(String[] args) {
DemoImpl d = new DemoImpl();
System.out.println(d.NUM);
System.out.println(Demo2.NUM);
System.out.println(DemoImpl.NUM);
}
}

多实现

java不直接支持多继承，因为会出现调用的不确定性。
所以java将多继承机制进行了改良，在java中变成了多实现。

一个类可以实现多个接口。完成 了多继承的改良。

interface A{
public void show();
}
interface Z{
public void show();
}

class Test implements A,Z{//多实现
public void show(){
//同时覆盖了A和Z中的show方法。
}
}

接口细节

一个类在继承另一个类的同时，还可以实现多个接口。

继承一个类属于一个体系，实现多个接口拓展其功能。

接口的出现避免了单继承的局限性。

类与类之间是继承关系，类与接口之间是实现关系。
接口与接口之间是继承关系，而且接口可以多继承。
因为接口没有方法体，没有安全隐患所以可以继承。

接口的特点：
接口是对外暴露的规则。
接口是程序的功能扩展。
接口的出现降低耦合性.

接口和抽象类的异同点：
相同点：
都是不断向上抽取而来的。

不同点：
1.抽象类需要被继承，而且只能单继承。
接口需要被实现，而且可以多实现。
2.抽象类中可以定义抽象方法和非抽象方法，子类继承后可以直接使用非抽象方法。
接口中只能定义抽象方法，必须由子类去实现。
3.抽象类的继承，是is a（所属关系）关系，在定义该体系的基本共性内容。
接口的实现是like a关系，在定义体系的额外功能。
类在确定体系，接口在扩展功能。

犬按功能分，有导盲犬，搜爆犬。

分析：犬在定义这类事物的基本功能，导盲犬和搜爆犬都会吼叫。
导盲，和搜爆是犬这类事物的额外功能。
犬应该定义成类，导盲和搜爆应该定义成接口。

abstract class 犬{
abstract void 吼叫();
}
abstract interface 导盲{
a	bstract void 导盲();
}
class 导盲犬 extends 犬 implements 导盲{
public void 吼叫(){}
public void 导盲(){}
}

接口的应用
例子:笔记本电脑、鼠标、u盘。
笔记本定义规则并使用规则，鼠标、u盘实现规则

继承是is a，我是你里面的一种。
实现是like a 像你里面的一种，usb鼠标像触摸板

笔记本电脑使用。
为了扩展笔记本的功能，但日后出现什么功能设备不知道。

定义一个规则，只要日后出现的设备都符合这个规则就可以了。
规则在java中就是接口。

interface USB{//定义规则
public void open();
public void close();
}
class BookPC{
public static void main(String[] args){
usbUSB(new UPan());//功能扩展了。
}
//使用规则
public static void usbUSB(USB u){//接口类型的引用。用于接收（指向）接口的子类对象
u.open();
}
}
--------------------------------------------------------
//一年后，实现规则。这些设备和电脑的耦合性降低了。
class UPan implements USB{
public void open(){
System.out.println("UPan open");
}
public void close(){
System.out.println("UPan close");
}
}

--------------------------------------------------------------------------------------

内部类访问特点：
1.内部类可以直接访问外部类中的成员。
2.外部类要访问内部类，必须要建立内部类的对象。

一般用于类的设计。
分析事物时，发现该事物描述中还有事物，而且这个事物还在访问被描述事物的内容，这时就把还有的事物定义成内部类来描述。

为什么内部类能直接访问外部类中的成员。

因为内部类持有了外部类的引用。外部类名.this

如果内部类中定义了静态成员，该内部类也必须是静态的。
直接访问外部类中的内部类中的成员。
Outer.Inner in = new Outer().new Inner();

in.show();

如果内部类是静态的，相当于一个外部类。

Outer.Inner in = new Outer.Inner();

in.show();

如果内部类是静态的，成员是静态的。

Outer.Inner.function();

内部类可以存放在局部位置上。

内部类在局部位置上只能访问局部中被final修饰的局部变量。

从内部类中访问局部变量，需要被声明为最终类型。
---------------------------------------------------------------------
匿名内部类：就是内部类的简写格式。
前提：内部类必须继承或者实现一个外部类或者接口。

匿名内部类：其实就是一个匿名子类对象。
格式：new 父类or接口名(){子类内容}
abstract class Demo{
abstract void show();
}

class Outer{
int num = 4;
/*
class Inner extends Demo{
void show(){

System.out.println("show"+num);
}
}
*/
public void method(){

//new Inner().show();
new Demo(){//匿名内部类
void show(){
System.out.println("show..."+num);
}
void haha(){}
}.show();
}

}

class InnerClassDemo4{
public static void main(String[] arga){
new Outer().method();
}
}

---------------------------------------------------------------
匿名内部类的应用。

interface Inter{
void show1();
void show2();
}
class Outer{
public void method(){
Inter in = new Inter(){
public void show1(){

}
public void show2(){

}

};
in.show1();
in.show2();
}
}

//通常使用场景之一：，而且接口中的方法不超过三个，可以用匿名内部类作为实际参数进行传递。
//当函数参数是接口类型时

public class InnerClassDemo5 {
public static void main(String[] args) {
show(new Inter(){
public void show1(){}
public void show2(){}
});

}
public static void show(Inter in){
in.show1();
in.show2();
}
}

--------------------------------------------------------
class InnerClassDemo6 {
static clsaa Inner{}
public static void main(String[] args) {
new Inner();//主函数是静态的，Inner如果是非静态会编译失败。
}

public void method(){
new Inner();
}
public static void show(Inter in){
in.show1();
in.show2();
}
}

-----------android培训、java培训、java学习型技术博客、期待与您交流！
------------