Java它不仅吸收了面向对象的编程语言C 语言的各种优势也被抛弃了C 多继承、指针等概念难以理解，所以Java语言有两个特点:功能强大，使用简单。Java语言作为静态面向对象编程语言的代表，极好地实现了面向对象理论，允许程序员以优雅的思维方式进行复杂的编程 [1] 。 Java具有简单、面向对象、分布式、强度、安全性、平台独立性和可移植性、多线程、动态性等特点 [2] 。Java桌面应用程序可以编写，Web应用程序、分布式系统和嵌入式系统应用程序 [3]

数据类型包括：基本数据类型和引用数据类型，基本数据类型主要有八种，byte、short、int、long、float、double、boolean、char、String ；引用类型包括对象和数组，引用类型的默认值为null。

八种基本数据类型，四种整数类型，两种浮点类型，一种布尔类型，一种字符类型。

拆箱与装箱

包装类位于java.lang包下。

1. 特点

   • 都有自己相应类型的参数结构方法。
   • 除Character还有其他重载带的结构方法String。
   • 六个数字相关类别继承Number。

2. 常用方法

   • XXX value()：///将包装类型转化为相应的基本类型。
   • int value = new Integer(10)：//在堆内存中重新创建变量。
   • Integer类加载时有静态空间，空间立即加载Integer数组（-128~127）。 如果使用的对象范围在此范围内，则直接取静态区域的对象 如果超过，它将帮助我们重建一个新的Integer对象

存储在数组中的元素是存储在数组中的元素堆内存中间；一组数据类型相同的数据组合，也可以存储基本数据类型存储基本类型。初始化必须指定长度。一旦创建了数组长度，就不能改变。数组中存储的类型可以是基本的或参考类型。

多维数组，即嵌套在数组中的数组。

• 静态数组 有长度有元素 初始化：int [] array = [ new int ]{value}；
• 动态数组 没有元素的长度 初始化：int [] array = new int {index};
• 通过index(元素访问数组的位置)，获得数组的总长度，即存储元素的数量——>”变量名.length“
• index的取值范围[0~lengh-1]

注：如果index超出范围，运行时会出现 ArrayIndexOutOfBoundsException 数组索引越界

1. 数组遍历-循环

常用于遍历数组For循环或者ForEach循环

///数组声明 int [] array = new int [5]{ 
        1,2,3,4,5};  //for循环遍历 for(int i = 0 ; i < array.length ; i++){ 
        
    //打印数组值
    System.out.println(array[i]);
}

2. 数组遍历-迭代器：

    遍历集合，每个集合都有 iterator 方法，该方法返回一个迭代器对象
   

    List<Integer> b = Arrays.asList (a) ; 
    Interor ib = b.iterator () ;

//常用方法：
    E next ();//返回集合的下一个元素
    boolean hasNext (); //判断下一个是否有元素
    void remove(); //从集合删除当前元素
    
//实例：
    Integer [] a = { 
        10,20,30,40,50};
    Object x;
    List<Integer> b = Arrays.asList (a) ;
    Interor ib = b.iterator () ; 
    while (ib.hasNext()){ 
        
    	x=ib.next;
    	System.out.println(x+" ");
    }

在程序中大致分为四种类型：算数运算符，赋值运算符，逻辑运算符，关系运算符。

1. 进制转换

   利用二进制判断奇偶数：判断该数的二进制数末尾为0还是1；如果为零，这表明该数为偶数，若为一，则表明该数为奇数。

2. 赋值运算

4. 关系运算符

• ” =“ 与“== ”的区别

  = 赋值符号，将结果存入变量之中。 == 可以理解为判断两值或对象是否相等，返回的结果为Flase或true。

• ”==“和“equals()”的区别 对于基本类型，==和equals方法比较的都为两值是否相等； 对于字符串，==比较的为地址,equals方法比较的为值； 对于对象，==比较的为内存地址，equals方法比较的为值；

4. 逻辑运算符

• 位(bit)运算符

