Java学习笔记1

基本变量类型

整型：

byte、short、int、long

long val = 26L; ``//以L结尾的字面值表示long型

字符型：

char

浮点型：

float、double

float aa = 313f;

float f1 = ``123``.4F;``// 以F结尾的字面值表示float类型

布尔型：

boolean

数据类型转换：

规则：从小到大自动转，从大到小强制转。

#Arrays

Arrays是针对数组的工具类，可以进行 排序，查找，复制填充等功能。 大大提高了开发人员的工作效率。

Arrays.copyOfRange(int[] original, int from, int to) 数组复制

第一个参数表示源数组

第二个参数表示开始位置(取得到)

第三个参数表示结束位置(取不到)

toString() 转换为字符串

sort 排序

binarySearch 搜索

equals 判断是否相同

fill 填充

形参和实参各指什么？

形参：以方法为例，就是方法定义时的变量

实参：在方法内部定义的变量

java的参数传递机制

值传递，传输的是实参存储的值

方法重载

return关键字的作用

1、立即跳出当前方法，并结束当前方法的执行

面向对象语法、

在java中，必须显示设计类，才能获得对象

类（设计图）：是对象共同特征的描述

对象：是真实存在的具体实例

对象在内存中的存在形式

Cat cat = new Cat();

cat.name = "小白";

cat.age = 2;

cat.color = "白色"；

所有的Java对象都存储在堆中。当一个对象包含另一个对象变量是，它只是包含另一个堆对象的指针。

如何定义类：

public class 类名{

​ 1、成员变量（代表属性，一般是名词）

​ 2、成员方法（代表行为，一般是动词）

​ 3、构造器

​ 4、代码块

​ 5、内部类

}

如何得到类的对象

类名 对象名 = new 类名（）；

Car c = new Car();

先声明再创建：

Car c;

c = new Car();

1、对象放在堆内存中

2、Car c = new Car(); c变量名中存储的是什么：

存储的是对象在堆内存中的地址

3、成员变量（name，price）的数据放在那里，存在于那个位置？

对象中，存在于堆内存中

类和对象的内存分配机制

java内存的结构分析：

栈：一般存放基本的数据类型（局部变量）

堆：存放对象（Cat cat，数组等）

方法区：常量池（常量，比如字符串） 类加载信息

#属性（成员变量）和局部变量

属性（成员变量）：直接定义在类的一对{}内

局部变量：声明在方法内，方法形参、代码块内，构造器形参，构造器内部的变量

局部变量不能使用权限修饰符。

默认初始化值情况：

属性（成员变量）：类的属性，根据其类型，都有默认初始化值

局部变量：没有默认初始化值

​ 意味着在调用局部变量之前，一定要显示赋值

​ 特别的：形参在调用时，再赋值即可。

在内存中加载的位置不同：

属性：加载到堆空间中（非static）

局部变量：加载到栈空间中

方法的调用机制

1、当程序执行到方法时，就会开辟一个独立的空间（栈空间）

2、当方法执行完毕，或者执行到return语句时，就会返回

3、返回到调用方法的地方

4、返回后，继续执行方法后面的代码

5、当main方法（栈）执行完毕，整个程序退出

同一个类中可以直接调用

跨类调用方法，要先创建对象

方法返回多个结果，用数组

方法的使用中的注意事项：

1、方法的使用中，可以调用当前类的属性或方法，特殊的：方法A中又调用了方法A 就是递归方法。

2、方法中不能定义方法。

构造器的定义格式

public calss Car{

​ //无参数构造器

​ public Car(){

​ ......

​ }

​ public Car(String n, String b){

​ ....

​ }

}

初始化对象的格式

类型 变量名称=new 构造器：

Car c = new Car();

this关键字

作用：出现在成员方法 、构造器中代表当前对象的地址，用于访问当前对象的成员变量、成员方法

关键字this指示隐式参数

面向对象的三大特征：封装，继承，多态

封装 （合理隐藏合理暴露）

一般会把成员变量使用private隐藏起来

通过getter 和setter 方法暴露其访问

封装加强了程序代码的安全性

标准javaBean

