• Java是一种跨平台性的语言，满足一次编译，到处运行的语言（Java语言的运行依赖于JVM，不同的操作系统有不同的JVM）
• Java是一种面向对象的编程语言
• Java有一个很大的优势在于有自动回收垃圾的机制
• Java语言是健壮的。Java的强类型机制、异常处理、垃圾的自动收集等是Java程序健壮性的重要保证。

• Java程序的运行过程

• 层次关系

• JVM

  1. JVM是一个具有指令集并使用不同的存储区域。负责执行指令，管理数据，内存，寄存器。
  2. 对于不同的平台有不同的虚拟机，平台提供了对应的虚拟机才能运行
  3. 因为JVM的存在，实现了"一次编译，到处运行"

• GC

  1. 自动监测对象是否超过作用域（可达性分析和引用计数）
  2. 将不再使用的内存空间进行回收
  3. 但是Java程序任然会存在内存泄露和内存溢出问题

在cmd中可以在任何地方调用JDK指令

• cmd种常用指令：

dir : 列出当前目录下的文件以及文件夹
md : 创建目录
rd : 删除目录
cd : 进入指定目录
cd.. : 退回到上一级目录
cd\: 退回到根目录
del : 删除文件
exit : 退出 dos 命令行

JDK是Java开发工具包     （JDK=JRE+开发工具包）
JRE是Java运行环境       （JRE=JVM+Java标准类库）
JVM是Java虚拟机

被Java语言赋予了特殊含义，用做专门用途的字符串（单词）。

• Java中有很多关键字，保留字是指以后的版本可能会用到（goto和const）
• 在Java中变量的名字不能关键字或者保留字

1. 结束方法
2. 针对于有返回值类型的方法，使用"return 数据"方法返回所要的数据。

克隆分为深克隆浅克隆，

Animal a2 = (Animal) a1.clone();

Java是一种强类型语言

强类型语言：每一种数据都定义了明确的具体数据类型，在内存中分配了不同大小的内存空间.比如int a=10;编译前就为a分配了4个字节
弱类型语言：是指是在编译后确定数据类型，没有明显的类型，随着环境的不同，自动变换类型。比如：var a=10;编译前无法确定它的类型。

变量按作用范围可分为成员变量和局部变量

• 成员变量： 在方法体外，类体内声明的变量
  1. 实例变量（不以static修饰的）
  2. 类变量（以static修饰的）
• 局部变量： 在方法体内部声明的变量
  1. 形参（方法、构造器中定义的变量）
  2. 方法内、代码块内定义的局部变量

Java的数据类型一共有两种。一种是基本类型，另一种是引用类型。

类（class）、接口（Interface）、数组（Array）

注意：字符串在类里面

byte、short、int（默认）、long、float、double（默认）、char、boolean

说明：float和double是怎么计算的 float、double和其它类型的计算方式是不一样的，float和double是采取科学计数法来进行计算的

float和double的范围是由指数的位数来决定的。其中float的指数位有8位，而double的指数位有11位。

举例：

0  01111100  01000000000000000000000==0.15625
+ 124-127     1.25         1.25*2^-3=0.15625
符号位：0代表正1代表负   
指数位：是一个无符号位存在一个偏移量127，计算出的结果需要与127做差
尾数位：尾数位占23个bit，它的表达上有一个特殊点，它被认为是24个bit，第一个bit取值1，且被隐藏掉：有了这个前提，我们就比较好理解尾数的表达了：这24个bit，依次表达2^0， 2^-1, 2^-2, 2^-23，隐藏的第一位表达的指就是1。所以：尾数位全0时表达的值是1，全1时表达的最大值2 - 2^-23。

注意：

• Java中char的范围和c语言中char的范围有区别Java中char占用两个字节，范围是0–65535。
• 1byte=8bit；
• long a=12; float b=12;这两种情况不会报错，是因为自动提升的原因
• byte,short,char之间不会相互转换，他们三者在计算时首先转换为int类型。所以有byte、short、char的混合运算时结果都为int类型

基本类型中容量小的和容量大的一起运算时，会发生自动提升现象 注意：float的范围比long的还要大。是因为它们底层的存储结构不同。float/double使用科学计数法来存储，而long使用普通的二进制来存储，也就是说一个存的是多少次方，而一个是只有多少位。

是指在大容量向小容量转换时发生的，在强制转换时会有精度损失

注意：类型转换都是基本类型之间的，String不能和基本类型之间进行转换，但是包装类可以和String进行转换。如： String a = “43”; int i = Integer.parseInt(a);

• 算术运算：+ - * /
• 赋值运算：

short s=2;
s=s+2;//编译不通过，类型不一致
s+=2;//编译通过，运算时不会改变类型

• 比较运算 instanceof

 System.out.println("hello" instanceof String);//true

• 逻辑运算

&：逻辑与
&&：短路与
|：逻辑或
||：短路或
^：异或。相同为0不同为1
!：非

• 位运算

