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 父类名&接口名(){ 定义子类成员或者覆盖父类方法 }.方法。