也可以理解成实体类，其对象可以用于在程序中封装数据

javaBean成员变量使用private修饰

提供每一个成员变量对应的setXxx() / getXxxx()。

必须提供一个无参构造器。

String类

字符串类型，可以定义字符串变量指向字符串对象

创建字符串对象的两种方式

String name="张三";

String类的特点详解

String其实常被称为不可变字符串类型，它的对象在创建后不能被更改

String name="李四";

方法区，栈内存，堆内存

##ArrayList集合

集合的特点：

集合的大小不固定，启动后可以动态变化，类型也可以选择不固定

集合非常适合做元素个数不确定，且要进行增删操作的业务场景

集合提供了许多丰富、好用的功能，而数组的功能很单一；

数组和集合适合的场景：

数组适合做数据个数和类型确定的场景

集合适合做数据个数不确定，且要做增删元素的场景

集合中存储的元素并不是对象本身，而是对象的地址

创建对象时，对象会被存放在堆内存中

继承：继承已存在的类所拥有的成员而生成新的类

封装：在类所拥有的成员中，隐藏掉那些没有必要展现给该类拥有这的成员

多态：针对同一种消息，不同的对象可以进行不同的操作。

#01局部变量

在方法体内声明的变量被称为局部变量，该变量只能在该方法内使用，类中的其他方法并不知道该变量。

public class LocalVariable{
  public static void main(String[] args){
    int a = 10;
    int b = 10;
    int c = a + b;
    System.out.println(c);
  }
}

其中a、b、c就是局部变量，它们只能在当前这个main方法中使用。

声明局部变量时的注意事项：

1、局部变量声明在方法、构造器或者语句块中。

2、局部变量在方法、构造方法、或者语句块中被执行的时候创建，当它们执行完成后，将会被销毁。

3、访问修饰符不能用于局部变量。

4、局部变量只在声明在它的方法、构造方法或者语句块中可见。

5、局部变量是在栈上分配的。

6、局部变量没有默认值，所以局部变量被声明后，必须经过初始化，才可以使用。

#02 成员变量

在类内部但在方法体外声明的变量称为成员变量， 或者实例变量。之所以称为实例变量，是因为该变量只能通过类的实例（对象）来访问。

public class InstanceVariable{
  int data = 88;
  public static void main(String[] args){
    InstanceVariable iv = new InstanceVariable;
    System.out.println(iv.data);//88
  }
}

其中iv是一个变量，它是一个引用类型的变量，new关键字可以创建一个类的实例（也称为对象），通过“=”操作符赋值给iv这个变量，iv就成了这个对象的引用，通过iv.data就可以访问成员变量了。

声明成员变量时的注意事项：

1、成员变量声明在一个类中，但在方法、构造方法和语句块之外。

2、当一个对象呗实例化之后，每个成员变量的值就跟着确定。

3、成员变量在对象创建的时候创建，在对象被销毁的时候销毁。

4、成员变量的值应该至少被一个方法、构造方法或者语句块引用，使得外部能够通过这些方式获取实例变量信息。

5、成员变量可以声明在使用前或者使用后。

6、访问修饰符可以修饰成员变量。

7、成员变量对于类中的方法、构造方法或者语句块是可见的。一般情况下应该把成员变量设为私有。通过使用访问修饰符可以使成员变量对子类可见；成员变量具有默认值。数值型变量的默认值是0，布尔型变量的默认值是false，引用类型变量的默认值是null。变量的值可以在声明时指定，也可以在构造方法中指定。

#03 静态变量

通过static关键字声明的变量被称为静态变量（类变量），它可以直接被类访问。

public class StaticVariable{
  static int data = 99;
  public static void main(String[] args){
    System.out.println(StaticVariable.data);//99
  }
}

其中data就是静态变量，通过类名.静态变量就可以访问，不需要创建类的实例。

声明静态变量时的注意事项：

1、静态变量在类中以static关键字声明，但必须在方法、构造方法和语句块之外。

2、无论一个类创建了多少个对象，类只拥有静态变量的一份拷贝。

3、静态变量除了被声明为常量外很少使用。

4、静态变量储存在静态存储区。

