一：Java基础

一.概念

1.java特点：跨平台、面向对象、开源

2.JVM是Java虚拟机的缩写，可以实现跨平台

3.java运行原理：

1).编写java源文件，以.java作为后缀名
2).编译为字节码文件，使用java编译器将.java源文件编译成JVM能接受的指令集合，且以字节码.class的形式保存于文件中。
3).解释执行字节码.class文件，JVM读取字节码，取出指令，并且将其解释为能够将计算机执行的语言
java源程序 --(java编译器编译)--> .class文件 --(JVM解释)--> 计算机语言

4.JDK包括java运行时环境、开发工具和java基础类库3个部分

5.环境变量包括三个属性

1)Java_HOME:JDK的安装路径  (JAVA_HOME: JDK安装路径)
2)PATH：使系统可以在任何路径下识别java命令  (PATH: %JAVA_HOME%\bin)
3)CLASSPATH：Java加载类的路径  (CLASSPATH: .;%JAVA_HOME%\lib)	'.'表示当前路径

6.java编译器(javac.exe) javac 源文件名.java

jvm  java 字节码文件  (不能加后缀名)

7.生成API文档

编写包含文档注释的java程序
使用javadoc命令  javadoc -d 文档存放目录 源文件名.java

二.数据类型

1.数据类型：

基本数据类型：byte、short、int、long、float、double、char、boolean	(char占两个字节)
引用数据类型：数组、字符串、接口、类

2.标识符命名遵循规范：

1，由字母，数字，下划线，和‘$’中的任意字符组合而成
2，首字母必须是字母，下划线，或'$'
3，需要具有一定意义，且不能是系统关键字
4，严格区分大小写

3.b=a++; ++优先级低，先赋值再自增

b=++a; ++优先级高，先自增再赋值

4.数据类型转换

1).自动类型转换

	转换的两种数据类型必须是兼容的 //boolean型与其他类型不兼容
	目标类型的取值范围大于源类型
		char-->int-->long-->float-->double
		byte-->short-->int

2).强制类型转换

	目标类型 变量 = (目标类型)值

三.流程控制

1.选择结构：

if
if...else
if...else if...else		//多层嵌套
if...else{ if...else }    //内部嵌套
switch(整型表达式)...case 	//表达式结果可以是int、short、byte、char    --break退出选择语句

2.循环语句

while  当型循环语句  先判断，再执行
do...while  直到型循环语句  先执行一次，再判断
for

3.break;结束循环；还可以用于switch语句中结束选择；

continue;结束本次循环，进行下一次循环的判断与执行；

四.类与对象

1.类与对象

1).类：类是具有共同特征和行为的一类事物的统称；
2).对象：对象是类的实例，是独一无二的具体个体；
3).理解类和对象之间的关系需要首先根据具有相同特征的对象抽象出一个类，再根据类的特征来描述具体的对象；
     类与对象：类是对对象的描述，是创建对象的“模板”，是对象的抽象；对象是类的一个实例，是实例化的结果

2.类的定义

1).类是由属性和方法两部分组成；

  [访问修饰符] class 类名{
 	  类属性声明；
	  类方法声明；
  }

2).属性：又称成员变量，用于描述对象的特征或状态；

3).方法：又称成员方法，用于改变对象的状态；

	[访问权限修饰符] 返回值类型  方法名  (类型  参数1，类型  参数2...){
		方法体
	}
	返回值类型：无返回值的方法返回类型为void，有返回值的方法体中至少包含一条return语句；
	方法名：一般首字母小写；多个单词组成时，第二个单词首字母大写；
	参数：每个参数都包括数据类型和变量两个部分，多个参数之间使用逗号(,)隔开

3.对象的操作

1).实例化对象

	创建对象称为类的实例化，使用关键字new来实现

2).访问属性

	访问自己的成员变量来改变自己的状态

3).调用方法

	a.调用有参数的方法：参数个数必须相同，参数类型必须一致或能自动转换
	b.调用无返回值的方法时，不能的得到任何类型的值
	c.同一个类中，方法可以相互调用
	d.方法的递归调用。递归是指在一个方法中调用方法本身

4.构造方法

