1.类是一种抽象的概念，对象是类的一种具体表示形式，是具体的概念。先有类，然后由类来生成
对象（Object）。对象又叫做实例（Instance）。
2.类由两大部分构成：属性以及方法。属性一般用名词来表示，方法一般用动词来表示。
3.如果一个java源文件中定义了多个类，那么这些类中最多只能有一个类是public的，换句话说，定义
的多个类可以都不是public的。
4.在java中进行方法的参数传递时，无论传递的是原生数据类型还是引用类型，参数传递方式统一是
传值（pass by value）。java中没有传引用（pass by reference）的概念。
5.方法重载（overload）.表示两个或多个方法名字相同，但是方法参数不同。方法参数不同有两层
含义：1）参数个数不同。2）参数类型不同。注意：方法的返回值对重载没有任何影响。
/**
* 功能:方法重载
* @author Administrator
*
*/
public class MethodOverload
{
public int add(int a,int b)
{
return a + b;
}
public int add(int a,int b,int c)
{
return a + b + c;
}
public static void main(String[] args)
{
MethodOverload methodOverlod = new MethodOverload();
System.out.println(methodOverlod.add(1, 2));
System.out.println(methodOverlod.add(1, 2, 3));
}
}
6.构造方法重载：只需看参数即可。如果想在一个构造方法中调用另外一个构造方法，那么
可以使用this()的方法调用，this()括号中的参数表示目标构造方法的参数。this()必须要
作为构造方法的第一条语句，换句话说，this()之前不能有任何可执行的代码。
7.继续（Inheritence）:java是单继承的，意味着一个类只能从另一个类继续（被继续的类叫做
父类[基类，base class],继承的类叫做子类），java中的继续使用extends关键字。
8.当生成子类对象时，java默认首先调用父类的不带参数的构造方法，然后执行该构造方法，
生成父类的对象。接下来，再去调用子类的构造方法，生成子类的对象。[要想生成子类的对象，
首先需要生成父类的对象，没有父类的对象就没有子类的对象]
public class Child extends Parent
{
public Child()
{
System.out.println("Child");
}
public static void main(String[] args)
{
Child child = new Child();
}
}
class Parent
{
public Parent()
{
System.out.println("no args parent");
}
public Parent(int i)
{
System.out.println("Parent");
}
}
运行该程序输出的结果为:
no args parent
Child
如果类Parent没有无参数构造函数，则子类Child的构造函数中需要利用super()来指定
调用父类的有参数的构造函数，否则程序将编译出错。
情况1：子类Child的构造函数中没有利用super()调用父类的有参数构造函数，程序出现
编译错误。
public class Child extends Parent
{
public Child()
{
System.out.println("Child");
}
public static void main(String[] args)
{
Child child = new Child();
}
}
class Parent
{
public Parent(int i)
{
System.out.println("Parent");
}
}
情况2：子类Child的构造函数中利用super()调用父类的带参数的构造函数
public class Child extends Parent
{
public Child()
{
super(1);
System.out.println("Child");
}
public static void main(String[] args)
{
Child child = new Child();
}
}
class Parent
{
public Parent(int i)
{
System.out.println("Parent");
}
}
其中，子类构造函数中super 语句必须写在第一行，否则将出现编译错误。
9.super关键字:super表示对父类对象的引用。
10. 如果子类使用super()显示调用父类的某个构造方法，那么在执行的时候就会寻找与super()所
对应的构造方法而不会再去寻找父类的不带参数的构造方法。与this一样，super也必须要作为构造
方法的第一条执行语句，前面不能有其他可执行的语句。
11.关于继续的3点：
a)父类有的，子类也有。
b)父类没有的，子类可以增加。
c)父类有的，子类可以改变。
12.关于继续的注意事项：
a)构造方法不能被继承
b)方法和属性可以被继续
c)子类的构造方法隐式的调用父类的不带参数的构造方法
d)当父类没有不带参数的构造方法时，子类需要使用super来显示的调用父类的带参数的构造
方法,super指的是对父类的引用。
e)super关键字必须是构造方法中的第一行语句。
1.方法重写（Override）:子类与父类的方法返回类型一样，方法名称一样，参数一样，这样我们说
子类与父类的方法构成了重写关系。
2.方法重写与方法重载之间的关系：
1）重载发生在同一个类内部的两个或多个方法。
2）重写发生在子类与父类之间。
3.当两个方法形成重写关系时，可以在子类方法中通过super形式调用父类的方法，其中super不必放在
第一行语句。因为此时的父类对象已经构造完毕，先调用父类的方法还是先调用子类的方法时根据程序
的逻辑决定的。
4.在定义一个类的时候，如果没有显示指定该类的父类，那么该类就会继承于java.lang.Object
类（JDK提供的一个类，Object类是java中所有类的直接或间接父类）
5.多态（Polymorphism）:我们说子类是父类，因此多态的意思就是：父类型的引用可以指向子类的对象。
举例：
public class PloyTest
{
public static void main(String[] args)
{
Flower rose = new Rose();//多态
rose.sing();
}
}
class Flower
{
public void sing()
{
System.out.println("Flower is singing");
}
}
class Rose extends Flower
{
}
2.Parent p = new Child();当使用多态方式调用方法时，首先检查父类中是否有sing()方法，如果没有则编译错误，
如果有，再去调用子类的sing()方法。
public class PloyTest2
{
public static void main(String[] args)
{
Parent p = new Child();
p.sing(); //出现编译错误
}
}
class Parent
{
}
class Child extends Parent
{
public void sing()
{
System.out.println("Child is sing");
}
}
3.一共有两种类型的强制类型转换：
a)向上类型转换（upcast）:
比如说将Cat类型转换为Animal类型，即将子类型转换为父类型。对于向上类型转换，不需要显示指定。
b)向下类型转换（downcast）:比如将Animal类型转换为Cat类型，即父类型转换为子类型。对于向下类型转换，
必须要显示指定（必须要使用强制类型转换）。
public class PloyTest3
{
public static void main(String[] args)
{
//向上类型转换
Dog dog = new Dog();
Animal animal = dog;
animal.sing();
//向下类型转换
Animal a = new Dog();
Dog d = (Dog)a;
d.sing();
}
}
class Animal
{
public void sing()
{
System.out.println("Animal is singing");
}
}
class Dog extends Animal
{
public void sing()
{
System.out.println("Dog is singing");
}
}
1.抽象类(abstract class): 使用了abstract关键字所修饰的类叫做抽象类。
2.抽象类无法实现化，也就是说，不能new出来一个抽象类的对象（实例）
举例：
public class AbstractTest01
{
public static void main(String[] args)
{
A a = new A();//将会出现编译错误。
}
}
abstract class A
{
}
将会出现编译错误。
3.抽象方法(abstract method):使用abstract关键字所修饰的方法叫做抽象方法，抽象方法有声明,无实现。
（抽象主要定义在抽象类中）
abstract class A
{
public abstract void method();//抽象方法
}
4.如果一个类包含了抽象方法，那么这个类一定是一个抽象类。
5.如果某个类是抽象类，那么该类可以包含具体的方法（有声明，有实现的）。
举例:
abstract class A
{
public abstract void method();//抽象方法
public void test()
{
System.out.println("test");
}
}
6.如果一个类中包含了抽象方法，那么这个类一定要声明成abstract class,也就是说，该类一定
是抽象类；反之，如果某个类是抽象类，那么该类既可以包含抽象方法，也可以包含具体方法。
7.无论何种情况，只要一个类是抽象类，那么这个类就无法实例化。
8.在子类继承父类（父类是个抽象类）的情况下，那么该子类必须要实现父类中所定义的所有抽象方法；否则，
该子类需要声明成一个abstract class.
9.接口(interface):接口的地位等同于class,接口中的所有方法都是抽象方法。
1.接口（interface）:接口的地位等同于class,接口中的所有方法都是抽象方法。在声明接口的方法
时，可以使用abstract关键字，也可以不使用。通常情况下，都会省略掉abstract关键字。
2.可以将接口看着是特殊的抽象类（抽象类中可以有具体方法，也可以有抽象方法，而接口中只能有抽象方法，
不能有具体的方法。）
1.类可以实现接口。实现使用关键字implements表示，代表了某个类实现了某个接口。
2.一个类实现了某个接口，那么该类必须要实现接口中声明的所有方法，如果该类是个抽象类，
那么无需实现接口中的方法了。
3.java是单继承的，也就是说某个类只能有唯一一个父类。一个类可以实现多个接口，多个接口之间使用逗号分隔。
4.多态：所谓多态，就是父类型的引用可以指向子类型的对象，或者接口类型的引用可以指向实现该接口的类的实例。
关于接口与实现接口的类之间的强制类型转换方式与父类和子类之间的强制类型转换方法完成一样。
5.static关键字：可以用于修饰属性，也可以用于修饰方法，还可以用于修饰类。
6.static修饰属性：无论一个类生成多少个对象，所有这些对象共同使用唯一一份静态的成员变量;一个对象对该
静态成员变量进行了修改，其他对象的该静态成员变量的值也会随之发生改变。如果一个成员变量是static的，那么
我们可以通过 类名.成员变量名 的方式来使用它。
7.static修饰方法：static修饰的方法叫做静态方法。可以使用 类名.方法名的方式来访问。
8.静态方法只能继承，不能被重写（Override）
9.final关键字：final可以修饰属性，方法，类。
10.final修饰类：当一个类被final修饰时，表示该类是一个终态类，即不能被继承。
11.final修饰方法：当一个被final所修饰时，表示该方法时一个终态方法，即不能被重写（Override）
12.final修饰属性时：当一个属性被final所修饰时，表示该属性不能被改写。
13.当final修饰一个原生数据类型时，表示该原生数据类型的值不能发生改变（比如说不能从10变为20）;
如果final修饰一个引用类型时，表示该引用类型不能再指向其他对象了，但该引用所指向的对象的内容是可以
发生变化的。
1.接口中所声明的方法都是抽象方法，接口中的方法都是public的。
2.接口中也可以定义成员变量。接口中的成员变量都是public static final 的。
3.一个类不能既是final，又是abstract的。因为abstract的主要目的是定义一种约定，让
子类去实现这种约定，而final表示该类不能被继承，这样abstract希望该类可以被继承而
final明确说明该类不能被继承，两者矛盾。因此一类个不能既是final的，又是abstract的。
4.单列模式（Singleton）:表示一个类只会生成唯一的一个对象。
/**
* 功能:单列模式
* @author Administrator
*
*/
public class SingletonTest
{
public static void main(String[] args)
{
Singleton test1 = Singleton.getInstance();
Singleton test2 = Singleton.getInstance();
System.out.println(test1 == test2);
}
}
class Singleton
{
private static Singleton singleton = null;
private Singleton()
{ }
public static Singleton getInstance(){
if(singleton == null){
singleton = new Singleton();
return singleton;
}else{
return singleton;
}
}
}
1.包（package）:用于将完成不同功能的类分门别类，放在不同的目录（包）下。
2.相等性的比较：（==）
a)对于原生数据类型来说，比较的是左右两边的值是否相等。
b)对于引用类型来说，比较左右两边的引用是否指向同一个对象，或者说左右两边的引用地址是否相同。
3.java.lang.Object类。 java.lang包在使用的时候无需手动导入，在编译的时候编译器自动帮我们导入。
4.打印引用时，实际上会打印出引用所指对象的toString()方法的返回值，因为每个类都直接或间接的继承自Object
而Object类中定义了toString()，因此每个类都有toString()这个方法。
举例：
public class ObjectTest
{
public static void main(String[] args)
{
Object object = new Object();
System.out.println(object);
System.out.println(object.toString());
}
}
运行结果：
java.lang.Object@12940b3
java.lang.Object@12940b3