1. 项目名
   • 全部小写。如：jobserver，studentmanagesystem；
2. 包名
   • 全部小写，名词。如：java.awt.event；
3. 类名、接口名
   • 首字母大写，多个单词组成时，每个单词的首字母大写。如MyClass，String；
4. 方法名
   • 首字母小写，多个单词组成时，从第二个单词开始，每个单词的首字母大写。第一个单词一般为动词，如：toString()；
5. 变量名
   • 普通变量名：同方法的命名，一般为名词。如：int index=0;
   • 常量名（静态变量名）：全部大写。如： public static final String GAME_COLOR=”RED”;
6. 属性文件properties
   • 以下划线隔开。如：errors_zh_CN.properties，hibernate_test.properties;

7.数据库命名：

• 表、字段命名全部大写，多个单词以_隔开。

注意：并不是每个权限修饰符都可以修饰类（外部类），只有public，默认的可以。所有权限修饰符都可以修饰数据成员，方法成员，构造方法。

特征修饰符有：final（最终的）、static（静态的）、abstract（抽象的）、native（本地的）、transient（瞬时的）、synchronized（同步的）、volatile（不稳定的） 等。

1. final 修饰符

final 不变的修饰变量的时候若无初始值，则给一次赋值机会，若一旦被final修饰，则不让其改变其值。

• 修饰变量的区别 若final修饰基本变量，则变量的值不能改变；若final修饰引用变量，则变量内的地址引用不变。

若属性使用final修饰，必须给其赋初始值，否则编译报错，属性如果没有赋值，但其是有默认值的，它储存在堆内存中的。

• 修饰方法 final修饰方法，不能被子类重写，即只能被子类继承。

• 修饰类 final修饰的类不能被继承，通常final修饰的是一些定义好的工具类。

2. static 修饰符

static修饰符，也就是静态的，static修饰符可以修饰 属性、方法、块、内部类。

• 静态元素在类加载的时候，就已经初始化完毕，并在静态元素区储存，且每一个类都有自己的储存区域。
• 类加载一次，全部类及对象共享可以理解静态元素不属于任何的一个对象，属于类。
• 非静态元素成员（堆内存对象）中可以访问静态成员（静态元素区）且静态成员可以访问静态成员，但是静态成员不可访问非静态成员。
• 静态元素中不可出现this或super关键字。

注意： 如果类已经被加载，则静态代码块和静态变量，就不会重复执行，再创建类对象时只执行相关的变量的初始和构造方法。 可以理解：如果相同的静态成员已加载，则不再会再次加载，静态变量只加载一次。

3. abstract 修饰符

abstract修饰符，抽象的，用于修饰类（接口和抽象类）、抽象方法。

• 同一个类不能被 abstract 与 **final **同时修饰。
• 同一个方法不能被 abstract 与 **static **同时修饰。

4. synchronized 关键字声明的方法同一时间只能被一个线程访问

if条件语句，也就是当条件符合时，执行语句里面的内容。

//当执行的条件符合，也就是条件为true时，执行if判断语句的内容。
if ( 条件 ) { 
        
	//执行内容
}

//双分支
if ( 条件 ) { 
        
	//执行体1
} else { 
        
	//执行体2
}

if条件语句多分支结构

if多分支结构就是在if单分支条件上增加多个条件判断。

if( 判断条件1 ){ 
        
	//执行体1
}else if( 判断条件2 ){ 
        
	//执行体2
}else if( 判断条件3 ){ 
        
	//执行体3
}...

Switch多分支条件语句

switch分支中的语句中，所支持的数据类型有：byte、short、int、char、String、eaum等。

Switch( values ){ 
                                                          
	case 1：            
		//代码执行程序1；
		beark;
	case 2：
		//代码执行程序2；
		beark;
	case 3：
		//代码执行程序3；
		beark;
	//...
}
//switch语句具有穿透性，可以用break去除穿透效果；

