类和对象的概念

类：是一组相关的属性和行为的集合，对象：是该类事物的具体体现

面向对象的三大重点：封装(encapsulation)、继承(inheritance)-多态(polymorphism)、接口(interface)

在类中的位置不同

成员变量：在类中方法外

局部变量：在方法定义中或者方法声明上

在内存中的位置不同

成员变量：在堆内存(成员变量属于对象，对象进堆内存)

局部变量：在栈内存(局部变量属于方法，方法进栈内存)

生命周期不同

成员变量：随着对象的创建而存在，随着对象的消失而消失

局部变量：随着方法的调用而存在，随着方法的调用完毕而消失

初始化值不同

成员变量：有默认初始化值

局部变量：没有默认初始化值，必须定义，赋值，然后才能使用。

注意事项：

局部变量名称可以和成员变量名称一样，在方法中使用的时候，采用的是就近原则。

基本数据类型变量包括：byte，short，int，long，float，double，boolean，char

引用数据类型变量包括：数组，类，接口，枚举

this代表当前对象的引用，super代表对父类的引用，在构造方法中二者不能同时出现。

class Phone {                            

                private String brand;

                private int price;

                public void setBrand(String brand) {

                    this.brand = brand;

                }

}

this和super的使用区别

调用成员变量

this.成员变量：调用本类的成员变量，也可以调用父类的成员变量（调用父类的变量是因为子类中没有和父类一样的变量）

super.成员变量：调用父类的成员变量

调用构造方法

this(参数)    调用本类的构造方法

super(参数)    调用父类的构造方法

调用成员方法

this.成员方法：调用本类的成员方法，也可以调用父类的方法

super.成员方法：调用父类的成员方法

随着类的加载而加载，优先于对象存在，被类的所有对象共享，可以通过类名调用。

注意事项

在静态方法中是没有this关键字的，因为this代表的是对当前对象的引用，而static是先于对象存在，所以矛盾。静态是随着类的加载而加载，this是随着对象的创建而存在。静态比对象先存在。

静态方法只能访问静态的成员变量和静态的成员方法。

静态变量也叫类变量，成员变量也叫对象变量。

所属不同

静态变量属于类，所以也称为为类变量

成员变量属于对象，所以也称为实例变量(对象变量)

内存中位置不同

静态变量存储于方法区的静态区

成员变量存储于堆内存

内存出现时间不同

静态变量随着类的加载而加载，随着类的消失而消失

成员变量随着对象的创建而存在，随着对象的消失而消失

调用不同

静态变量可以通过类名调用，也可以通过对象调用

成员变量只能通过对象名调用

修饰类，类不能被继承­

修饰变量，变量就变成了常量，只能被赋值一次

修饰方法，方法不能被重写，即子类不能重写父类的final方法

final修饰变量的初始化时机

显示初始化，即在类中的变量定义时：final int num =10；如果写成final int num；虽然变量num默认初始化为0，但是对于final来说是无效的，会报错。

在对象构造完毕前即可，即构造方法中，给变量赋值即可。

作用是给对象属性进行初始化，方法名与类名相同，没有返回值类型，连void都没有，没有具体的返回值return。

class Person {

    private String name;

    private int age;

    public Person() {

        name = "张三";

        age = 23;

    }

    public void show() {

        System.out.println(name + "..." + age);

    }

}

构造方法重载：方法名相同，参数列表不同。

构造方法注意事项

如果没有给出构造方法，系统将自动提供一个无参构造方法。

如果给出了构造方法，系统将不再提供默认的无参构造方法。

封装是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。

封装好处：

    隐藏实现细节，提供公共的访问方式

    提高了代码的复用性

    提高安全性

封装原则：

    将不需要对外提供的内容都隐藏起来

    把属性隐藏，提供公共方法对其访问

private关键字是一个权限修饰符，可以修饰成员变量和成员方法，被其修饰的成员只能在本类中被访问。