5、静态变量在程序开始时创建，在程序结束时销毁。

6、与成员变量具有相似的可见性，但为了对类的使用者可见，大多数静态变量声明为public类型。

7、静态变量的默认值和实例变量相似。

8、静态变量还可以在静态语句块中初始化。

#04 常量

在 Java 中，有些数据的值是不会发生改变的，这些数据被叫做常量——使用 final 关键字修饰的成员变量。常量的值一旦给定就无法改变！

常量在程序运行过程中主要有 2 个作用：

1、代表常数，便于修改（例如：圆周率的值，final double PI = 3.14）

2、增强程序的可读性（例如：常量 UP、DOWN 用来代表上和下，final int UP = 0）

3、Java 要求常量名必须大写。来看下面这个示例：

值传递和引用赋值的区别

jvm内存

栈：

堆：

方法区：

值传递：值拷贝

引用传递：地址拷贝

冒泡排序

通过对 待排序序列从后向前（从下标较大的元素开始），一次比较相邻元素的值，若发现逆序则交换，使值较大的元素逐渐从前移向后面。

{24, 69, 80, 57, 13}

一共是arr.length-1次排序 排序趟数 1 2 3 4

每次比较arr.length - 1 - i次 比较次数 4 3 2 1

双重循环

for(i = 0; i > arr.length-1;i++){ //排序趟数

​ for(j = 0; j > arr.length-1-i;j++){//比较次数

​ if(arr[j] >arr[j+1]){

​ int temp = arr[j];

​ arr[j] = arr[j+1];

​ arr[j+1] = temp;

​ }

​ }

}

查找

顺序查找

二分查找

首先，假设表中元素是按升序排列，将表中间位置记录的关键字与查找关键字比较，如果两者相等，则查找成功；否则利用中间位置记录将表分成前、后两个子表，如果中间位置记录的关键字大于查找关键字，则进一步查找前一子表，否则进一步查找后一子表。重复以上过程，直到找到满足条件的记录，使查找成功，或直到子表不存在为止，此时查找不成功。

二维数组

二维数组内存分布

继承

通过拓展一个类来建立另外一个类的过程称为继承（inheritance）。

类之间的关系

依赖（“uses-a”) ：如果一个类的方法使用或操纵另一个类的对象，我们就说一个类依赖于另一个类。

应该尽可能的将相互依赖的类减少，减少类之间的耦合。

聚合("has-a")：一个Oder对象包含一些Item对象，包容关系意味着类A的对象包含类B的对象

继承("is-a")：表示一个更特殊的类与一个更一般的类之间的关系。一般而言，如果类A拓展类B，类A

不但包含从类B继承的方法，还会有一些额外的功能。

构造器

构造器与类同名

每个类可以有一个以上的构造器

构造器可以有0个，1个或多个参数

构造器没 有返回值

构造器总是伴随着new操作符一起调用

final关键字

修饰方法、变量、类

修饰方法 ：表明该方法是最终方法，不能被重写

修饰变量：表示该变量第一次赋值后，不能再次被赋值（有且仅能被赋值一次）。

修饰类：表明该类是最终类，不能被继承

变量分为：局部变量和成员变量

成员变量包括：静态成员变量和实例成员变量

一般不用finale关键字修饰实例成员变量

final修饰变量注意事项：

final修饰的变量是基本类型，那么变量存储的数据值不能发生改变。

final修饰的变量是引用类型，那么变量存储的地址值不能发生改变，但是地址指向的对象内容是可以发生变化的

static静态关键字

static可以修饰成员变量和成员方法

public static int ...

访问：类名.静态成员变量 或 对象.静态成员变量

表示该成员变量只在内存中只存储一份，可以被共享访问、修改。

静态成员方法：(有static)

访问：类名.静态成员方法

实例方法：属于对象的，只能对象触发访问(无static)

访问：对象.实例方法

使用场景：

表示对象自己的行为，且方法中需要访问实例成员的，则该方法必须申明成实例方法。

如果该方法是以执行一个公用功能为目的，则可以申明成静态方法。

static的注意事项：

静态方法只能访问静态的成员，不可用直接访问实例成员（成员包括变量和方法）