<<左移，相当于*2
>>右移，相当于/2
&与运算，都1为1
|或运算，有1为1
^异或运算  110^011=101==>5
~取反运算  ~6=7  (补码)0110<==>(补码)1001==>0111(源码)==>7

• 三目运算符 要求 " ："前后两种数据类型要一致 举个栗子：

//如果a<60,将a的值置为0。
int a=a>60?a:0;

• 运算符优先级

数组是一种按照一定顺序排列，且能存储相同数据类型的集合。但是需要占用连续空间数据结构。 需要注意的是：

• 长度一旦确定，就不能再进行修改。
• 数组的索引是从0开始的而数据库库的索引是1开始的，在连接数据库时需要注意。

就是两个一维数组组成的数组栈中的引用指向堆，堆中存的也是一个引用

1. 数组元素的赋值(杨辉三角、回形数等)
2. 求数值型数组中元素的最大值、最小值、平均数、总和等
3. 数组的复制、反转、查找(线性查找、二分法查找)
4. 数组元素的排序算法（稳定性）A和B相等排序后，A和B的次序不变（应用：商品首先根据销量排序，再根据价格排序，就需要排序的稳定性）

     	int [] arr=new int[] { 
         1,2,3,4,5};
		System.out.println(arr);//[I@32a1bec0
		char [] arr1=new char[] { 
         'a','b'};
		System.out.println(arr1);//ab

出现这种现象是因为重载。（将char型print和int型print进行重载）

在Java中将功能结构封装在类中，通过类的实例化来调用具体功能结构

主流编程语言要么是面向过程（强调考虑怎么做），要么是面向对象（强调谁来做）。程序员从面向过程的执行者转化成了面向对象的指挥者

注意：int 不是对象，因为一般情况下创建对象需要进行new。将int转换为包装类后即是对象。

举个栗子：把大象装进并冰箱

面向对象的两个要素：类和对象

类：是指对一类事物的概括，是抽象的、概念上的定义。类的成员包括属性和方法 对象：是指存在的一个真实个体，因而也称为实例(instance)。对象可以调用类的非私有成员。创建类的对象 = 类的实例化 = 实例化类 可以理解为：类 = 抽象概念的人；对象 = 实实在在的某个人 对象一般通过new来创建。类名 对象名 = new 类名();

不定义对象的句柄，而直接调用这个对象的方法。这样的对象叫做匿名对象。

    new A().show();

注意：匿名对象主要使用在只需要进行一次方法调用

属性 = 成员变量 = field = 域、字段 使用形式： 修饰符 数据类型 属性名 = 初始化值 ;

• private int age; //声明private变量 age

变量的分类：成员变量（属性，存在于方法体外部）与局部变量（存在于方法体内部） Java中的变量都是先声明后使用，并且作用于自己的作用域

方法 = 成员方法 = 函数 = method

方法是类或对象行为特征的抽象，用来完成某个功能操作。

方法的分类：按照是否有形参及返回值。

• 重载：参数个数或者参数型不同的同名方法。与返回值类型无关，只看参数列表，且参数列表必须不同。(参数个数或参数类型)。调用时，根据方法参数列表的不同来区别。

举个例子：

    //返回两个整数的和
    int add(int x,int y){ 
         return x+y;}
    //返回三个整数的和
    int add(int x,int y,int z){ 
         return x+y+z;}
    //返回两个小数的和
    double add(double x,double y){ 
         return x+y;}

• 重写：同一个方法子类对父类方法功能的改变

public class A { 
         
    public void show() { 
          System.out.println("ok"); }
}
class B  extends A{ 
         
    @Override
    public void show() { 
          System.out.println("no ok"); }
}

Java只有值传递

• 当传递类型是基本类型时，传递的就是参数真实的值，在方法中对值进行修改，不影响本身的值
• 当传递类型时引用类型时，传递的就是地址的值，在方法中进行修改数据时，会影响本身的值

不是说只要传递的参数是引用类型的就会修改数据的值，他的大前提是传递前后两个引用指向的是同一块内存。

举个栗子：

String s="hello";
Test test=new Test();
test.change(s);
// change(String s1){ 
         
// s1="hi";
// }

System.out.println(s); 

一个方法体内调用它自身，注意在递归时要注意弹出时，否则会导致跳不出循环，导致栈溢出

//计算1-100之间所有自然数的和
public int sum(int num){ 
         
if(num == 1){ 
         
return 1;
}else{ 
         
return num + sum(num - 1);
} }

构造器的作用：创建对象；给对象进行初始化 构造器：默认构造器、非默认构造器

注意：

• 多个构造器之间构成重载关系
• 父类的构造器不可被子类继承

• 有一个无参的公共的构造器
• 有属性，且有对应的get、set方法

public class JavaBean { 
         
private String name; // 属性一般定义为private
private int age;
public JavaBean() { 
         
}
public int getAge() { 
         return age; }
public void setAge(int age) { 
         this.age = age; }
public String getName() { 
         return name; }
public void setName(String n) { 
         name = n; } }