构造方法是一种特殊的方法，用于为对象变量分配内存空间，再给变量赋初始值，没有返回值

1).构造方法的名称必须与类名完全相同
2).构造方法是给对象赋初值，没有返回值，不需要void来指明
3).构造方法不能被程序显示的调用，会在实例化时自动地被调用
4).调用系统默认的构造方法实例化对象时，属性会被赋予该数据类型的默认值
5).显示的定义了构造方法，系统默认的构造方法会失效
6).同一个类中可以有多个构造方法，但他们之间必须参数个数不相同或参数个数相同但类型不完全相同，
    调用时会根据与之对应的实际参数来决定需要调用的方法

五.静态成员

1.静态变量

类的成员变量有两种：静态变量(类变量)和实例变量。

静态变量是指被static修饰的变量，静态变量属于某个类，被该类所有实例共享，即可以通过类名访问或通过实例名访问

静态变量和实例变量的区别；

	a.静态变量在加载类的过程中完成内存分配，只初始化一次，可以直接通过类名来访问
	b.实例变量中每创建一个实例，就会分配一次内存，各个对象访问自己的变量

2.静态方法

静态方法(类方法):被static修饰的方法;也可以直接通过类名访问;也是该类公有的
static [修饰符] 返回值类型  方法名 (类型1  参数1，类型2  参数2){
	方法体
}
静态方法中只能访问静态变量，不能访问实例变量;
在实例化对象之前，系统先初始化静态变量，再加载静态方法，最后初始化实例变量

3.静态代码块

静态代码块不存在于任何方法体中，它在java虚拟机加载类时执行；
如果类中包含多个静态块，则按照它们在类中出现的顺序依次进行，且每个静态代码块只在静态方法执行之前被执行一次
java程序在执行时，对类中不同部分执行顺序不相同；
类中各个组成部分的初始化顺序：
	静态变量初始化-->初始化静态方法-->静态代码块-->初始化实例变量-->普通方法初始化-->构造代码块-->构造方法

4.变量的生命周期

java中有三种变量：类变量，实例变量和某个方法中临时定义的局部变量

不同的变量作用域和生命周期不同；执行程序时java虚拟机的流程是：

	1).加载类-->初始化静态变量
	2).创建实例-->初始化实例变量
 	3).调用实例的方法-->初始化局部变量
	4).方法执行完后，销毁局部变量，退回main()方法
	5).main()方法执行完后，销毁实例及实例变量；卸载类，销毁静态变量

5.final变量

final 类型 变量名 = 值；

基本数据类型的final特征；

	1).final修饰符可以修饰三种变量，分别表示静态常量，实例常量和局部常量
	2).final类型的变量必须是显示地初始化，否则将导致编译错误
		final int MAX_VALUE = 1000;	//正确的
		final int MAX_VALUE;	//错误的
	3).final变量只能被赋值一次
	4).定义final常量时，一般以大写字母命名，且多个单词之间用"_"符号隔开
	5).一般讲final变量定义成静态的(static final)

final对象：

	即用final修饰的对象变量，该对象变量始终只能引用一个对象，但可以改变对象的内容

6.包

同一工程里不同包中的类可以相互访问--解决了类名重复，又实现了类的重用(引入类)

1).java常用包

	java.lang包：线程类(Thread)、异常类(Exception)、系统类(System)、整数类(Integer)、字符串类(String)等
				是由jvm自动引入的包
	java.io包：输入输出包，包含各种输入流类和输出流类
	java.util包：日期类(Date)、集合类(Collection)等实用类

2).自定义包

在程序中定义包时需要使用关键字package。

包的名称通常采用小写，一般包的命名应该包含以下信息：

		a.类的创建者或拥有者
		b.类所属软件项目信息
		c.类在具体软件项目中的位置
		d.包可以有多层结构，用"."分隔

包命名：com.公司名.项目名.模块名

	        org.公司名.项目名.模块名

一个java源文件中只能有一条package语句，且必须位于源文件的第一句

3).包的引入

一个类访问来自另一个包(除java.lang)中的类,需要通过import语句引入该类

java要求不同包中的类必须在相互访问前指定类、方法和属性都为公共(public)的,非公共的方法，属性不能被访问

