一、重载

在一个程序中，可以定义多个名称相同的方法，但是参数的类型或个数必须不同。

二、重写

子类在继承父类方法的时候，有时候需要对父类的方法进行一些修改，这就是重写。需要相同的方法名，参数列表和返回值类型。
子类在重写父类方法时，不能比父类的方法权限更严格，比如父类方法是Public，子类方法就不能是private。
在子类中，用super关键字访问父类的成员。(super.成员变量，super.成员方法)

三、递归

方法的递归是指在一个方法的内部调用自身的过程。递归必须要有结束条件，不然会陷入无限递归的状态。

四、数组

int[] x = new int[100]
上面代码的意思是，先声明一个变量x，该变量为一个int类型的数组。变量x回占用一块内存单元，它没有被分配初始值。然后创建一个数组，将数组的地址赋给x，这时内存中的状态才会发生变化。该数组中有100个元素，初始值都为0，每一个元素都有一个索引，最小的是0，最大的是99，也就是数组的长度-1。

五、八大基本数据类型

整数型四种(int，byte，short，long)
浮点型两种(float，double)
字符型(char)
布尔型(boolean)

String 类型不是基本数据类型，属于引用数据类型，它实际上是final修饰，所以也不可以继承。
区别:基本数据类型和引用类型的区别主要在于基本数据类型是分配在栈上的，而引用类型是分配在堆上的。

六、面向对象的概念

我理解的意思差不多就是，我们用对象来对应我们的现实中的事物，用对象的关系来描述事物之间的关系，这种思想，就是面向对象。

面向对象的特点是，封装性，继承性，多态性。

1. 封装性

将对象的属性和行为封装起来，不需要让外界知道具体的实现细节。

2. 继承性

继承性主要是描述类于类之间的关系。通过继承，我们可以无需编写原有类，对原有类的功能进行扩展。

3. 多态类

指程序中允许出现重名现象，但不同的参数可以表现出不同的行为。

七、构造方法

构造方法满足的条件：

方法名与类名要相同
在方法名的前面没有返回值类型的声明
在方法中不能使用return语句返回一个值

当一个类被实例化后，会自动调用该类的构造方法。

构造方法也可以重载，根据传入参数的不同，分别调用不同的构造方法。

八、this关键字

this关键字有三种使用方法。

1. 在方法里使用this调用类的成员变量，解决与局部变量名称冲突的问题。

class person{
int age;
public person(int age){
this.age = age;
}
public int getAge(){
return this.age;
}
}

2. 在一个方法里，通过this关键字调用同一个类的另一个成员方法

public void a(){
...
}
public void b(){
this.a();
}

3.使用this调用类的构造方法，要注意：只能在构造方法里才能使用this调用其他的构造方法，而且this调用构造方法的语句必须在第一句，只能出现一次。

九、static关键字

static用于修饰类的成员，比如成员变量，成员方法，还有代码块。

1. 静态变量

用static修饰的成员变量，称为静态变量。被所有实例共享。用类名.变量名来访问。
static只能修饰成员变量，不能修饰局部变量。

2. 静态方法

静态方法可以不用实例化对象，就可以访问。类名.方法名() 这样就可以访问了。当然也可以实例化再访问。

3. 静态代码块

使用一个{}包围起来的代码被称为一个代码块。用static修饰的代码块称为静态代码块。
如：

1
2
3

static{
sout("hhh");
}

这样。加载类的同时会执行该类的静态代码块，而且只有这个类在第一次被使用时才会加载。

十、内部类

在一个类的内部定义类，这样的类称为内部类。这个内部类所在的类被称为外部类。内部类又分三种，成员内部类，静态内部类，方法内部类。

1. 成员内部类

就是在一个类中再定义一个类，普通的类。
内部类可以在外部类中被使用，并且能访问外部类的成员。
但如果想通过外部类去访问内部类，则需要通过外部类的对象去创建内部类对象。
如：

1 2	Outer.Inner inner = new Outer().new Inner() inner.show()

2. 静态内部类