​ 循环就是在不停的往复重复一件事情，可以理解不断执行的代码。循环的条件：初始值、终点判定条件 、变化量。在循环中，一直达不到终点判断条件，则该循环会陷入“死循环”，会抛出**OutOfMemoryError** 内存溢出的错误，也可以理解内存使用完。

​ 循环中断：使用break关键字，即可中断本次循环。 ​ 循环继续：使用continue关键字，就是中断本次循环继续下一次循环，且只能存在循环中。 ​ 循环嵌套：顾名思义就是在循环中嵌套循环，循环的次数就是两循环次数的乘积。

for (初始量;重点判定条件;变化量){ 
        
	//执行代码；
}

//循环嵌套
for (初始量;重点判定条件;变化量){ 
        
	for (初始量;重点判定条件;变化量){ 
        
	//执行代码；
	}
}

while循环是_先判断后执行，条件不符不执行_，并且变换量放在执行代码上下顺序可能对执行有影响；

//初始值
int i = 0;

//while循环：先判断后执行，，倘若条件为真true，则跳出循环
while( 终点判断条件 ){ 
        
	//执行体；
	//变化量；
}

//do...while循环：先执行后判断，倘若条件为真true，则跳出循环
do{ 
        
	//执行体
}while( 终点判断条件 )

对象（Object）：一个具体的事物具有一定属性和行为，含有“物体的概念”，一切物体皆对象。

类 （Class）：类是java程序中组成的基本单位，是一组具有相同属性和行为的对象；类是由属性和行为组成，属性主要通过成员变量来实现，行为主要通过定义成员方法来实现。

• 属性结构：权限修饰符 特诊修饰符 数据类型 属性名称 [=所赋予的值];
• 方法结构：权限修饰符 特征修饰符 返回值类型 方法名称 (参数列表) [抛出异常] {方法体;}

public class Person{ 
        

	//属性
	public String name;
	
	//方法
	public String getName (){ 
        
		
		return this.name;
		
	}
}

方法相关

1. 方法重载(overload)

对于一个同一个类的同一组方法，具有相同的方法名，不同的参数列表（个数、顺序、类型），这样一组方法构成方法重载。

方法重载的原则：

• 方法名称必须相同。
• 参数列表必须不同。
• 方法的返回类型可以相同也可以不相同。
• 仅仅返回类型不同不足以称为方法的重载。

注意：final修饰的方法不能被重载。static修饰的方法不能被重载，但是能够被在此声明。

2. **实参与形参 **

形参：方法执行时的临时变量空间。 实参：方法调用时传递的出去的参数。

方法调用时会将实参的内容传递给形参 如果内容是基本数据类型，则传递的为值，形参改变，实参不改变。 如果内容是引用数据类型，则传递的为地址，形参改变，实参改变。

3. 构造方法

构造方法，就是构造当前类的对象，对一个类进行实例初始化，其没有返回类型，甚至连void关键字修饰都无。 构造方法可以进行方法重载。 构造方法分为有参构造和无参构造，其类默认为无参构造方法，当类无构造方法，其系统会默认添加无参构造方法，若想让类不可被实例化，可以用private修饰构造方法。 语法结构：权限修饰符 方法名（与类名一致）(参数列表) [抛出异常] {方法体; } 可以通过this()，调用当前类的构造方法。

3. this和super关键字

this代表当前对象，用于代替某个对象或当前属性和方法。并且this关键字可以调用属性和方 法，也调用构造方法，但必须通过**this()。**在另一个构造方法内调用构造方法，必须放在程序的第一行。 super来实现对父类成员引用，用来引用当前对象的父类。

4. 代码块

代码块就是一个只有方法的方法体，没有方法名、参数列表、返回值并且不能通过对象调用，只能在类加载时自己执行。

• 创建形式 “ {} ” 就是没有参数，没有修饰符（static除外），没有返回值的特殊方法。
• 没有重载，但可以定义多个程序块。
• 在创建对象之前进行，每一次在调用构造方法之前都会默认执行。