实例方法可以访问静态的成员，也可以访问实例成员

静态方法中是不可以出现this关键字。

工具类定义是的其他要求

工具类内部都是静态方法，每个方法完成一个功能

一次编写，处处可用，提高代码的重用性

由于工具类里面都是静态方法，直接用类名即可访问，因此，工具类无需创建对象，建议将工具类的构造器进行私有。

代码块

代码块是只有方法体的方法，而且不能通过对象或类显示调用，而是加载类时，或创建对象时隐式调用。。

代码块分为：

静态代码块

格式：static{}

特点：需要通过static关键字修饰，随着类的加载而加载，并且自动触发

作用：如果要在启动系统是对静态资源进行初始化，则建议使用静态代码块完成数据的初始化操作。

实例代码块（少用）

没有static关键字修饰

• 类实例化的时候执行代码初始化块；

• 实际上，代码初始化块是放在构造方法中执行的，只不过比较靠前；

• 代码初始化块里的执行顺序是从前到后的。

单例模式

可用保证系统中，应用该模式的这个类永远只有一个实例，即一个类永远只能创建一个对象。

例如任务管理器对象，我们只需要一个就可以解决问题了，这样可用节省内存空间。

单例的实现方式：

饿汉单例设计模式：在用类获取对象的时候，对象已经提前为你创建好了

设计步骤：定义一个类，把构造器私有；定义一个静态变量储存一个对象

懒汉单例设计模式：特点：要拿对象的时候才开始创建一个对象

设计步骤：构造器私有，定义一个静态成员变量，暂时不存对象，提供一个方法，对外返回单例对象

#重载中可变参数使用

public int sum(int ... nums){

}

public String showScore(Sting name, double... score){

}

继承

定义子类

public class Manager extends Employee{

​ added methods and fields

}

Employee 已存在的类，称为超类（superclass)（也称为基类(base class)或父类(parent class)）

Manager 新类 称为子类(subclass)、派生类(derived class)或孩子类(child class)

覆盖方法（override）

double baseSalary = super.getSalary;

继承的特点

1、子类可以继承父类的属性和行为，但是子类不能继承父类的构造器

2、java是单继承模式：一个类只能继承一个直接父类。

3、java不支持多继承，但是支撑多层继承。

4、java中所有的类都是Object类的子类。

子类是否可以继承父类的私有成员？

可以，只是不能直接访问

子类是否可以继承父类的静态成员？

不算继承，只是共享。（你爸的车可以给你开，但是车还是你爸的）

在子类方法中访问成员（成员变量、成员方法）满足：就近原则

先子类局部范围找

然后子类成员范围找

然后父类成员范围找，如果父类范围还没有找到则报错

如果遇到子父类中，出现了重名的成员，会优先使用子类的，此时如果一定要在子类中使用父类

可以通过super关键字，指定访问父类的成员。

指定子类用this关键字。

继承后，方法重写 覆盖方法（override）

什么是方法重写？

在继承体系中，子类出现和父类中一模一样的方法声明，我们就称子类这个方法是重写的方法。

简单的说：方法重写就是子类有一个方法，和父类的某个方法的名称、返回类型、参数一样，那么我们就是子类的这个方法重写了父类的那个方法。

子类的方法的参数、方法名称要和父类方法的参数、方法名称完全一样。子类方法的返回类型和父类返回类型一样或者是父类返回类型是object 子类是String...（兼容）（可以写父类一样的或者父类的子类。）

子类方法不能缩小父类方法的访问权限。

方法重写的应用场景

当子类需要父类的功能，但父类的该功能又不能完全满足自己的需求时。

子类可以重写父类中的方法。

方法重写注意事项和要求：

加上注解 @override注解可以校验重写是否正确，同时可读性好。

重写方法的名称、形参列表必须与被重写方法的名称和参数列表一致。

私有的方法不能被重写

子类重写父类方法时，访问权限必须大于或者等于父类。

子类不能重写父类的静态方法，如果重写会报错。

继承后子类构造器的特点

子类的全部构造器默认会先访问父类的无参数构造器再访问自己的

为什么？

