Java基础知识之常见关键字以及概念总结

static 

特色： 
随着类的加载而加载 
优先于对象存在 
被全部对象所共享 
能够直接被类名调用

使用注意： 
静态方法只能访问静态成员 
可是非静态成员能够直接访问静态成员 
静态方法中不可用使用this,super关键字 
主方法（main）是静态的（能够利用类名去调用静态的main方法，可是会陷入死循环，致使内存溢出，jvm自动中止） 
用static修饰的成员表示它属于这个类共有，而不是属于该类的单个实例 
static修饰的字段和方法，既能够经过类调用，也可使用实例调用，没有static修饰的字段和方法，只能使用实例来调用

final 
特色： 
final能够修饰类，方法，变量 
final修饰类不能够被继承，可是能够继承其余类 
final修饰的方法不能够被覆写，但能够覆写父类方法 
final修饰的变量成为常量，这些变量只能赋值一次 
内部类在局部时，只能够访问被final修饰的局部变量 
final修饰的引用类型变量，表示该变量的引用不能变，而不是该变量的值不能变

this 
特色： 
this表示当前对象 
换言之：谁调用了方法，谁就是当前对象 
在构造器中使用this时，this参数必须卸载构造方法第一行

super 
特色： 
表示父类对象的默认引用 
若是子类要调用父类被覆盖的实例方法，可用super做为调用者调用父类被覆盖的实例方法

注意事项： 
Java在执行子类的构造方法前会先调用父类无参的构造方法，其目的是为了对继承自父类的成员作初始化操做 
子类在建立对象的时候，默认调用父类的无参构造方法，要是子类构造方法中显示指定调用父类其余构造方法，就调用指定的父类构造方法，取消调用父类无参构造方法

权限修饰符 
public: 公共访问权限：任何地方均可以访问，能继承到子类 
protected: 子类访问权限：本类内部能够访问，不一样包的子类也能够访问，同包的其余类也能够访问，能继承到子类 
default: 什么都不写，包访问权限：本类内部能够访问，同包其余类也能够访问，同包可继承 
private: 类访问权限：本类内部能够访问，不能继承到子类

abstract 
抽象：不具体，看不明白。抽象类表象体现。

在不断抽取过程当中，将共性内容中的方法声明抽取，可是方法不同，没有抽取，这时抽取到的方法，并不具体，须要被指定关键字abstract所标示，声明为抽象方法。

抽象方法所在类必定要标示为抽象类，也就是说该类须要被abstract关键字所修饰。

抽象类的特色： 
1：抽象方法只能定义在抽象类中，抽象类和抽象方法必须由abstract关键字修饰（能够描述类和方法，不能够描述变量）。 
2：抽象方法只定义方法声明，并不定义方法实现。 
3：抽象类不能够被建立对象(实例化)。 
4：只有经过子类继承抽象类并覆盖了抽象类中的全部抽象方法后，该子类才能够实例化。不然，该子类仍是一个抽象类。

抽象类的细节： 
1：抽象类中是否有构造函数？有，用于给子类对象进行初始化。 
2：抽象类中是否能够定义非抽象方法？ 能够。其实，抽象类和通常类没有太大的区别，都是在描述事物，只不过抽象类在描述事物时，有些功能不具体。因此抽象类和通常类在定义上，都是须要定义属性和行为的。只不过，比通常类多了一个抽象函数。并且比通常类少了一个建立对象的部分。 
3：抽象关键字abstract和哪些不能够共存？final , private , static 
4：抽象类中可不能够不定义抽象方法？能够。抽象方法目的仅仅为了避免让该类建立对象。

接 口：★★★★★ 
1：是用关键字interface定义的。 
2：接口中包含的成员，最多见的有全局常量、抽象方法。

注意：接口中的成员都有固定的修饰符。 
成员变量：public static final 
成员方法：public abstract

interface Inter{     
     public static final int x = 3;     public abstract void show(); }

3：接口中有抽象方法，说明接口不能够实例化。接口的子类必须实现了接口中全部的抽象方法后，该子类才能够实例化。不然，该子类仍是一个抽象类。
4：类与类之间存在着继承关系，类与接口中间存在的是实现关系。 
继承用extends ；实现用implements ； 
5：接口和类不同的地方，就是，接口能够被多实现，这就是多继承改良后的结果。java将多继承机制经过多现实来体现。 
6：一个类在继承另外一个类的同时，还能够实现多个接口。因此接口的出现避免了单继承的局限性。还能够将类进行功能的扩展。 
7：其实java中是有多继承的。接口与接口之间存在着继承关系，接口能够多继承接口。

接口都用于设计上，设计上的特色：（能够理解主板上提供的接口） 
1：接口是对外提供的规则。 2：接口是功能的扩展。 3：接口的出现下降了耦合性。

抽象类与接口： 
抽象类：通常用于描述一个体系单元，将一组共性内容进行抽取，特色：能够在类中定义抽象内容让子类实现，能够定义非抽象内容让子类直接使用。它里面定义的都是一些体系中的基本内容。 
接口：通常用于定义对象的扩展功能，是在继承以外还需这个对象具有的一些功能。 
抽象类和接口的共性：都是不断向上抽取的结果。

