学习java必知的概念

1、java面向对象的特征

 1）封装：封装就是将抽象得到的数据和行为（或功能）相结合，形成一个有机的整体，也就是将数据与操作数据的源代码进行有机的结合，形成“类”，其中数据和函数都是类的成员。

        面向对象程序设计中，一个非常重要的技术便是封装，也就是把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行信息隐藏。这样做的好处在于可以使类内部的具体实现透明化，只要其他代码不依赖类内部的私房数据，你便可以安心修改这些代码。此外，这样做也是出于安全方面的考虑，如果代表网上支付卡密码的变量随便就可以被访问到，这样的系统谁还敢用呢？

封装的目的是增强安全性和简化编程，使用者不必了解具体的实现细节，而只是要通过 外部接口，一特定的访问权限来使用类的成员。

2）继承：子类对父类的继承，若子类与父类在同一包中。子类继承了父类中所有不是private的成员方法（除构造方法）及不是private的成员变量。

对象是用类来定义的。通过类，你能够充分了解对象的全貌。比如，一说起自行车，你就会联想到自行车是有两个轮子、车把以及脚踏板。

　　更进一步，面向对象语言的另一个特点便是允许从一个已有的类定义新的类。比如，山地车、公路赛车和两人三轮车都是自行车。在面向对象语言中，你可以从一个已经有的自行车类定义山地车类、公路赛车类等等。山地车类、公路赛车类都称为自行车类的子类，自行车类是它们的父类，而这种定义关系，便是继承关系。

　　子类继承了父类的属性。比如，山地车、公路赛车都是有两个轮子一个车座。子类也可继承了父类的方法，比如山地车、公路赛车、两人三轮车都可以前进、刹车、转弯等。
当然，子类并不限于继承，还可以发扬光大。比如两人三轮车便颠覆了自行车只有两个轮子、一个座垫的属性，使得自己更加休闲潇洒。

3）多态

多态性（polymorphisn）是允许你将父对象设置成为和一个或更多的他的子对象相等的技术，赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。简单的说，就是一句话：允许将子类类型的指针赋值给父类类型的指针。

实现多态，有二种方式，覆盖，重载。

覆盖，是指子类重新定义父类的虚函数的做法。

重载，是指允许存在多个同名函数，而这些函数的参数表不同（或许参数个数不同，或许参数类型不同，或许两者都不同）。

2、Java中的关键字：
1）static，

 被static修饰的成员变量和成员方法独立于该类的任何对象。也就是说，它不依赖类特定的实例，被类的所有实例共享。只要这个类被加载，Java虚拟机就能根据类名在运行时数据区的方法区内找到他们。因此，static对象可以在它的任何对象创建之前访问，无需引用任何对象。 
      static变量前可以有private修饰，表示这个变量可以在类的静态代码块中，或者类的其他静态成员方法中使用（当然也可以在非静态成员方法中使用--废话），但是不能在其他类中通过类名来直接引用，这一点很重要。实际上你需要搞明白，private是访问权限限定，static表示不要实例化就可以使用 

     用static修饰的代码块表示静态代码块，当Java虚拟机（JVM）加载类时，就会执行该代码块

static变量

      按照是否静态的对类成员变量进行分类可分两种：一种是被static修饰的变量，叫静态变量或类变量；另一种是没有被static修饰的变量，叫实例变量。两者的区别是：
　   对于静态变量在内存中只有一个拷贝（节省内存），JVM只为静态分配一次内存，在加载类的过程中完成静态变量的内存分配，可用类名直接访问（方便），当然也可以通过对象来访问（但是这是不推荐的）。对于实例变量，没创建一个实例，就会为实例变量分配一次内存，实例变量可以在内存中有多个拷贝，互不影响（灵活）。

static方法

      静态方法可以直接通过类名调用，任何的实例也都可以调用，因此静态方法中不能用this和super关键字，不能直接访问所属类的实例变量和实例方法(就是不带static的成员变量和成员成员方法)，只能访问所属类的静态成员变量和成员方法。因为static方法独立于任何实例，因此static方法必须被实现，而不能是抽象的abstract。