封装和private的应用：把成员变量用private修饰，提供对应的getXxx()和setXxx()方法， private仅仅是封装的一种体现形式，不能说封装就是私有。

通过javadoc命令生成说明书，首先在代码的注释中，添加如下内容

    @author (提取作者内容)

    @version (提取版本内容)   

    @param 参数名称//形式参数的变量名称

    @return 函数运行完返回的数据

cmd运行命令：

    javadoc -d 指定的文件目录 -author -version ArrayTool.java

在Java中，使用{}括起来的代码被称为代码块。根据其位置和声明的不同，可以分为局部代码块，构造代码块，静态代码块，同步代码块。

局部代码块

在方法中出现，限定变量生命周期，及早释放，提高内存利用率，开发中利用率低。

public static void main(String[] args) {

        {

            int x = 10; 

            System.out.println(x);

        }

}

构造代码块 (初始化块)

在类中方法外出现；多个构造方法方法中相同的代码存放到一起，每次调用构造方法都执行，并且在构造方法前执行，开发中用的少。

{       //构造代码块，每创建一次对象就会执行一次，优先于构造函数

        System.out.println("构造代码块"); }

静态代码块

在类中方法外出现，并加上static修饰；用于给类进行初始化，在加载的时候就执行，并且只执行一次。一般用于加载驱动。

static {   

        System.out.println("我是静态代码块"); 

}

让类与类之间产生关系，子父类关系。

提高了代码的复用性，提高了代码的维护性，让类与类之间产生了关系，是多态的前提。但是类的耦合性增强了。开发的原则：高内聚，低耦合。

Java只支持单继承，不支持多继承。即只能extend一个类。但是Java支持多层继承

子类只能继承父类所有非私有的成员（成员方法和成员变量）

子类不能继承父类的非空构造方法，但是可以通过super关键字去访问。

子类中所有的构造方法默认都会访问父类中空参数的构造方法， 因为子类初始化之前，一定要先完成父类数据的初始化。每一个构造方法的第一条语句默认都是：super();如果不写的话，系统会默认加上。而父类的构造方法使用super();时会调用Object类的空参构造方法，object类是最顶层的父类。

如果父类没有无参构造方法，子类如果不进行处理会报错。解决方法：

   super解决：在子类的构造方法中，调用父类的有参构造方法，super(参数1，参数2，...);

   this解决：直接调用本类中的构造方法，例如在子类的空参构造方法中，this(参数1，参数2，...);调用自己的有参构造方法

方法重写：子父类出现了一模一样的方法，当子类需要父类的功能，而功能主体子类需要有自己特有内容时，可以重写父类中的方法。这样，即沿袭了父类的功能，又定义了子类特有的内容。

方法重写注意事项

父类中私有方法不能被重写：因为父类私有方法子类根本就无法继承；

子类重写父类方法时，访问权限不能更低，最好就一致；

父类静态方法，子类也必须通过静态方法进行重写；

子类重写父类方法的时候，最好声明一模一样。

权限修饰符：private，default，protected，public

状态修饰符：static，final

抽象修饰符：abstract

类加了权限修饰符后，访问的权限，Y代表可以访问

                本类      同一个包下(子类和无关类)    不同包下(子类)    不同包下(无关类) private        Y         默认            Y                  Y protected    Y                  Y                                          Y public          Y                 Y                                          Y                              Y

权限修饰符：default，public

状态修饰符：final

抽象修饰符：abstract

用的最多的就是：public

权限修饰符：private，default，protected，public

状态修饰符：static，final

用的最多的就是：private

权限修饰符：private，default，protected，public

用的最多的就是：public

权限修饰符：private，default，protected，public

状态修饰符：static，final

抽象修饰符：abstract

用的最多的就是：public

成员变量：public static final

成员方法:

public static

public abstract

public final

内部类可以直接访问外部类的成员（变量或者方法），包括私有。外部类要访问内部类的成员，必须创建对象。