抽象类和接口的区别： 
1：抽象类只能被继承，并且只能单继承。 
接口须要被实现，并且能够多实现。 
2：抽象类中能够定义非抽象方法，子类能够直接继承使用。 
接口中都有抽象方法，须要子类去实现。 
4：抽象类的成员修饰符能够自定义。 
接口中的成员修饰符是固定的。全都是public的。

多 态★★★★★（面向对象特征之一）：函数自己就具有多态性，某一种事物有不一样的具体的体现。

体现：父类引用或者接口的引用指向了本身的子类对象。//Animal a = new Cat(); 
多态的好处：提升了程序的扩展性。 
多态的弊端：当父类引用指向子类对象时，虽然提升了扩展性，可是只能访问父类中具有的方法，不能够访问子类中特有的方法。(前期不能使用后期产生的功能，即访问的局限性) 
多态的前提： 1：必需要有关系，好比继承、或者实现。 2：一般会有覆盖操做。

若是想用子类对象的特有方法，如何判断对象是哪一个具体的子类类型呢？ 
能够能够经过一个关键字 instanceof ;//判断对象是否实现了指定的接口或继承了指定的类 
格式：<对象 instanceof 类型> ，判断一个对象是否所属于指定的类型。 Student instanceof Person = true;//student继承了person类

多态在子父类中的成员上的体现的特色： 
1，成员变量：在多态中，子父类成员变量同名。 
在编译时期：参考的是引用型变量所属的类中是否有调用的成员。（编译时不产生对象，只检查语法错误） 
运行时期：也是参考引用型变量所属的类中是否有调用的成员。 
简单一句话：不管编译和运行，成员变量参考的都是引用变量所属的类中的成员变量。 再说的更容易记忆一些：成员变量 — 编译运行都看 = 左边。

2，成员函数。 
编译时期：参考引用型变量所属的类中是否有调用的方法。 
运行事情：参考的是对象所属的类中是否有调用的方法。 
为何是这样的呢？由于在子父类中，对于如出一辙的成员函数，有一个特性：覆盖。 
简单一句：成员函数，编译看引用型变量所属的类，运行看对象所属的类。 更简单：成员函数 — 编译看 = 左边，运行看 = 右边。

3，静态函数。 
编译时期：参考的是引用型变量所属的类中是否有调用的成员。 
运行时期：也是参考引用型变量所属的类中是否有调用的成员。 
为何是这样的呢？由于静态方法，其实不所属于对象，而是所属于该方法所在的类。 调用静态的方法引用是哪一个类的引用调用的就是哪一个类中的静态方法。 
简单说：静态函数 — 编译运行都看 = 左边。

Object：全部类的直接或者间接父类，该类中定义的就是全部对象都具有的功能。

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

public boolean equals(Object obj){    if(!(obj instanceof Person))        return false;    Person p = (Person)obj;    return this.age == p.age; }

2，String toString()：将对象变成字符串； 
默认返回的格式：类名@哈希值 = getClass().getName() + ‘@’ + Integer.toHexString(hashCode()) 
为了对象对应的字符串内容有意义，能够经过复写，创建该类对象本身特有的字符串表现形式。

public String toString(){    return "person : "+age; }

3，Class getClass()：获取任意对象运行时的所属字节码文件对象。

4，int hashCode()：返回该对象的哈希码值。支持此方法是为了提升哈希表的性能。

内部类：若是A类须要直接访问B类中的成员，而B类又须要创建A类的对象。这时,为了方便设计和访问，直接将A类定义在B类中。就能够了。 
A类就称为内部类。内部类能够直接访问外部类中的成员。而外部类想要访问内部类，必需要创建内部类的对象。

class Outer{ 
    int num = 4;    class Inner {        void show(){            System.out.println("inner show run "+num);        }    }    public void method(){        Inner in = new Inner();//建立内部类的对象。        in.show();//调用内部类的方法。    } }

当内部类定义在外部类中的成员位置上，可使用一些成员修饰符修饰 private、static。 
1：默认修饰符。 直接访问内部类格式：外部类名.内部类名 变量名 = 外部类对象.内部类对象; Outer.Inner in = new Outer.new Inner();//这种形式不多用。 可是这种应用很少见，由于内部类之因此定义在内部就是为了封装。想要获取内部类对象一般都经过外部类的方法来获取。这样能够对内部类对象进行控制。 
2：私有修饰符。 一般内部类被封装，都会被私有化，由于封装性不让其余程序直接访问。 
3：静态修饰符。 若是内部类被静态修饰，至关于外部类，会出现访问局限性，只能访问外部类中的静态成员。 注意；若是内部类中定义了静态成员，那么该内部类必须是静态的。

匿名内部类：没有名字的内部类。就是内部类的简化形式。通常只用一次就能够用这种形式。匿名内部类其实就是一个匿名子类对象。想要定义匿名内部类：须要前提，内部类必须继承一个类或者实现接口。

匿名内部类的格式：new 父类名&接口名(){ 定义子类成员或者覆盖父类方法 }.方法。