子类在初始化的时候，有可能会使用到父类中的数据，如果父类没有完成初始化，子类将无法使用父类的数据。

子类初始化之前，一定要调用父类构造器先完成父类数据空间的初始化。

super调用父类有参数构造器的作用

初始化继承自父类的数据

super（name,age)；

如果父类中没有无参数构造器，只有有有参构造器，会出现什么现象呢？

会报错，因为子类默认是调用父类无参构造器的

如何解决：子类构造器中可以通过书写super(...)，手动调用父类的有参数构造器。

this、super使用总结

this访问子类当前对象的成员

super：在子类方法中指定访问父类的成员。

this（...）:访问本类兄弟构造器

super(...):在本类构造器中指定访问父类的构造器

注意事项：super(...)、this(....)必须放在第一行，两者不能同时存在于一个构造器中

导包

相同包下的类可以直接访问，不同包下的类必须导包才可以使用。导包格式：import 包名.类名;

假如一个类中需要用到不同的类，而这两个类的名称是一样的，那么 默认只能导入一个类，另一个类要带包访问。

权限修饰符

权限修饰符是用来控制一个成员能够被访问的范围的。

可以修饰成员变量，方法，构造器，内部类，不同权限修饰符修饰的成员能够被访问的范围将受到限制。

private -> 缺省 -> protected -> public 作用范围由小到大

自己定义成员（方法、成员变量、构造器）一般满足如下要求：

成员变量一般私有

方法一般公开

如果该成员只希望本类访问，使用private修饰。

如果该成员只希望本类，同一个包下的其他类和子类访问，使用protected修饰

常量

常量是使用了public static final 修饰的成员变量，必须有初始值，而且执行的过程中其值不能被改变。

常量的作用和好处：可以用于做系统的配置信息，方便程序的维护，同时也能提高可读性。

常量命名规范：英文单词全部大写，多个单词下划线连接起来。

类似于C中的宏定义。

选择常量做信息标致和分类

枚举

枚举是java中的一种特殊类型

枚举的作用是：为了做信息的标志和信息的分类

定义枚举类的格式：

修饰符 enum 枚举名称{

​ 第一行都是罗列枚举类实例的名称。

}

public enum Season{

​ SPRING,SUMMER,AUTUMN,WINTER;

}

枚举的特征：

枚举类都是继承了枚举类型：java.lang.Enum；

枚举都是最终类(final)，不可以被继承；

构造器的构造器都是私有的，枚举对外不能创建对象；

枚举类的第一行默认都是罗列枚举对象的名称；

枚举类相当于是多例模式。

javap Hello.反编译

抽象类

某个父类知道其所有子类要完成某功能，但是每个子类完成情况都不一样，父类就只定义该功能的基本要求，具体实现有子类完成，这个类就可以是一个抽象类，抽象类其实就是一种不完全的设计图。

抽象类必须使用abstract修饰：

修饰符 abstract class 类名 {}

抽象方法：

就是抽象类中定义的子类必须完成的功能的基本要求。

修饰符 abstract 返回值类型 方法名称(形参列表)

没有方法体，只有方法签名，必须abstract修饰

抽象类用来被继承的，抽象方法时交给子类重写实现的。

一个类如果继承了抽象类，那么这个类必须重写完抽象类的全部抽象方法，

否则这个类也必须定义成抽象类。

抽象类不能创建对象

final 和 abstract 是什么关系？

互斥关系；

abstract定义的抽象类作为模板让子类继承，final定义的类不能被继承；

抽象方法定义通用功能让子类重写，final定义的方法子类不能重写。

抽象类应用：模板方法模式

使用场景说明：当系统中出现同一个功能多处在开发，而该功能中大部分代码是一样的，只有其中部分可能不同的时候。

实现步骤：

把功能定义成一个所谓的模板方法，放在抽象类中，模板方法中只定义通用且能确定的代码。

模板方法中不能决定的功能定义成抽象方法让具体子类去实现。

模板方法建议用final修饰

接口

接口概述：接口就是体现规范的，其中用抽象方法定义的一组行为规范，接口是更加彻底的抽象。

1）接口中定义的变量会在编译的时候自动加上 public static final 修饰符。

