Java抽象类和内部类

类（class）

类是相似对象中共同属性和方法的集合体
在面向对象中定义类，就是在描述事物，就是在定义属性（变量）和行为（方法）。属性和行为共同成为类中的成员(成员变量和成员方法)。

封装、继承和多态

面向对象方法中软件设计的主体是类，类是相同属性和方法的封装体，因此类具有封装性
子类可以在继承父类所有属性和方法的基础上，再增加自己特有的属性和方法，因此类具有继承性
在一个类层次中，定义为根类的对象可被赋值为其任何子类的对象，并根据子类对象的不同而调用不同的方法，因此类具有多态性。

类的这种封装性、继承性和多态性，是面向对象程序设计的三个最重要的特点。

类声明

格式:[<修饰符>] class<类名>[extends<父类名>] [implements<接口名表>]
     {
     类主体
     }
其中，class是定义类的关键字，当接口名多于一个时，用逗号分隔开。方括号表示该项是可选项。

class Student implements Cloneable{
	private String name;
	private int age;
	
        @Override
	public Object clone() throws CloneNotSupportedException{
		//此处要把protected改为public 
		Object object = super.clone();
		return object;
	}
}

修饰符
类声明的<修饰符>分为访问控制符【该类的访问权限】和类型说明符【该类是否为抽象类或最终类】两部分。

访问控制符public:表示该类被定义为公共类，该类能被任何类访问。由于类都放于某个包中，包中的类互相能访问，而不在一个包中的类互相不能直接访问。如果要在一个包中访问另一个包中的类，就必须用import语句导入所需要的类到该包中。但Java语言规定，被导入的类必须是用public修饰的类。
访问控制符默认（无public时，即是默认类）：表示该类只能被同一个包中的类访问，而不能被其他包中的类访问。Java语言规定，一个Java文件中可以有很多类，但最多只能有一个公共类，其他都必须定义为默认类。
类型说明符abstract：表示该类为抽象类，抽象类不能用来定义对象，抽象类通常设计成一些具有类似成员变量和方法的子类的父类。
类型说明符abstractfinal ：表示该类为最终类，最终类不能用来再派生子类。

例如:

public class Teacher就声明了一个公共类Teacher，该类可以通过import语句导入到其他包的类中，并能被其他所有的类访问。
class Student就声明了一个默认类Student，该类只能被同一个包中的其他类访问。
public abstract class Person就声明了一个公共抽象类Person。访问控制符和类型说明符一起使用时，访问控制符在前，类型说明符在后。

声明成员变量

格式为：[<修饰符>] [static] [final] [transient] <变量类型> <变量名>;
其中，<修饰符>有private、public和protected三种。当不加任何修饰符时，定义为默认修饰符。

private修饰符表示该成员变量只能被该类本身访问，任何其他类都不能访问该成员变量。
protected修饰符表示该成员变量除可以被该类本身和同一个包的类访问外，还可以被它的子类（包括同一个包中的子类和不同包中的子类）访问。
public修饰符表示该成员变量可以被所有类访问。
不加任何访问权限限定的成员变量属于默认访问权限。默认访问权限表示该成员变量只能被该类本身和同一个包的类访问。
static指明该成员变量是一个类成员变量
final指明该成员变量是常量
transient指明该成员变量是临时变量。 transient很少使用。

类成员变量是一个类的所有对象共同拥有的成员变量，上述修饰符实现了类中成员变量在一定范围内的信息隐藏。这既符合程序设计中隐藏内部信息处理细节的原则，也有利于数据的安全性。

声明方法
    声明成员方法的格式为：
    [<修饰符>] [static] <返回值类型> <方法名> ([<参数列表>])
    {
      <方法体>
    }其中，<修饰符>和成员变量的修饰符一样，有private、public和protected三种，另外，还有默认。

各个修饰符的含义也和成员变量修饰符的含义相同。
static指明该方法是一个类方法。
方法声明中必须给出方法名和方法的返回值类型，如果没有返回值，用关键字void标记。方法名后的一对圆括号是必须的，即使参数列表为空，也要加一对空括号。

例如：public void SetInfo(String name,int age)
上述语句声明了方法名为SetInfo的public方法，其返回值为空，参数有2个，分别为name和age，这2个参数的数据类型分别为String 和 int。

方法体
方法体是方法的具体实现，是变量定义、赋值语句、if语句、for语句等根据方法体设计要求的综合应用。

public void setInfo(String name,int age) {
　　if(age >= 18){
　　　　System.out.println("成年人");	
　　　　this.name = name;
       this.age =age;
　　}else if(age < 18 && age >0){
　　　　System.out.println("未成年人"); 
　　　　this.name = name;
       this.age =age;
　　}
}

成员变量和变量

一个最简单的区别方法是：定义在类中的都是成员变量，定义在方法内的都是变量。
另外，还有定义在方法参数中的虚参变量，如SetInfo()中的 name 和 age。
成员变量和变量的类型既可以是基本数据类型（如int、long等），也可以是已定义的类。

