final
关键字作为一个修饰符
1.可以修饰类、函数、变量
2.被final修饰的类不可以被继承
为了避免被继承，被子类复写功能。
3.被final修饰的方法，不可以被复写
4.被final修饰的变量是一个常量，只能赋值一次，既可以修饰成员变量，又可以修饰局部变量。作为常量：常量的书写规范：所有的字母大写，如果有多个单词，用 “_” 连接。相当于C++中的const
5.内部类定义在类中的局部位置上时，只能访问该局部被final修饰的局部变量
final class Aa{
void show ()
{
System.out.println("A.show()");
}
}
// class Bb extends Aa{
//
// }
class Bb {
final public int x = 10;
final void show ()
{
System.out.println("B.show()");
}
void display (){
// x = 20;
// x = 10;
System.out.println("x==:"+x);
}
}
class Cc extends Bb{
//public void show (){}
}
public class Final {
public static void main (String[] args){
Aa a = new Aa();
Bb b = new Bb();
Cc c = new Cc();
a.show ();
b.show ();
c.show ();
c.display();
}
}
抽象类
抽象类的特点：
1.抽象方法一定在抽象类中
2.抽象方法和抽象类都必须被abstract关键字修饰
3.抽象类不可以用new 创建对象。因为调用抽象方法没意义
4.抽象类中的方法要被使用，必须由子类复写其所有的抽象方法后建立子类对象调用，如果子类只覆盖了部分抽象方法，那么该子类也是一个抽象类。
抽象只能修饰类和方法。
抽象类里也可以有非抽象方法。
抽象类中也可以不定义抽象方法，这样做仅仅是不让该类去创建对象。
抽象类和一般类没有太大的不同。
如何使用?
通过对实际问题的分析，不断抽取每个类的相同部分，将这一相同部分定义成抽象类。
例如：
学生和工人这么两个对象，他们共同的行为假如说是study，那么就将study这个功能提取出来，定义一个名为person的抽象类。
Person类只提供方法，具体的实现是靠子类。
abstract class Person {
abstract void study ();
public void show ()
{
System.out.println("Person.show()");
}
//abstract void dislay ();
}
class Student extends Person{
public void study(){
System.out.println("Student.study()");
}
public void show ()
{
System.out.println("Student.show()");
}
}
class Worker extends Person{
public void study (){
System.out.println("Worker.study()");
}
public void show ()
{
System.out.println("Worker.show()");
}
}
public class Abstract {
public static void main (String[] args)
{
Student s = new Student();
Worker w = new Worker();
s.study();
w.study();
s.show ();
w.show ();
}
}
内部类
将一个类定义在另一个类的里面，对里面那个类就称为内部类（内置类，嵌套类）
内部类的访问规则：
1.内部类可以直接访问外部类成员，包括私有。
之所以可以直接访问外部类中的成员是因为内部类中持有一个外部类的引用（外部类名.this）
2.外部类要访问内部类必须建立内部类对象。
简单的内部类创建方式：
class Out{
int x = 10;
class In {
int y = 20;
void show (){
System.out.println("Out.In.show()+++"+y);
}
}
void display (){
System.out.println("Out.display()---"+x);
}
}
那么如何对内部类进行访问？
import java.awt.DisplayMode;
class Out{
int x = 10;
class In {
void show (){
System.out.println("Out.In.show()+++"+x);//内部类可直接访问外部类的成员。
display();
}
}
void display (){
System.out.println("Out.display()---"+x);
}
void set (){
In in = new In();
in.show();
}
}
class Hello{
public static void main (String[] args){
Out out = new Out();
out.display();
out.set();
}
}
直接访问内部类中的成员：
import java.awt.DisplayMode;
class Out{
int x = 10;
class In {
void show (){
System.out.println("Out.In.show()+++"+x);//内部类可直接访问外部类的成员。
display();
}
}
void display (){
System.out.println("Out.display()---"+x);
}
void set (){
In in = new In();
in.show();
}
}
class Hello{
public static void main (String[] args){
//Out out = new Out();
//out.display();
//out.set();
/*
直接访问内部类的成员。
*/
new Out().new In().show();
Out.In in = new Out().new In();
in.show ();
}
}
访问格式:
当内部类定义在外部类的成员位置上，而且非私有，可以在外部其他类中可以直接建立内部类对象
格式：
外部类名.内部类名 变量名 = 外部类对象.内部类对象
Out.In in = new Out().new In();
class Out{
int x = 10;
class In {
int x = 4;
void show (){
int x = 6;
System.out.println("Out.In.show()+++"+x);//6
System.out.println("Out.In.show()+++"+this.x);//4
System.out.println("Out.In.show()+++"+Out.this.x);//3
display();
}
}
}之所以可以直接访问外部类中的成员是因为内部类中持有一个外部类的引用（外部类名.this）
当内部类在成员位置上，就可以被修饰符修饰。
比如：private： 将内部类在外部类中进行封装
static：内部类就具备了静态的特性。
当内部类被静态修饰后，只能直接访问外部类中的静态成员。出现了访问局限。
在其他外部类中如何直接访问静态内部类的非静态成员？
import java.awt.DisplayMode;
class Out{
static int x = 10;
static class In
{
void show ()
{
System.out.println("Out.In.show()+++"+x);//内部类可直接访问外部类的成员。
}
}
void display (){
System.out.println("Out.display()---"+x);
}
void set (){
In in = new In();
in.show();
}
}
class Hello{
public static void main (String[] args){
new Out.In().show ();
}
}
new Out.In().function;
Out加载完，内部类也加载完，因为是static类，new Out.In()就相当于是创建一个内部类对象。
在其他外部类中如何直接访问静态内部类的静态成员？
Out.In.function;
注意：
当内部类中定义了静态成员，该内部类必须是静态的。
class In
{
static void show ()
{
System.out.println("Out.In.show()+++"+x);//内部类可直接访问外部类的成员。
}
}
编译器提示：
The method show cannot be declared static; static methods can only be declared in a static or top
level type
当外部类中的静态方法访问内部类时，内部类也必须是static的。
原文：http://blog.csdn.net/u013476556/article/details/41660307