引入某个包中的类有两种方式：

		指明需要引入某个类
			import java.util.某各类;
		一次性引入包中所有类：使用"*"
			import java.util.*;

六.常用包

/--java.lang包--/

1.String类

1).java中任何字符串都是一个对象。除了使用new关键字实例化，还可以像基本数据类型一样声明和使用

   String的实例是不可变对象,不能修改它的值,都是重新创建一个新的对象来修改

2).创建String对象 声明时没有分配空间,实例化(初始化)时才分配空间

	String str1; str1 = "Hello world";
	String str2 = "Hello world";
	String str3 = new String("Hello world");

3).String类的常用方法

a.使用length()方法获取一个字符串的长度

		String str1 = "";	//空字符
		String str2 = null;	//空对象
		str1.length();	//0	对象存在,值为空
		str2.length();	//NullPointerException 对象不存在

b.使用valueOf()方法将数字类型转换成字符串

		int a = 100;
		int b = 6;
		String.valueOf(a);
		System.out.println(" "+a+b);

c.使用subString()方法截取字符串

		subString(x);    [x,...)
		subString(x,y);    [x,y)

d.使用equals()方法判断两字符串值是否相等

		equals()  字符串(重写)  值
				  非字符串  地址
		"=="  基本数据类型  值
			  非基本数据类型  地址

2.StringBuffer类

1).StringBuffer的实例是可变对象,对其修改不会重新创建对象

2).创建StringBuffer对象

	StringBuffer str1 = new StringBuffer("Hello world");
	StringBuffer str2 = new StringBuffer();  //空的字符串常量  默认长度为16个字符
	StringBuffer str3 = new StringBuffer(20);  //空的字符串常量  赋值长度不能超过20个字符

3).StringBuffer类的常用方法

	a.使用insert()方法在指定位置插入指定字符串
	sb.insert(2,"Hello");  //在索引号位置插入指定字符串

3.包装类 --基本数据类型就是对应包装类的一个成员变量

1).char -- Character

   int  --  Integer
   其余6种都是首字母大写

2).常用方法:

	a.使用parseInt()方法将数字字符串转换为整型
	Integer.parseInt("123");

4.Math类

1).两个静态常量:E(自然对数)  PI(圆周率)
2).数学方法都是静态方法
3).构造方法都是private,不能实例化
4).Math类是final类,不能被继承
5).常用方法:
	Math.random();	[0.0,1.0)

/--java.util包--/

5.Date类

Date d = new Date();
DateFormat df = new DateFormat();
DateFormat.format(d);

6.SimpleDateFormat类:用于格式化和解析日期的具体类,位于java.text包中 --将时间日期类型与字符串类型进行相互转换

SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");		"H"表示24小时,"h"表示12小时
String s = sdf.format(d);	//将Date转换为字符串
Date dd = sdf.parse(s);    //将字符串转换为Date		-- 需要throws Exception

7.Calendar类 --可以动态的修改日期

1).Calendar类是抽象类,不能被实例化

   getInstance()方法返回一个Calendar对象,该对象已经由当前日期和时间初始化
   Calendar cld = Calendar.getInstance();

2).使用getTime()方法获取当前时间

	cld.getTime();

3).使用add(int field,int amount)方法修改日期

	cld.add(Calendar.DATE,-1);	//修改成昨天的日期
	String s = sdf.format(cld.getTime());	//获取昨天的日期

4).使用set()方法设置日期

	cld.set(2018,09,18);
	String s= sdf.format(cld.getTime());

5).使用get()方法获取时间的特定部分

	int i = cld.get(Calendar.DAY_OF_WEEK);	//获取一周中的第几天,也就是星期几

七.数组

1.一维数组

1).声明 类型[] 数组名 //声明并未分配内存空间

2).定义 类型[] 数组名 = new 类型[长度]; //使用new为数组分配内存空间

3).默认初始化

	实例化时,数组中的数值型元素默认值都是0
	布尔型元素默认值都是false
	引用型是null

4).显示初始化

	a.int[] x = {1,2,3,4,5};
	b.int[] x = new int[]{1,2,3,4,5};
	c.int[] x = new int[5];  x[0]=1; x[1]=2; x[2]=3; x[3]=4; x[4]=5;
	d.定义数组长度为0
		int[] a = new int[]{};
		int[] a = {};
	一旦创建了数组,其长度将无法再改变
	数组的长度可以为0