1. 非静态代码块

非静态代码块也就是，不使用static修饰的代码块，其包括：局部代码块、构造代码块。

//构造代码块：也就是处于方法外
{ 
        
	System.out.println("这是构造代码块");
}

//局部代码块
public void test () { 
        
	System.out.prinln("这是局部代码块");
}

3. 静态代码块

也就是通过static修饰的代码块，一般用于数据初始化，并且静态块伴随类的初始化而加载，且只执行一次。

static{ 
        
	//执行体
}

注意：如果方法来回的调用，但执行时可能会产生 StackOverFlowError 栈溢出错误，也就是内存使用完。

public class block { 
        

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

    static{ 
        
        System.out.println("静态代码块");
    }

    public static void main(String[] args) { 
        
        { 
        
			//对类进行实例化
            new block();
            System.out.println("局部代码块");
        }
    }
}

• 声明的对象是先在栈内存中为其分配地址空间，在对其进行实例化后则在堆内存中为其分配地址。
• 堆内存用来存放由 new 创建的对象和数组，在堆中分配的内存，由 Java 虚拟机的自动垃圾回收器来管理。
• 在函数中定义的一些基本类型的变量和对象的引用变量都是在函数的栈内存中分配，
• 当在一段代码块定义一个变量时，Java就在栈中为这个变量分配内存空间，当超过变量的作用域后，Java 会自动释放掉为该变量分配的内存空间，该内存空间可以立即被另作它用。

面向对象的编程的主要思想是把构成问题的各个事物分解成各个对象，建立对象的目的不是为了完成一个步骤，而是为了描述一个事物在解决问题的过程中经历的步骤和行为。对象作为程序的基本单位，将程序和数据封装其中，以提高程序的重用性，灵活性和可扩展性。类是创建对象的模板，一个类可以创建多个对象。对象是类的实例化。类是 抽象的，不占用存储空间；而对象具体的，占用存储空间。

• 面向对象的最重要的特性是支持继承、封装和多态。
• 系统设计应该遵循开闭原则，系统应该稳定不不可修改，但应支持通过继承、组合等方式进行扩展
• 面向对象设计时，每个类的职责应该单一，不要再一个类中引入过多的接口
• 过程式语言和面向对象的语言各有其优势，过程式语言更加灵活，面向对象语言更加强调抽象和封装
• Java和C++都是静态类型的面向对象编程语言

继承实现提高程序的复用，提高耦合性，但响应的降低了独立性，子类可以直接获得父类提供的属性和方法，子类还可通过拓展，定义自己的属性和行为。 继承通过 extends关键字实现，实现的类为子类，被继承的为父类，一个父类有多个实现类，但一个子类只有一个父类，子类可以获取父类中的所有非私有的属性和行为。 继承类型包含单继承和多继承，但Java中只支持单继承，但可以通过传递的方式实现多继承效果，一个类可以被多个子类直接或间接继承。

public class animal { 
        

	public Eat eat;
	
	//......

}

public calss person extends animal { 
        

	//继承父类的属性或行为
	public Eat eat;
	
	//......
	
}

子类可以调用父类的属性和方法且可以添加自己独有的属性和方法，也就是方法重载（override），重写父类的方法体，也就是覆盖父类的方法内容，保持子类的**方法名、参数列表、返回值相同**，后修改方法体。

ouverride 与ouverlode 的区别

1. 类的区别 方法重写是产生两个继承的类，子类重写父类的方法。方法重载是同一类的同一组方法。

2. 权限权限符 方法重写子类的权限修饰符可以大于父类（public>protected>默认的>private）。方法重载无要求。

3. 特征修饰符

若父类的方法被final修饰，则子类不能重写父类的方法；若父类被static修饰，则子类不存在重写；若父类被abstract修饰，则子类必须重写（或者该子类为抽象类）。

4. 返回值 重写中子类的返回值必须小于父类，重载没有要求。

5. 参数列表 方法重写，子类必须与父类一致；方法重载，每个方法的参数必须不一致。