外部类名.内部类名 对象名 = new 外部类名().内部类类名();

如果这个内部类被private，那么就需要在外部类中定义一个方法，在这个方法中对内部类进行创建，并且访问内部类中的方法。

如果这个内部类被static，那么创建这个内部类就直接写为：

外部类名.内部类名 对象名 = new 外部类名.内部类类名();

局部内部类是在方法中有个类。开发中很少用。只能在所在的方法中被访问。

局部内部类访问方法中的局部变量时，局部变量必须用final修饰。如果没有用final修饰，变量的生命周期和方法的生命周期一样的，当方法弹栈，这个局部变量也会消失，那么如果局部内部类对象在堆中，若没有马上消失想用这个局部变量，就没有了，如果用final修饰会在类加载的时候进入常量池，即使方法弹栈，常量池的常量还在，也可以继续使用。

就是内部类的简化写法。前提是存在一个类或者接口。这里的类可以是具体类也可以是抽象类。匿名内部类本质是一个继承了该类或者实现了该接口的子类匿名对象。只针对实现一个方法时使用匿名内部类，否则调用一个方法，却要重新多个方法，没必要。匿名内部类不能向下转型，因为没有类名。

格式:

new 类名或者接口名(){

    重写方法;

};

多态，即事物存在多个状态。多态前提，要有继承关系，要有方法重写，要有父类引用指向子类对象。

Animal a = new Cat();//cat继承了animal类，并重写了eat方法

a.eat();

成员变量：编译看左边（父类），运行看左边（父类）

Father f = new Son();

System.out.println(f.num); //f的地址只能访问到父类的变量

成员方法：编译看左边（父类），运行看右边（子类），也叫作动态绑定

静态成员方法：编译看左边（父类），运行看左边（父类）

Person p = new SuperMan(); 向上转型

SuperMan sm = (SuperMan) p; 向下转型

好处：提高代码的维护性（继承保证），提高了代码的拓展性（多态保证，可以当做形式参数，可以接收任意子类对象）

弊端：不能使用子类特有的方法，除非进行向下转型

抽象类和抽象方法必须用abstract关键字修饰

abstract class 类名{ } 

public abstract void eat();

抽象类不一定有抽象方法，有抽象方法的类一定是接口或者是抽象类。

抽象的类不能实例化，只能通过子类实例化，子类要么是抽象类，要么需要重写抽象类中的所有方法。

成员变量：既可以是变量，也可以是常量。abstract不能修饰成员变量。

成员方法：既可以是抽象的，也可以是非抽象的。

构造方法：有（或者是隐含地给出空参构造方法），为了初始化类

抽象类成员方法特点：抽象方法强制子类实现，非抽象方法给子类继承，提高代码复用性

从狭义地讲，java中的interface是接口，广义地说，对外提供规则的都是接口。

接口用interface表示：interface 接口名 { }

接口实现用implements表示：class 类名 implements 接口名 { }

接口不能实例化，按照多态的方式实例化，即父类引用指向子类对象

接口成员特点：

成员变量：只能是常量，并且是静态的并公共的，默认public static final，建议自己给出

构造方法：接口没有构造方法，这个和抽象类不同

成员方法：只能是抽象的方法，默认public abstract，建议自己给出

假如某个类上第一条语句为package com.it.dragon，编译时候可以使用语句：javac -d . 类名，会在类的当前目录下生成com/it/dragon的路径，如果仅仅使用javac 类名，则仅在类当前路径下，生成class文件。

运行时，在com的当前路径下，使用java com.it.dragon.类名，才能运行该类，在其他路径下运行都会找不到该类，因为该类已经含有package。

demo访问person类，则person类需要是public，且被访问的方法也是public。

在demo中，如果不使用import，则需要加全路径名访问person类：com.it.dragon.person p = new com.it.dragon.person();这种方法十分痛苦。

采用import com.it.dragon.person 则只需要 p = new person();