类、构造器、方法、成员、其他关键词之间的联系

                                                类、构造器、方法、成员、其他关键词之间的联系

1、类

1.1类型

   普通类

   抽象类

   接口（特殊的抽象类）

   内部类

1.2定义

普通类：一般的声明的类为普通类（public class）

抽象类：声明为abstract的类为抽象类（public abstract class）

接口：声明为interface的类为接口（interface A）

内部类：在类的内部再声明一个类

1..3特点

普通类：一般类拥有的特征，如：成员、构造方法、方法等。

抽象类：①可以拥有抽象的方法（public abstract void a(){} ）

           注意：抽象类可以没有抽象方法，有抽象方法的必须是抽象类（特殊：接口），但是如果抽象类里面没有抽象方法就是去了抽象类的意义。       ②抽象类不能被实例化。（不能直接new）

接口：①接口是特殊的抽象类

           ②接口里面只能有公共的静态常量(public final static )、公共的抽象方法(public abstract ）、静态内部类(static class)

内部类：只存在于类的内部，有成员内部类、局部内部类、匿名内部类、静态内部类

1.4它们之间的关联

普通类：

     普通类vs普通类：①普通类可以单继承（extends）普通类，它们是父子类关系，子类拥有父类的方法跟属性。

                                 ②子类可以对父类的构造方法进行重载、方法进行重写、成员进行赋值

                                 ③子类可以进行扩展，增加成员、增加带多个形参的构造方法、增加自己的方法。

                                 ④子类可以在自己的构造方法或者方法中调用父类的构造方法、方法、成员（通过super.）

                                 ⑤父类也可以调用子类的方法子类的方法、成员（通过在父类中创建子类的实例对象，或者让子类的对象作为父类的成员）

     普通类vs抽象类：①普通类继承抽象类，它们也父子类关系，但是子类必须重写父类全部的抽象方法。

                                 ②重写完父类的全部抽象方法之后，它们的关系跟普通类继承普通类一样。

      普通类vs接口：   ①普通类实现接口可以实现多继承（class A  implement B,C  注：B、C为接口）

                                 ②实现了接口之后要对接口里面的方法全部进行重写

                                 ③重写全部抽象方法之后，它们的关系跟普通类继承普通类一样。但是接口里面的成员变量都是常量。

    

  普通类vs内部类：   ①在外部类方法中实例化内部类并调用其方法

                                 ②使用static可以什么一个内部类，声明的内部类就称为外部内，可以直接在类的外部调用，

                                     但是要想访问外部类中的属性，则此属性必须是static访问权限的

                                  

抽象类：

       抽象类vs普通类：①抽象类也可以继承普通类，跟普通类继承普通类一样，只是抽象类拥有自己独有的抽象方法。

       

       抽象类vs抽象类：①抽象类可以继承抽象类，抽象类继承了别的抽象类，那么可以不覆盖抽象方法，也可以覆盖抽象方法。

         抽象类vs接口 ：①抽象类可以实现接口，实现接口之后可以不实现接口中的方法，也可以实现接口中的方法。

                                      因为抽象类中可以存在抽象方法 。

        抽象类vs内部类：①抽象类中可以创建内部类。

接口：

          接口vs普通类、抽象类：①接口不能继承普通类和抽象类，因为接口中只能出现3种成员
                                                          1.公共的静态常量(public final static )
                                                          2.公共的抽象方法(public abstract )
                                                          3.静态内部类(static class)
而一个类中,就算什么都不写,也必须带一个构造方法,在extends时就会被子类继承,如果是接口也会继承这个构造                     方法,很明显构造方法不在上面项之列而如果类中有一般的方法和成员变量,也会被子类全部继承,这些更不能出现在接口中了,所以接口是绝对不可能继承一个类的

                         接口vs接口:   ①接口可以继承接口。但是要使用extends~而不是用implements
                                                                   如:interface a{}
                                                                        interface b extends a{}

                        接口vs内部类：①接口中可以有内部类，但是接口中的内部类必须是静态的(static class)。

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

 2、构造器vs方法（也叫构造函数vs方法函数）

2.1声明

  构造方法的声明：  权限修饰符+类名（形参）{}

       方法的声明  ：权限修饰符+返回值类型+方法名（形参）{}

区别：①构造器名字必须跟类名一样，方法的名字可以自己取

            ②构造器没有返回值类型，方法有返回值类型

            ③构造器不能有以下非访问性质的修饰： abstract, final, native, static, 或者 synchronized，方法可以。

2.2使用

构造器：

       ①构造器可以初始化成员变量，给成员赋值

       ②构造器的形参可以是引用变量，也可以是一个引用对象

       ③构造器中可以调用其他的构造器

       ④构造器中可以调用方法，调用成员

方法：

       ①方法的形参可以是引用变量，也可以是一个引用对象

       ②方法中可以调用其他的方法

       ③方法中可以调用成员，声明局部变量

       ④方法可以有具体的返回值

       ⑤方法中可以调用构造方法（通过new 一个实例出入具体的实参就可以了）

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

3、成员

        成员变量vs局部变量

  3.1、声明

  成员变量：权限修饰符/其他关键词+类型+名称+初始化值

  局部变量：类型+名称+初始化值

区别：①位置不同，成员变量声明在类内方法外，局部变量声明在方法内。

           ②初始化值不同，成员变量可以不声明初始化值，会有默认的初始化值，局部变量必须声明初始化值

           ③访问权限不同，成员变量可以通过类的实例来直接访问，局部变量要调用它所在的方法才能被访问。

           ④修饰符不同，成员变量可以有权限修饰符，局部变量只能用final或者不用 

           ⑤作用域不同，成员变量在类内，可以通过类的实例来调用，局部变量超出了方法的花括号就不起作用了

注意：成员的引用可以是一个变量也可以是一个对象。当类的成员是另外一个类的对象时，调用方法跟调用类的成员的调用方法是一样的。

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

4、其他关键词

4.1访问修饰符

  private:只能被当前类的方法访问。

  缺省（default）:可以被同一个包的所有类访问，如果子类不在同一个包则不能访问

 protected：可以被同一个包的所有类访问，如果子类不在同一个包也可以访问

 public： 可以被任何类访问。

4.2其他关键词

 final：修饰的类不能被继承，修饰的成员变量为常量。

static：可以用来修饰内部类，方法，变量。修饰的变量和方法可以被类的所有实例共享，并不需要创建实例就可以访问静态方法

abstract：可以用来修饰类和方法，所修饰的类为抽象类，所修饰的方法为抽象方法。

interface：用来声明一个接口

implement：实现接口用。