2）没有使用 private、default 或者 static 关键字修饰的方法是隐式抽象的，在编译的时候会自动加上 public abstract 修饰符。

3）从 Java 8 开始，接口中允许有静态方法。静态方法无法由（实现了该接口的）类的对象调用，它只能通过接口名来调用。接口中定义静态方法的目的是为了提供一种简单的机制，使我们不必创建对象就能调用方法，从而提高接口的竞争力。

• 接口中允许定义变量

• 接口中允许定义抽象方法

• 接口中允许定义静态方法（Java 8 之后）

• 接口中允许定义默认方法（Java 8 之后）

接口的格式如下(JDK8之前接口中只能是抽象方法和常量，没有其他成分)：

public interface 接口名{

​ //常量

​ //抽象方法

}

接口不能实例化（接口不能创建对象）

接口的用法：

接口是用来被类实现（implements）的，实现接口的类称为实现类。实现类可以理解成所谓的子类。

修饰符 class 实现类 implements 接口1，接口2，接口3,....{

}

实现的关键字：implements

接口可以被类单实现，也可以被类多实现。

抽象类去实现接口时，可以不用实现接口的方法。

接口不能继承其它类，但是可以继承多个别的接口。

接口实现的注意事项：

一个类实现接口，必须重写完全部接口的全部抽象方法，否则这个类需要定义成抽象类。

接口与接口的关系：多继承，一个接口可以同时继承多个接口

#面向对象

1、Java面向对象学习的三条主线：

1、Java类及类的成员：属性、方法、构造器；代码块，内部类

2、面向对象的三大特征：封装、继承、多态

3、其他关键字：this、super、static、final、abstract、interface、package、import等

2、面向对象与面向过程（理解）

面向过程：强调的是功能行为，以函数为最小单位，考虑怎么做；

面向对象：强调具备了功能的对象，以类/对象为最小单位，考虑谁来做。

理解“万事万物皆对象”：

1、在Java语言范畴中，我们都将功能、结构等封装到类中，通过类的实例化，来调用具体的功能结构。

2、涉及到Java语言与前端Html、后端的数据库交互时，前后端的结构在Java层面交互时，都体现为类、对象。

方法重载

1、定义：在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。

2、判断是否重载：

​ 跟方法的权限修饰符、返回值类型、形参变量名、方法体都没有关系。

3、在通过对象调用方法时，如何确定某一个指定的方法

​ 方法名 -----> 参数列表

方法参数的值传递机制

Java里方法的参数传递方式只有一种：值传递。

关于变量的赋值：

如果变量是基本数据类型，此时赋值的是变量所保存的数据值。

如果变量是引用数据类型，此时赋值的是变量所保存的数据的地址值。

方法的形参的传递机制：

1、 形参：方法定义时，声明在小括号内的参数。

​ 实参：方法调用时，实际传递给形参的数据。

2、值传递机制：

​ 如果参数是基本数据类型，此时实参赋给形参的是实参真实存储的数据值

​ 如果参数是引用数据类型，此时实参赋给形参的是实参存储数据的地址值

多态

对象的多态：

1、一个对象的编译类型和运行类型可以不一致

2、编译类型在定义对象时，就确定了不能改变

3、运行类型是可以变化的

4、编译类型看定义时 = 的左边，运行类型看 = 的右边。

向上转型：父类的引用指向了子类的对象

语法：父类类型引用名 = new 子类类型();

Animal animal = new Cat();

编译类型看左边，运行类型看右边。

可以调用父类中所有成员（需遵守访问权限）；

但是不能调用子类的特有成员，因为在编译阶段，能调用哪些成员，是由编译类型来决定的；

最终运行效果看子类（运行类型）的具体实现,即调用方法时，按照从子类（运行类型）开始查找（就近原则，向上查找），然后调用。

向下转型：把指向子类对象的父类引用，转成指向子类对象的子类引用

1、语法：子类类型 引用名 = (子类类型) 父类引用；

Animal animal = new Cat();//父类的引用指向的是Cat
Cat cat = (Cat) animal;
//Dog dog = (Dog) animal; 错误，因为原先animal指向的是Cat
//ClasCastException
//So：要求父类的引用必须指向的是当前目标类型的对象 