构造方法

用来进行对象的初始化，一般来说，一个类中至少要有一个构造方法。
名字必须与其类名完全相同，并且没有返回值【void也不行】，构造方法一般应定义为public。
如果在编写一个类时没有编写构造器，系统就会提供一个默认构造器（默认构造器是指没有参数的构造器）。系统提供的这个默认构造器会将所有的实例域设置为默认值。
当一个类中没有定义构造函数时，那么系统会默认给该类加入一个空参数的构造函数。
当在类中自定义了构造函数后，默认的构造函数就没有了。
如果构造器的第一个语句形如this(…)，那么这个构造器将调用同一个类的另一个构造器。

public Student(){
    this();
}

构造函数的作用：可以用于给对象进行初始化，实现过程是：在创建对象时，将调用相应类中的构造方法为对象的成员变量进行初始化赋值。

所有的Java对象都是在堆中构造的，构造器总是伴随着new操作符一起使用。

构造函数和一般函数的区别

在写法上有不同
在运行上也有不同：构造函数是在对象一建立就运行，给对象初始化；而一般方法是对象调用才执行，给是对象添加对象具备的功能。
一个对象建立，构造函数只运行一次；而一般方法可以被该对象调用多次。

什么时候定义构造函数呢？
　　当分析事物时，该事物存在具备一些特性或者行为，那么将这些内容定义在构造函数中。
一个类中默认会有一个空参数的构造函数，这个默认的构造函数的权限和所属类一致：

如果类被public修饰，那么默认的构造函数也带public修饰符。
如果类没有被public修饰，那么默认的构造函数，也没有public修饰。

默认构造构造函数的权限是随着的类的变化而变化的。

构造代码块

构造代码快中定义的是不同对象共性的初始化内容。
对象一建立就运行，而且优先于构造函数执行。
作用：给对象进行初始化。
和构造函数的区别：构造代码块是给所有对象进行统一初始化；而构造函数是给对应的对象初始化。

抽象类

　　就是在分析事物时，通过抽象函数来描述事物中不明确的内容。

抽象类是一个父类，是不断向上抽取而来的，在抽取过程中，只抽取了方法声明，但没有抽取方法实现。

抽象类的特点：

抽象方法一定在抽象类中。【因为抽象函数所在类，也必须被抽象标识。】
抽象方法和抽象类都必须被abstract关键字修饰。
抽象类不可以用new创建对象。因为调用抽象方法没意义。
抽象类中的抽象方法要被使用，必须由子类复写其所有的抽象方法后，建立子类对象调用。

抽象类和一般类没有太大的不同，抽象类比一般类多了抽象函数，就是在类中可以定义抽象方法；抽象类不可以实例化。

特殊：抽象类中可以不定义抽象方法，这样做仅仅是不让该类建立对象。

abstract 关键字，和哪些关键字不能共存：

final：被final修饰的类不能有子类。而被abstract修饰的类一定是一个父类，所以final 和 abstract 不能同时修饰一个类。
private: 抽象类中的私有的抽象方法，不被子类所知，就无法被复写。而抽象方法出现的就是需要被复写。
static：如果static可以修饰抽象方法，那么连对象都省了，直接类名调用就可以了，可是抽象方法运行没意义。

抽象类中是否有构造函数？

有，抽象类是一个父类，要给子类提供实例的初始化。

接口

可以认为是一个特殊的抽象类。当抽象类中的方法都是抽象的，那么该类可以通过接口的形式来表示。

interface 用于定义接口
是不可以创建对象的，因为有抽象方法
需要被子类实现，子类对接口中的抽象方法全都覆盖后，子类才可以实例化。否则子类是一个抽象类。
接口可以被类多实现，也是对多继承不支持的转换形式。【java对多继承进行了改良】
一个类可以对接口进行多实现，也弥补了多继承带来的安全隐患。
一个类可以继承一个类的同时，实现多个接口。
接口与接口之间是继承关系，而且可以多继承。

接口中常见定义：常量，抽象方法。

接口中的成员都有固定修饰符

常量：public static final
方法：public abstract

记住：接口中的成员都是public的。

应用特点：

接口是对外暴露的规则
接口是功能的扩展
接口的出现降低了耦合性。【usb。pci，主板。插座。

抽象类和接口异同

相同：

都可以在内部定义抽象方法
通常都在顶层。
都不可以实例化，都需要子类来实现

不同点：

抽象类中可以定义抽象方法和非抽象方法；而接口中只能定义抽象方法。
抽象类只能单继承；接口的出现可以多实现。

内部类

当描述事物时，事物的内部还有事物，该事物用内部类来描述。
一个类被嵌套定义于另一个类中，称为内部类(Inner Classes)或内隐类。包含内部类的类称为外部类。