this可以用来修饰、调用：属性、方法、构造器们可以理解为当前对象。 在类的方法中，我们可以使用"this.属性"或"this.方法"的方式，调用当前对象属性或方法。但是，通常情况下，我们都选择省略"this."。特殊情况下，如果方法的形参和类的属性同名时，我们必须显式的使用"this.变量"的方式，表明此变量是属性，而非形参。

注意： 在类的构造器中，可以使用this()调用本类的其他构造器，在用this进行调用构造器时必须放在第一行

//boy类的marry方法
marry(Girl girl){ 
         
       System.out.println("I Love girlA");
}

//girl类的marry方法
marry(Boy boy){ 
         
       System.out.println("I Love boyA");
       boy.marry(this);//谁调用marry，this就是谁。boyA回应 I Love girlA
}

• 我们可以用this来区分属性和局部变量。

this.name = name;

super和this的用法相像，this代表本类对象的引用，super代表父类的内存空间的标识

• 封装：隐藏对象内部的复杂性，只对外公开简单的接口。便于外界调用，从而提高系统的可扩展性、可维护性。通俗的说，把该隐藏的隐藏起来，该暴露的暴露出来。
• 继承：一个子类继承一个父类，能够直接调用父类的非私有属性和方法，通过set、get也能访问私有属性。
• 多态:分为运行时多态（overload）和编译时多态（override），多态的三个必要条件 ：1.要有继承(实现implements) 2.要有重写(overWrite&overRide) 3.父类引用指向子类对象

将方法和属性进行私有化，对实现细节进行隐藏，只暴露出供外界使用的接口。使用者只能通过事先定制好的方法来访问数据，可以方便地加入控制逻辑，限制对属性的不合理操作

封装的体现：Java中通过将数据声明为私有的(private)，再提供公共的（public）方法:getXxx()和setXxx()实现对该属性的操作

注意：对于class的权限修饰只可以用public和default

多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承那个类即可。因为有了继承就可以省略掉很多冗余的代码。

1. 一旦子类A继承父类B以后，子类A中就获取了父类B中声明的所有的属性和方法。特别的，父类中声明为private的属性或方法，子类继承父类以后，仍然认为获取了父类中私有的结构。只有因为封装性的影响，使得子类不能直接调用父类的结构而已。
2. 子类继承父类以后，还可以声明自己特有的属性或方法：实现功能的拓展。子类和父类的关系，不同于子集和集合的关系。

• Java是单根继承，一个子类只能继承(extends)一个类。但是可以实现很多个接口
• 子类继承了父类，可以直接使用父类的非私有的方法和属性。
• 在子类中，可以使用父类中定义的方法和属性，也可以创建新的数据和方法。
• 在Java 中，继承的关键字用的是“extends”，即子类不是父类的子集，而是对父类的“扩展”。

说明：所有的子类都会直接或间接继承Object类

• 父类的引用指向子类的对象（或子类的对象赋给父类的引用）
• 多态性的使用前提： ① 类的继承关系 ② 方法的重写
• 分为运行时多态（overload）和编译时多态（override）。编译时，看左边；运行时，看右边

System.out.println()方法就是典型的重载方法，其内部的声明形式如下：

public void println(byte x)
public void println(short x)
public void println(int x)
public void println(long x)
public void println(float x)
public void println(double x)
public void println(char x)
public void println(double x)
public void println()

//这2个方法不能构成重载，会有编译错误。
public int A(int i);
public double A(int i);
//这2个方法可以形成重载
public int A(int i)；
public double A(double i);

注意：子类与父类中同名同参数的方法必须同时声明为非static的(即为重写)，或者同时声明为static的（不是重写）。因为static方法是属于类的，子类无法覆盖父类的方法。

Java对象的强制转换：

• 从子类到父类的类型转换可以自动进行
• 从父类到子类的类型转换必须通过造型(强制类型转换)实现
• 无继承关系的引用类型间的转换是非法的
• 在造型前可以使用instanceof操作符测试一个对象的类型

public class Test { 
         
public void method(Person e) { 
          // 设Person类中没有getschool() 方法
// System.out.pritnln(e.getschool()); //非法,编译时错误
if (e instanceof Student) { 
         
Student me = (Student) e; // 将e强制转换为Student类型
System.out.pritnln(me.getschool());
} }
public static void main(String[] args){ 
         
Test t = new Test();
Student m = new Student();
t.method(m);
} }

• == 既可以比较基本类型也可以比较引用类型。对于基本类型就是比较值，对于引用类型就是比较内存地址
• equals没有被重写过默认也是==，但是进行重写(重写的原则：比较两个对象的实体内容是否相同)，重写后会比较类中的相应属性是否都相等。

1. 是一个方法，而非运算符
2. 只能适用于引用数据类型
3. Object类中equals()的定义：

public boolean equals(Object obj) { 
         
	        return (this == obj);
	  }

说明：Object类中定义的equals()和==的作用是相同的：比较两个对象的地址值是否相同.即两个引用是否指向同一个对象实体

4. 像String、Date、File、包装类等都重写了Object类中的equals()方法。重写以后，比较的不是两个引用的地址是否相同，而是比较两个对象的"实体内容"是否相同。