黑马程序员--面向对象三（final、abstract、Interface、Object、内部类）

------- android培训、java培训、期待与您交流！
----------

一、final
final：最终，终态。是一个修饰符

特点：

可以修饰类、变量、函数。
被修饰的类不可以被继承。
被修饰的函数不可以被复写。
被修饰的变量是一个常量只能赋值一次。可以修饰成员变量和局部变量。挡在描述事物时，一些数据的出现值是固定的，那么这时为了增强阅读性，都给这些值起个名字，便于阅读。而这个值不需要改变，所以加上final修饰。作为常量存在。常量的书写规范是所有字母都大写，如果有多个单词组成，用"_"连接。
内部类定义在类中的局部位置时，只能访问该剧不被final修饰的局部变量。

二、抽象类 abstract
抽象：笼统，看不懂。当多个类出现相同功能，但是主体不同，这时进行向上抽取，但是只能抽取功能的定义，抽取不了主体。这时抽取到的方法并不具体，需要被关键字abstract所修饰。

特点：

抽象方法一定在抽象类中。
抽象方法和抽象类都必须被abstract所修饰。
抽象类不可以用new创建对象，因为调用抽象方法没有意义。
抽象类中的抽象方法要被使用，必须由子类复写其所有抽象方法后建立子类对象调用。如果子类只覆盖了部分抽象类方法，那么该子类还是一个抽象类。就算建立空函数也要覆盖。

抽象类和一般类没有太大的不同
该如何描述事物，就如何描述事物，只不过该事物出现了一些看不懂的东西。这些不确定的部分，也是该事物的功能，需要明确出现，但是无法定义主体，就通过抽象方法来表示。

特殊：

抽象类中可以不定义抽象方法，作用仅仅是不让该类实例化。
抽象是可以定义构造方法，为了让其子类实例化。
抽象关键字abstract和final、private、static 不可以共同出现。

abstract class Animal//抽象类
{
public abstract void eat();//生物有吃东西的方法
//public abstract void work();
}

class Cat extends Animal
{
public void eat()//覆盖抽象方法具体猫吃东西
{
System.out.println("吃鱼");
}
public void catchMouse()
{
System.out.println("捉老鼠");
}
}

class Dog extends Animal
{
public void eat()//覆盖抽象方法具体狗吃东西
{
System.out.println("吃骨头");
}
public void kanJia()
{
System.out.println("看家");
}
}

三、接口 Interface

接口：特殊的抽象类。定义规则和约束
特点：

接口中常见定义：常量和抽象方法。
接口中的成员都有固定的修饰符。

常量：public static final

方法：public abstract
就是说接口中的方法都是抽象的。缺少任意一个修饰符，系统都会自动补上，接口中的成员都是public的。

关系

A：类与类的关系：是继承关系。类与类只能单继承，可以多重继承。

B：类和接口的关系：是实现关系。类可以多实现接口；类在继承一个类的同时，可以实现多个接口。

C：接口和接口的关系：是继承关系。接口可以多继承接口。

接口是不可以创建对象的，因为有抽象方法。
需要被子类实现，子类对接口中方法全部覆盖后才可以实例化，否则子类也只是一个抽象类。
impements跟extends一样，不过是用于实现接口。

接口的优点

A：是对外暴露的规则

B：提高了功能的扩展

C：降低功能之间的耦合性。（模块化开发）

D：接口可以多实现。如：CPU和主板、笔记本的USB插口、插座.

给类另外增加功能，体系意外的功能扩展，
搞清楚什么是类的基本功能，什么是扩展功能。
不同类基本功能不同，学生类和工作这类的基本功能不一样。

接口和抽象类的区别

A：抽象类只能被单继承； 接口可以多实现,接口的出现避免了多继承的局限性。

B：
抽象类中的数据特点：

成员变量：可以是变量，也可以是常量

成员方法：可以是抽象方法，也可以是非抽象方法

构造方法：有构造方法

接口中的数据特点：

成员变量：是常量。默认修饰 public static final

成员方法：都是抽象方法。都有默认修饰 public abstract

构造方法：没有构造方法

C：抽象类中定义的是继承体系中的共性功能； 接口中定义的是继承体系中的扩展功能。

D：抽象类被继承是"is a"关系:xx是yy的一种；接口被实现是"like a"关系:xx像yy的一种

class jiekou
{
public static void main(String[] args)
{
MainBoard mb = new MainBoard();
mb.run();
mb.usePCI(null);
mb.usePCI(new NetCard());
mb.usePCI(new SoundCard());
}
}

interface PCI//主板上的PCI插槽，相当于规则
{
public void open();
public void close();
}

class MainBoard//主板
{
public void run()
{
System.out.println("mainboard run ");
}
public void usePCI(PCI p)//PCI p = new NetCard()//接口型引用指向自己的子类对象。
{
if(p!=null)
{
p.open();
p.close();

}
}
}

class NetCard implements PCI//网卡，实现PCI
{
public void open()
{
System.out.println("netcard open");
}
public void close()
{
System.out.println("netcard close");
method();
}

}
class SoundCard implements PCI//声卡，实现PCI
{
public void open()
{
System.out.println("SoundCard open");
}
public void close()
{
System.out.println("SoundCard close");
}
}

——————————————————————————————

四、Object