用static来修饰成员内部类，那么该内部类就被称为静态内部类。
它可以在不创建外部类对象的情况下被实例化。

1 2	Outer.Inner inner = new Outer.Inner(); inner.show();

静态内部类中只能访问外部类的静态成员。
在静态内部类中可以定义的静态的成员，而在非静态内部类中不能定义静态成员。

3. 方法内部类

方法内部类，是指在成员方法中定义的类，它只能在当前方法中被使用。

public void test(){
     class Inner{
	     void show{
		     sout("ggg");
		 }
	 }
	 Inner in = new Inner();
	 in.show();
}

main(){
Outer outer = new Outer();
outer.test();
}

方法内部类，只能在方法中创建该类的实例对象并调用show()方法。方法内部类中也可以访问外部类的成员变量。

十一、类的继承

类的继承指在一个现有类的基础上去构建一个新的类，构建出来的新类被称为子类，现有类被称为父类。用 extends 关键字来声明。

需要注意：
在Java中，类只支持单继承，不允许多重继承
多个类可以继承同一个父类
可以多层继承，B继承A，C继承B
子类在实例化时，会默认调用父类无参的构造方法

十二、final关键字

final关键字用来修饰类，方法和变量。

修饰类时，该类将不可被继承
修饰一个类的方法时，那么这个类的子类将不能重写该方法
修饰变量时，那这个变量只能被赋值一次，而且需要在声明的时候赋予值，这个值将不能被修改

十三、抽象类与接口

抽象类

抽象类，就是类的抽象。我们知道类是客观事物的抽象，而抽象类又是类的进一步抽象。

举个例子：

猫，狗，鸡。这三个动物都会叫，但每个动物叫的声音都不一样。我们把猫，狗，鸡这三个动物都抽象为类，每个类都有一个叫的方法，那么猫的方法输出就是喵，狗输出的是汪，鸡输出的是喳。这个时候我们就可以把这三个类，在进行一次抽象，筛选出他们的共同点，叫。然后这三个类，都继承这个抽象类，然后实现这个叫的方法。

1）抽象方法必须为public或者protected（因为如果为private，则不能被子类继承，子类便无法实现该方法），缺省情况下默认为public。

2）抽象类不能用来创建对象；

3）如果一个类继承于一个抽象类，则子类必须实现父类的抽象方法。如果子类没有实现父类的抽象方法，则必须将子类也定义为为abstract类。

4) 包含抽象方法的类，必须声明为抽象类

接口

更方便的对一个事物的功能进行拓展。是一种极度抽象的类型，它比抽象类更加“抽象”。

接口中可以含有变量和方法。但，接口中的变量会被指定为public static final变量，而方法会被指定为public abstract方法且只能是public abstract方法，并且接口中所有的方法不能有具体的实现，也就是说，接口中的方法必须都是抽象方法，并且一般情况下不在接口中定义变量。

抽象类与接口的区别

1、抽象类和接口都不能直接实例化，如果要实例化，抽象类变量必须指向实现所有抽象方法的子类对象，接口变量必须指向实现所有接口方法的类对象。

2、抽象类要被子类继承，接口要被类实现。

3、接口只能做方法申明，抽象类中可以做方法申明，也可以做方法实现

4、接口里定义的变量只能是公共的静态的常量（public,static,final），抽象类中的变量可以是成员变量或者静态变量。

5、抽象类里的抽象方法必须全部被子类所实现，如果子类不能全部实现父类抽象方法，那么该子类只能是抽象类。同样，一个实现接口的时候，如不能全部实现接口方法，那么该类也只能为抽象类。

6、抽象方法只能申明，不能实现。abstract void abc();不能写成abstract void abc(){}。

7、抽象类里可以没有抽象方法

8、如果一个类里有抽象方法，那么这个类只能是抽象类

9、抽象方法要被实现，所以不能是静态的，也不能是私有的（静态的变量或者方法是全局可用，可以被继承，但不能被重写。也就相应的不存在被实现）。

10、接口可继承接口，并可多继承接口，但类只能单根继承。