2、只能强转父类的引用，不能强转父类的对象

3、要求父类的引用必须指向的是当前目标类型的对象

4、当向下转型后，可以调用子类类型中所有的成员

属性的值看编译类型,方法看运行类型

Public class PolyDetail{
  Base base = new Sub();//向上转型
  System.out.println(base.count);//结果是：10，说明属性的值看编译类型（=左边）
}
​
class Base{//父类
  int count = 10;//属性
} 
class Sub extends Base{//子类
  int count = 20;//属性
}

instanceOf比较操作符:

用于判断对象的类型是否为XX类型或XX类型的子类型。判断的是对象运行类型（=右边）

System.out.println(Sub instanceOf Base); //true Sbu是Base的子类型。

Java的动态绑定机制

1、当调用对象方法的时候，该方法会和该对象的内存地址/运行类型(=右边)绑定；

2、当调用对象属性时，没有动态绑定机制，哪里声明，哪里使用。

#==与equals的对比

== 是一个比较运算符

1、== ：既可以判断基本类型，又可以判断引用类型

2、==：如果判断基本类型，判断的是值是否相等

int i = 10;
double d = 10.0;

3、==：如果判断引用类型，判断的是地址是否相等，即判定是不是同一个对象。

equals方法

是Object类中的方法，只能判断引用类型

默认判断的是地址是否相等，子类往往重写该方法，用于判断内容是否相等，（比如Integer、String）。

hashCode

返回该对象的哈希码值。

1、提高具有哈希结构的容器的效率

2、两个引用，如果指向的是同一个对象，则哈希值是一样的

3、两个引用，如果指向的不是同一个对象，则哈希值是不一样的

4、哈希值主要根据地址号来的，不能完全将哈希值等价于地址。

toString

返回该对象的字符串显示。

默认返回：全类名（包名+类名）+@+哈希值的十六进制

子类往往重写toString方法，用于返回对象的属性信息。

finalize（了解）

可以通过重写释放资源：数据库连接或者打开文件.....

理解main方法语法

public static void main(String[] args){}

1、main方法是虚拟机调用

2、java虚拟机需要调用类的main()方法，所以该方法的访问权限必须是public

3、java虚拟机在执行main()方法时不必创建对象，所以该方法必须是static

4、该方法接收String类型的数组参数，该数组中保存执行java命令时传递给所运行的类的类型。

#内部类

内部类的分类

1、定义在外部类局部位置上（比如方法内）：

1）局部内部类（有类名）

2）匿名内部类（没有类名）

2、定义在外部类的成员位置（属性、方法位置）上：

1）成员内部类（没有static修饰）

2）静态内部类（使用static修饰）

局部内部类：

/**
 * 1、局部内部类时定义在外部类的局部位置，通常在方法中
 * 2、可以直接访问外部类的所有成员(属性、方法等等)，包含私有
 * 3、局部内部类不能添加访问修饰符，但是可以使用final修饰
 * 4、作用域：仅仅在定义它的方法或代码块中
 * 5、局部内部类可以直接访问外部类的成员
 * 6、外部类在方法中可以创建Inner01对象，然后调用方法。（代码位置code05.LocalInnerClass）
 * 7、外部其他类不能访问局部内部类（因为局部内部类地位是一个局部变量）
 * 8、如果外部类和局部内部类的成员重名时，默认遵循就近原则，如果想访问外部类的成员，则可以使  *  用（外部类名.this.成员）去访问
 */

#反射

反射过程：

1、获取反射类的Class对象

Class clazz = Class.forName("....");

2、通过Class对象获取构造方法Constructor对象

Constructor constructor = clazz.getConstructor();

3、通过Constructor对象初始化反射类对象

Object object = constructor.newInstance();

4、获取要调用的方法的Method对象：

Method setNameMethod = clazz.getMethod("setName",String.class);
Method getNameMethod = clazz.getMethod("getName");

5、通过invoke()方法执行：

setNameMethod.invoke(object,"...");
getNameMethod.invoke(object);