6. 异常区别 如果父类方法执行时异常，子类不予理会。如果父类抛出编译时异常，子类抛出的异常个数少于等于父类。 子类抛出的异常类型小于等于父类。

三目运算符

三目运算符就类似于if-else语句，但是语法更加简洁，语法结构：判断条件 ? 执行体1 : 执行体2

类关系

类之间的关系包括：继承（泛化 Generalization）、 实现（Realization）、依赖（Dependenc）、关联（Correlation）、聚合（Paradigmatic）、组合（Syntagmatic）。

1. 继承关系

继承关系也叫泛化关系是，通过关键字extends实现，继承的类为子类，被继承的类为父类，但在java中只支持单继承，若想要实现多继承可以通过叠加的方式实现，通过一个空心箭头的实线表示。

2. 实现关系

实现关系，其实现形式为 **interface **接口 ，并通过关键字 Implements 实现，其通过空心箭头的虚线表示。在java中单继承多实现。

3. **依赖关系 use-a **

是一种使用关系，临时性关系。在代码中由局部变量，函数参数，返回值建立对于其他对象调用。类比“屠夫杀猪、人使用手机”之间的关系。通过虚线箭头表示。

4. **关联关系 **

体现的是两个类之间的语义级别具有强烈依赖关系，且关系一般为平等、双向的关系，如：人有车、学生与学校的关系等。通过实线箭头表示。 ** 一个类成员变量是另个一个类的实例对象。**

5. 组合关系(Compostion)

表示 contains-a 的关系，是一种强烈的包含关系，含有相同的生命周期。整体和部分的关系不可分割，，同时出现同时消失，类比“人与大脑”的关系,也就是整体和部分不可分离，通过实心菱形箭头实线表示。

6. 聚合关系

它体现整体与内部的关系也就是 has - a 关系，此时整体和部分可以分割，他们具有各自的生命周期，部分可以属于多个整体对象，也可为多个整体对象所共享，类比“汽车和轮胎，电脑和主板”的关系,通过空心菱形箭头实线表示-。

7. 各种关系强弱：泛化=实现>组合>聚合>关联>依赖

Object方法

• hashCOde()；将对象在内存中的地址经过计算得到一个 int 整数。
• **equlas()；**用于比较对象的内容，且Object的默认效果为“==”
• toString()； 打印输出的对象为String字符串类型。
• **getClass()；**获取对象的映反射。
• **wait()；**让线程进入挂起状态，且存在方法的重载。
• **notity()；**线程唤醒。
• **notifyAll()；**唤醒所有线程。
• tinalize()；
• **clone()；**为克隆对象。

对象的全部属性和行为都在类的内部实现，不可分割，“信息隐蔽”，就是将类内部的数据进行私有化或者对执行过程进行封装，使类的内部实现细节不可见的，从而保护数据和执行过程的安全，使用者只能通过类提供的公共方法，来获取类的内部数据。

1. 类加载顺序

** 先父类后子类，先静态后动态，先变量后块，最后构造器。**

2. 类加载做了哪些事？

   • 类加载时，同时初始化类中静态的属性（赋默认值）。
   • 执行静态代码块。
   • 分配内存空间,同时初始化非静态的属性（赋默认值）。
   • 如果声明属性的同时有显示的赋值,那么进行显示赋值把默认值覆盖。
   • 执行匿名代码块。
   • 执行构造器。
   • 返回内存地址。

1. 抽象类

在普通类的基础上扩充了抽象方法的类，使用 **abstract **关键字定义。

使用原则