内部类可以直接访问外部类中的成员，包括私有。之所以可以直接访问外部类中的成员，是因为内部类中持有了一个外部类的引用，格式外部类名.this
外部类要访问内部类，必须建立内部类对象。

访问格式：

当内部类定义在外部类的成员位置上，而且非私有，可以在外部其他类中直接建立内部类对象:

　　　　格式：外部类名.内部类名变量名 = 外部类对象.内部类对象【Outer.Inner in = new Outer().new Inner();】

当内部类在成员位置上，就可以被成员修饰符所修饰。

　　　　比如private：将内部类在外部类中进行封装。

　　　　static:内部类就具备static的特性。

当内部类被static修饰后，只能直接访问外部类中的static成员，出现了访问局限。

在外部其他类中，如何直接访问static内部类的非静态成员呢？
new Outer.Inner().function();
在外部其他类中，如何直接访问static内部类的静态成员呢？
uter.Inner.function();

注意：当内部类中定义了静态成员，该内部类必须是static的。
当外部类中的静态方法访问内部类时，内部类也必须是static的。

静态内部类

和普通的类一样，内部类也可以有静态的。不过和非静态内部类相比，区别就在于静态内部类没有了指向外部的引用。

在任何非静态内部类中，都不能有静态数据，静态方法或者又一个静态内部类（内部类的嵌套可以不止一层）。不过静态内部类中却可以拥有这一切。这也算是两者的第二个区别吧。

class Outer
{
    private static  int x = 3;
    
    static class Inner//静态内部类
    {
        static void function()
        {
            System.out.println("innner :"+x);
        }
    }

    static class Inner2
    {
        void show()
        {
            System.out.println("inner2 show");
        }
    }

    public static void method()
    {
        //Inner.function();
        new Inner2().show();
    }

}


class  InnerClassDemo
{
    public static void main(String[] args) 
    {
        Outer.method();
        Outer.Inner.function();
        new Outer.Inner().function();
        //直接访问内部类中的成员。
        Outer.Inner in = new Outer().new Inner();
        in.function();
    }
}

局部内部类

class Outer
{
    int x = 3;
    void method(final int a)
    {
        final int y = 4;
        class Inner
        {
            void function()
            {
                System.out.println(y);
            }
        }
        new Inner().function();
    }
}

class  InnerClassDemo
{
    public static void main(String[] args) 
    {
        Outer out = new Outer();
        out.method(7);
        out.method(8);
    }
}

内部类定义在局部时：

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

匿名内部类

匿名内部类其实就是内部类的简写格式。
其实匿名内部类就是一个匿名子类对象，而且这个对象有点胖。【可以理解为带内容的对象】
匿名内部类中定义的方法最好不要超过3个。

定义匿名内部类的前提：
内部类必须是继承一个类或者实现接口。
匿名内部类的格式： new 父类或者接口(){定义子类的内容}。

在java的事件处理的匿名适配器中，匿名内部类被大量的使用:

frame.addWindowListener(new WindowAdapter(){
	public void windowClosing(WindowEvent e){
	   System.exit(0);//关闭窗口
	}
});

 1 interface Inter
 2 {
 3     void method();
 4 }
 5 
 6 class Test 
 7 {
 8     /*补足代码。通过匿名内部类。
 9     static class Inner implements Inter
10     {
11         public void method()
12         {
13             System.out.println("method run");
14         }
15     }
16     */
17 
18     static Inter function()
19     {
20         return new Inter()
21         {
22             public void method()
23             {
24                 System.out.println("method run");
25             }
26         };
27     }
28 }
29 
30 class InnerClassTest 
31 {
32     public static void main(String[] args) 
33     {
34 
35         //Test.function():Test类中有一个静态的方法function。
36         //.method():function这个方法运算后的结果是一个对象。而且是一个Inter类型的对象。
37         //因为只有是Inter类型的对象，才可以调用method方法。
38 
39         Test.function().method();
40     
41         //Inter in = Test.function();
42        // in.method();
43 
44         show(new Inter()
45         {
46             public void method()
47             {
48                 System.out.println("method show run");
49             }
50         });
51     }
52 
53     public static void show(Inter in)
54     {
55         in.method();
56     }
57 }
58 
59 class InnerTest
60 {
61 
62     public static void main(String[] args)
63     {
64         new Object()
65         {
66             public void function()
67             {
68                 
69             }
70             
71         }.function();
72     }
73 }

匿名内部类练习

匿名内部类由于没有名字，所以它没有构造函数（但是如果这个匿名内部类继承了一个只含有带参数构造函数的父类，创建它的时候必须带上这些参数，并在实现的过程中使用super关键字调用相应的内容）。

初始化它的成员变量，有2种方法：

如果是在一个方法的匿名内部类，可以利用这个方法传进你想要的参数，不过记住，这些参数必须被声明为final。
将匿名内部类改造成有名字的局部内部类，这样它就可以拥有构造函数了。