static代码块

      static代码块也叫静态代码块，是在类中独立于类成员的static语句块，可以有多个，位置可以随便放，它不在任何的方法体内，JVM加载类时会执行这些静态的代码块，如果static代码块有多个，JVM将按照它们在类中出现的先后顺序依次执行它们，每个代码块只会被执行一次。

static和final一块用表示什么
static final用来修饰成员变量和成员方法，可简单理解为“全局常量”！
对于变量，表示一旦给值就不可修改，并且通过类名可以访问。
对于方法，表示不可覆盖，并且可以通过类名直接访问。

2）final，

final变量：

      当你在类中定义变量时，在其前面加上final关键字，那便是说，这个变量一旦被初始化便不可改变，这里不可改变的意思对基本类型来说是其值不可变，而对于对象变量来说其引用不可再变。其初始化可以在两个地方，一是其定义处，也就是说在final变量定义时直接给其赋值，二是在构造函数中。这两个地方只能选其一，要么在定义时给值，要么在构造函数中给值，不能同时既在定义时给了值，又在构造函数中给另外的值。

     当函数参数为final类型时，你可以读取使用该参数，但是无法改变该参数的值。

     另外方法中的内部类在用到方法中的参变量时，此参变也必须声明为final才可使用

final方法

     如果一个类不允许其子类覆盖某个方法，则可以把这个方法声明为final方法。
使用final方法的原因有二：
    第一、把方法锁定，防止任何继承类修改它的意义和实现。
    第二、高效。编译器在遇到调用final方法时候会转入内嵌机制，大大提高执行效率。

final类

     final类不能被继承，因此final类的成员方法没有机会被覆盖，默认都是final的。在设计类时候，如果这个类不需要有子类，类的实现细节不允许改变，并且确信这个类不会载被扩展，那么就设计为final类。

3）this，通常指向当前对象；
4）super，指向父类，如果想引用父类的某种东西时可以使用，此外当super后加参数时，表示调用父类中有相同参数形式的构造函数；
3、抽象类与接口

抽象类：

抽象方法与抽象类必须使用abstract修饰，有抽象方法的类只能被定义为抽象类，抽象类里可以没有抽象方法。
它们遵守的规则：
1 用abstract修饰，且抽象方法没有方法体（注意与空方法体的区别）。
2 抽象类不能实例化，即使该抽象类不包含抽象方法
3 抽象类包含属性、方法、初始化块、内部类、构造器、枚举六种类型。其构造器主要用于被子类调用。
4 包含抽象方法，或者父类包含抽象方法而没有实现，必须定义为抽象类。

abstract不能修饰属性和构造器，不能与static同时使用，也不能和private同时使用。

接口:
其修饰符可以是public或默认的包权限访问控制符。
接口中可以包含属性（只能是常量），方法（只能是抽象方法），内部类（包括内部接口）和枚举类定义
接口中的所有成员都是public权限（也可以省略不写），而接口中的属性则默认是public static final。
一个Java源文件中最多只有一个public接口，且与该源文件的主文件名相同。
实现接口的方法时只能使用public权限，因为子类重写父类方法或实现接口方法是访问权限只能更大或者相等

总结：声明方法的存在而不去实现它的类被叫做抽象类（abstract class），它用于要创建一个体现某些基本行为的类，并为该类声明方法，但不能在该类中实现该类的情况。不能创建abstract 类的实例。然而可以创建一个变量，其类型是一个抽象类，并让它指向具体子类的一个实例。不能有抽象构造函数或抽象静态方法。Abstract 类的子类为它们父类中的所有抽象方法提供实现，否则它们也是抽象类为。取而代之，在子类中实现该方法。知道其行为的其它类可以在类中实现这些方法。
接口（interface）是抽象类的变体。在接口中，所有方法都是抽象的。多继承性可通过实现这样的接口而获得。接口中的所有方法都是抽象的，没有一个有程序体。接口只可以定义static final成员变量。接口的实现与子类相似，除了该实现类不能从接口定义中继承行为。当类实现特殊接口时，它定义（即将程序体给予）所有这种接口的方法。然后，它可以在实现了该接口的类的任何对象上调用接口的方法。由于有抽象类，它允许使用接口名作为引用变量的类型。通常的动态联编将生效。引用可以转换到接口类型或从接口类型转换，instanceof 运算符可以用来决定某对象的类是否实现了接口。