Object：是所有对象的直接或者间接父类。Java认为所有的对象都具备一些基本的共性内容，这些内容可以不断的向上抽取，最终就抽取到了一个最顶层的类中的，该类中定义的就是所有对象都具备的功能。

常用方法：

boolean equals(Objectobj)：用于比较两个对象是否相等，其实内部比较的就是两个对象地址。
而根据对象的属性不同，判断对象是否相同的具体内容也不一样。所以在定义类时，一般都会复写equals方法，建立本类特有的判断对象是否相同的依据。

String toString()：将对象变成字符串；默认返回的格式：类名@哈希值 = getClass().getName()+ '@' +Integer.toHexString(hashCode())；为了对象对应的字符串内容有意义，可以通过复写，建立该类对象自己特有的字符串表现形式。
Class getClass()：获取任意对象运行时的所属字节码文件对象。反射的基石

int hashCode()：返回该对象的哈希码值。支持此方法是为了提高哈希表的性能。应用于hash集合。

——————————————————————————————

五、内部类
访问规则：

1、内部类可以直接访问外部类中的成员，包括私有。

之所以可以直接访问外部类中的成员，是因为内部类中持有了一种外部类的引用格式：外部类名.this

2、外部类要访问内部类，必须建立内部类的对象。

访问格式：

1、当内部类定义在外部类的成员位置上，而且非私有，可以在外部其他类中。
可以直接建立内部类对象
格式：外部类.内部类 变量=new 外部类().new内部类()
如：Out.Inner in = new Out().new Inner();
2、但内部类在成员位置上，就可以被成员修饰符所修饰，
比如：
private：将内部类在外部类中进行封装
static：内部类就具备了static的特性
但内部类被static修饰后，只能直接访问外部类中的static成员，出现了访问局限
在外部其他类中，如何直接访问static内部类的成员呢？
非静态：new Outer.Inner().function()
静态：Outer.Inner.function()
注意：
当内部类定义了静态成员时，该内部类必须是static的。
但外部类中的静态方法访问内部类时，内部类也必须是static的。

class Outer
{
int x=10;
static class Inner
{
private int x = 9;
static void show()
{
int x= 8;
System.out.println("Inner show="+x);//x为show方法里的x
//System.out.println("Inner show="+this.x);//x为局部类的x
//System.out.println("Inner show="+Outer.this.x);//x为外部类的x
}
}
void mai()
{
Inner i = new Inner();
i.show();
}
}

class InnerDemo
{
public static void main(String[] args)
{
System.out.println("Hello World!");
new Outer().mai();//建立对象访问
Outer.Inner.show();//static直接类名调用。

//Outer.Inner oi = new Outer().new Inner();//建立其他类的内部类对象
//oi.show();
}
}

内部类编译后的文件名为：“外部类名$内部类名.java”；

内部类定义在局部时：

不可以被成员修饰符修饰
可以直接访问外部类中的成员，因为还持有外部类中的引用。但是不可以访问它所在的局部中的变量。只能访问被final修饰的局部变量

class Outer
{
int x = 5;
void show(final int a)
{
final int y = 7;//必须定义为final才能被局部内部类访问。
class Inner
{
void show2()
{
System.out.println("x="+Outer.this.x);
System.out.println("y="+y);
System.out.println("a="+a);
}
}
new Inner().show2();//必须放在Inner类下面。
}
}
class InnerDemo2
{
public static void main(String[] args)
{
Outer out = new Outer();
//虽然a被定义为final，但是a是局部变量，在栈内存运行完一次就释放
//所以可以被传入两次的值。
out.show(10);
out.show(9);
}
}

匿名内部类

匿名内部类其实 就是内部类的简写格式。
定义匿名内部类的前提：内部类必须是继承一个类或者实现接口。
匿名内部类的格式：new 父类或者接口(构造函数参数){定义子类的内容}
其实匿名内部类就是一个子类对象，理解为带内容的对象。匿名内部类是把定义类和建立对象封装为一体的表现形式。
匿名内部类中定义的方法最好不要超过3个

abstract class abvDemo
{
abstract void show();
}
class Outer
{
//普通内部类
class Inner extends abvDemo
{
void show()
{
System.out.println("Inner show");
}
}
public void show1()
{
new Inner().show();
}
public void show2()
{
//匿名内部类：（普通内部类的简化写法）
new abvDemo()//注意这里不要跟分号。
{
void show()//复写抽象方法
{
System.out.println("匿名内部类");
}
}.show();//复写完再调用。
//---------------------------------------------------------
new abvDemo()//注意这里不要跟分号。
//这里没有出现多态可以调用子类特有方法abc。
{
void show()//复写抽象方法
{
System.out.println("匿名内部类");
}
void abc()
{
System.out.println("子类方法")
}
}.abc();//复写完再调用。
abvDemo b = new abvDemo()
//这里出现多态，new abvDemo()是子类对象，abvDemo b 是父类引用。
//所以最后不能调用子类对象的特有方法abc。
{
int x = 9;//这里的成员变量是可以调用的。
void show()//复写抽象方法
{
System.out.println("匿名内部类 x=="+x);
}
void abc()
{
System.out.println("子类方法")
}
}.show();

}
}
class InnerDemo3
{
public static void main(String[] args)
{
System.out.println("Hello World!");
new Outer().show1();//普通内部类的调用
new Outer().show2();//匿名内部类的调用
}
}

如：IO流中的过滤器，GUI中的监听器、代理中的InvocationHandler...