5).数组的遍历

	int[] a = new int[10];
	for(int i=0; i<a.length; i++){
		a[i] = i*2;    //为数组显示初始化
	}
	for(int i=0; i<a.length; i++){
		System.out.println(a[i]);	//数组的遍历
	}

6).冒泡排序 --定右边数字

	int[] a = {1,3,2,6,4,8};
	for(int i=0; i<a.length-1; i++){	//轮数
		for(int j=0; j<a.length-1-i; j++){	//次数
			if(a[j]>a[j+1]){
				int temp = a[j];
				a[j] = a[j+1];
				a[j+1] = temp;
			}
		}
	}

7).选择排序 --定左边数字

	int[] a = {1,3,2,6,4,8};
	for(int i=0; i<a.length-1; i++){	//轮数
		for(int j=i+1; j<a.length; j++){	//次数
			if(a[i]>a[j]){
				int temp = a[i];
				a[i] = a[j];
				a[j] = temp
			}
		}
	}
	-------------------------------------
	int[] flag = new int[2];    //中间容器
	for(int i=0; i<a.length-1; i++){    //a.length轮只需要比较a.length-1轮
		flag[0] = a[i];
		flag[1] = i;
		for(int j=i+1; j<a.length; j++){	//比较最小值,放入中间容器
			if(a[i]>a[j]){
				flag[0] = a[j];
				flag[1] = j;
			}
		}
		if(flag[1] != i){    //换位置
			int temp = a[i];
			a[i] = flag[0];
			a[flag[1]] = temp;
		}
	}

8).对象数组

a.声明和初始化

		类名称[] 对象数组名称 = new 类名称[对象个数];

b.对象数组使用

		Student[] stu = new Student[10];
		for(int i=0; i<stu.length; i++){
			Student s = new Student("Jack"+i,18+i);		//实例化对象
			stu[i] = s;    //将对象放入数组
		}
		for(int i=0; i<stu.length; i++){
			System.out.println(stu[i].name+" "+stu[i].age);		//打印输出每个对象的属性
		}

2.二维数组 --一维数组的嵌套

1).声明 数据类型[][] 数组名;

2).定义 int[][] a = new int[2][3]; //2行3列的数组

	a看作一维数组,包含元素int[0],int[1],且int[0]和int[1]分别又包含3个元素的一维数组

3).初始化

	默认初始化和一维数组相同
	显示初始化:
		int[][] a = new int[][]{(1,2,3),(4,5,6),(7,8,9)};
		int[][] a = {(1,2,3),(4,5,6),(7,8,9)};

4).数组的遍历

	String[][] s = new String[2][3];
	for(int i=0; i<s.length; i++){    //s.length表示二维数组的行数
		for(int j=0; j<s[i].length; j++){    //s[i].length表示二维数组的列数
			s[i][j] = "第"+i+"行,第"+j+"列";    //将字符串对象存入数组
		}
	}
	//遍历输出二维数组的值  --嵌套循环
	for(int i=0; i<s.length; i++){
		for(int j=0; j<s[i].length; j++){    //遍历每个一维数组
			System.out.print(s[i][j]+" ");
		}
		System.out.println();
	}

5).不规则二维数组

a.定义

		int[][] a = new int[5][];    //定义行,即a[0]-a[4],a[i]都是数组对象的引用
		a[0] = new int[4];    //定义a[0]所实际引用的数组对象,即第一行由4个元素组成
		a[1] = new int[3];
		a[2] = new int[1];
		a[3] = new int[2];
								//没有定义a[4],即第五行开辟的空间,没有显示初始化,a[4]默认值为null

b.数组的遍历

		for(int i=0; i<a.length; i++){
			System.out.print("第"+(i+1)+"行:");
			if(a[i] == null){	//判断数组对象的引用是否是null
				System.out.print(a[i]);
				continue;
			}
			for(int j=0; j<a[i].length; j++){
				System.out.print(a[i][j]+" ");
			}
			System.out.println();
		}

c.应用

		矩阵元素互换
		杨辉三角形