4、内部类、匿名内部类

内部类的作用
1 内部类提供了更好的封装，可以把内部类隐藏在外部类之内，不允许同一个包内的其他类访问该类
2 内部类成员可以直接访问外部类的私有数据，而外部类不能访问内部类的实现细节。
3 匿名内部类适用于创建那些只需要使用一次的类

内部类分为成员内部类和局部内部类，而局部内部类又分为非静态内部类和静态内部类，其在外部类中与其他静态，和非静态成员的使用类似。

匿名内部类格式
new 父类构造器（实参列表）|实现接口（）
{
 //匿名内部类的类体部分
}
匿名内部类必须继承一个父类或实现一个接口
匿名内部类使用规则：
1 不能使抽象类
2 不能定义构造器，因为没有类名，但可以定义初始化块，可以通过初始化块来完成构造器的工作。

5、final, finally, finalize的区别。

final 用于声明属性，方法和类，分别表示属性不可变，方法不可覆盖，类不可继承。
finally是异常处理语句结构的一部分，表示总是执行。
finalize是Object类的一个方法，在垃圾收集器执行的时候会调用被回收对象的此方法，可以覆盖此方法提供垃圾收集时的其他资源回收，例如关闭文件等。

6、 "=="和equals方法究竟有什么区别

（单独把一个东西说清楚，然后再说清楚另一个，这样，它们的区别自然就出来了，混在一起说，则很难说清楚）

==操作符专门用来比较两个变量的值是否相等，也就是用于比较变量所对应的内存中所存储的数值是否相同，要比较两个基本类型的数据或两个引用变量是否相等，只能用==操作符。

如果一个变量指向的数据是对象类型的，那么，这时候涉及了两块内存，对象本身占用一块内存（堆内存），变量也占用一块内存，例如Objet obj = new Object();变量obj是一个内存，new Object()是另一个内存，此时，变量obj所对应的内存中存储的数值就是对象占用的那块内存的首地址。对于指向对象类型的变量，如果要比较两个变量是否指向同一个对象，即要看这两个变量所对应的内存中的数值是否相等，这时候就需要用==操作符进行比较。

equals方法是用于比较两个独立对象的内容是否相同，就好比去比较两个人的长相是否相同，它比较的两个对象是独立的。例如，对于下面的代码：

String a=new String("foo");

String b=new String("foo");

两条new语句创建了两个对象，然后用a,b这两个变量分别指向了其中一个对象，这是两个不同的对象，它们的首地址是不同的，即a和b中存储的数值是不相同的，所以，表达式a==b将返回false，而这两个对象中的内容是相同的，所以，表达式a.equals(b)将返回true。

在实际开发中，我们经常要比较传递进行来的字符串内容是否等，例如，String input = …;input.equals(“quit”)，许多人稍不注意就使用==进行比较了，这是错误的，随便从网上找几个项目实战的教学视频看看，里面就有大量这样的错误。记住，字符串的比较基本上都是使用equals方法。

如果一个类没有自己定义equals方法，那么它将继承Object类的equals方法，Object类的equals方法的实现代码如下：

boolean equals(Object o){

return this==o;

}

这说明，如果一个类没有自己定义equals方法，它默认的equals方法（从Object 类继承的）就是使用==操作符，也是在比较两个变量指向的对象是否是同一对象，这时候使用equals和使用==会得到同样的结果，如果比较的是两个独立的对象则总返回false。如果你编写的类希望能够比较该类创建的两个实例对象的内容是否相同，那么你必须覆盖equals方法，由你自己写代码来决定在什么情况即可认为两个对象的内容是相同的。