• 所有抽象类都必须还有子类，且abstract 和 final不能同时修饰，否这个会编译报错。
• 若子类不是抽象类，子类必须重写父类（抽象类）的所有抽象方法，若子类为抽象类则可以不要求重写，即以abstract修饰子类。
• 抽象类可以修饰子类向上转型，对其实现实例化，抽象类不一定能直接实例化对象。
• 由于抽象类强制要求子类复写父类的方法，故 private 和 abstract 不能同时使用，(private私有的，被private修饰的属性方法不能被外部使用)。
• 抽象类可以没有抽象方法，但抽象类也可全为抽象方法，若全为抽象方法可以转化为另一种使用形式-接口。
• 抽象类的属性和普通方法（非抽象方法）都能用final和static修饰也可含有块和构造方法(static修饰块)，构造方法也可重载。
• 子类重写父类的方法，在子类内部在子类方法外进行重写。后在子类主方法内那个调用重写之后的方法。

//抽象类
public abstract class Animal { 
        
	
	//抽象方法-抽象方法无方法体
	public abstract void eat();
	
	//普通方法
	public void sleep (){ 
        
		//方法体
	}
	
}

2. 抽象方法

使用 abstract 关键字修饰没有方法体的方法，且子类继承后必须重写父类的抽象方法。

使用原则

• 先调用抽象类构造方法，再调用子类构造方法。
• 抽象方法必须放在抽象类中或接口中。
• 抽象方法一定不能用final和static修声明，因为final不允许有子类，而抽象类必须含有子类，即子类通过重写抽象类的方法。
• 直接继承外部的抽象类，则只需重写外部类的抽象类的所有抽象方法。

接口是一种特殊的类，简单理解就是抽象类的极致化，使用interface关键字声明，大多用于定义规则。通过关键字 **implements **表示被子类实现。

public interface Student{ 
        
	
	//静态熟悉/常量
	public static final Integer ID = 1;
	
	//抽象方法
	public abstract void study();

}

1. 使用原则

   • 在接口中所有的属性值都是通过 public static final 修饰，即静态常量。
   • 在接口中公有的抽象方法都是通过 public abstract 修饰。
   • 不允许使用 **private **和 **protected **声明接口成员和结构，包括在任何地方使用。
   • 通过“implement”（实现）表示被子类继承，同时需要在子类中实现抽象方法。如：public class Person implement Animal{}。
   • 使用接口常量，直接通过"对象名."的形式进行调用。
   • 使用接口的方法，通过创建对象，后进行调用子类实现的方法。

2. 类与接口的关系

   • 接口不能继承其他类，包括抽象类和具体方法，但可以直接继承其他接口。
   • 抽象类可以直接实现接口，但具体类不可以直接实现接口，必须将接口的方法具体化或将该子类变为抽象类。
   • 在java中是单继承多实现机制，但是可以通过阶梯式实现多继承。

多态也就是类的多种形态，不同对象使用同一接口，所产生的不同状态。 类是对象的模板，对象是类的实例。类只有通过对象才可以使用，而在开发之中应该先产生类，之后再产生对象。类不能直接使用，对象是可以直接使用的。

实现条件

• 继承关系：必须含有继承关系的子类和父类。
• 重写方法：子类对父类的某些方法进行重新定义，在调用这些方法就会调用子类的方法。
• 向上转型：在多态中需要将子类的引用赋给父类的对象（ 父类的引用指向子类的对象），才可调用子类和父类的方法。
• 如果父类和子类有同名的属性，则执行的为父类的属性。
• 如果子类将父类的方法重写，则调用子类重写的结果。

**上下转型 **

1. 向上转型

当父类引用指向一个子类对象时，便是向上转型。当使用多态方式调用方法时，首先检查父类中是否有该方法，若有，则执行的是子类重写后的方法，若没有，则编译出错。

Person person = new Teacher;
//该引用只方能调用父类的属性和方法（Person为父类，Teacher为子类）

2. 向下转型

父类类型向子类类型向下转换的过程，这个过程是强制的。一个已经向上转型的子类对象，将父类引用转为子类引用，可以使用强制类型转换的格式，便是向下转型。

Teacher teacher = new Person();
//向下转型

注意：在造型时（强制向上或向下转型）可能会出现一个运行时异常 ClassCastException。

对于对象固定的类，一组常量，使用枚举类。