Java学习笔记

第一章

一、什么是程序?

程序是为了让计算机执行某些操作或解决某个问题而编写的一系列有序指令的集合

二、Java是什么？ 有什么用处?

java是一门计算机编程语言，能够开发桌面应用程序和Internet应用程序以及Android应用

三、java的技术平台

JavaSE : Standard Edition 标准版 开发桌面应用程序（C/S）

JavaEE 企业版 开发Internet应用程序(B/S)

JavaME Micro Edition 微型版 嵌入式开发

四、开发java程序的步骤

编写源程序 ----->>编译源程序 ----->>运行

编写源程序: 创建扩展名为.java的文件

编译源文件: 使用javac命令将.java文件转换为.class文件

运行: 用java命令解释class文件

五、常用CMD命令

切换盘符 : 盘符:(例：c: d: e:)

切换目录 : cd 目录名(文件路径)

查看目录 : dir(显示当前目录的所有文件)

创建文件夹: mkdir 目录

六、解析第一个JAVA程序

/**
*  public 访问修饰符
*  class  类关键字
*  static 静态关键字
*  void   无返回值
*  main() 程序的运行入口
*/
public class HelloWorld{
	public static void main(String[] args){
        //do anything
        System.out.println("Hello World!");
    }
}

七、转义符

\n 换行

\t 水平制表符(空格)

第二章

一、为什么要使用变量

程序要把数据存储在内存中，用变量来表示这个空间，可以把空间理解为容器

二、怎么找到变量

通过内存地址找到对应的数据，但是内存地址不方便编程人员的记忆，所以通过变量名称寻找到内存中的数据

三、变量的概念和作用

变量就是一块内存空间，可以用来存储数据并可以重复读写

变量组成结构

1. 变量名 ：表示内存空间
2. 变量类型 ：便是内存空间大小
3. 值 ：数据内容

四、变量的命名规则

1. 可以使用数字、下划线、美元符号
2. 数字不能用于开头
3. 不能使用java关键字

五、变量的命名规范

1. 小写字母开头，后面每个单词首字母大写
2. 不要使用中文以及拼音
3. 命名必须是有意义的

总结：字下美元其后数，见名知意！

六、变量的使用步骤

1. 声明变量

// 数据类型 变量名称;
int money;

2. 赋值

//变量名称 = 1000;
money = 1000;

3. 使用变量

//使用变量
System.out.println("您的余额为:"+money);

七、基础数据类型

1. char 字符型 2byte 一对单引号,且只能存储一个字符
2. double 双精度小数 8byte 能够存储小数点的数据
3. int 整数型 4bit 能够存储整数的数据，不能存储小数点的，强制转换时， 不会四舍五入 ，只会取整数的那部分
4. String 字符串 可变 一对双引号括起来的字符串

八、整数型中包含以下数据类型

1. byte() 字节 字节(byte)
2. short 短整型 2(byte)
3. int 整形 4(byte)
4. long 长整型 8(byte)

九、浮点型型中包含以下数据类型

1. float 单精度 4(byte)
2. double 双精度 8(byte)

十、java中的八种基本类型

数据类型	数据类型名称
char	字符型
boolean	布尔
byte	字节
short	短整型
int	整型
long	长整型
double	双精度小数
float	浮点型

十一、运算符

1. 赋值运算符

= 用于赋值，将数据赋值给变量名

2. 算术运算符 (变量初始之后才能进行运算)

1. +：加法运算、字符拼接 (算式在前属于算式，算式在后面为拼接)

int a = 3,b = 5;
System.out.println(a + b + "=" + a + b);  //输出8=35
System.out.println(a + "+" + b + "=" + a + b);  //输出35=35

2. -：减法运算

3. *：乘法运算

4. /：除法运算（整型/整型= 整型）

1、整型/整型= 整型 取整数不会保留小数

2、整型/浮点数 = 浮点数 除数和被除数中只要有一个浮点数，那么结果就是浮点数

5. %：取余 (取除不尽的数,如果能除尽那么就是0)

3. 关系运算符

1. <  大于
2. >  小于
3. <= 小于或等于
4. >= 大于或等于
5. == 等于
6. != 不等于

十二、键盘输入

输出语句 电脑和我们交流

System.out.println("xxxxx");

输入语句 我们和电脑交流

//导入包      可以理解为说明书
import java.util.Scanner;
//创建扫描仪对象
Scanner scanner = new Scanner(System.in);
//使用扫描仪对象方法
Scanner.nextInt();     		//输入类型为整型
Scanner.next();        		//输入类型为字符串
Scanner.nextDouble();  		//输入类型为浮点型
Scanner.next().charAt(0);	//输入类型为字符型

十三、有关于++ --的口诀

++ (自增) 在前先计算后用 ++在后先用后计算

– (递减) 在前先减后用 --在后先用后减

十四、类型转换

1. 自动类型转换：小类型自动提升为大类型

转换条件

1）类型要兼容（要属于同一类型）

2）目标类型大于原类型(通过字节比较) double a(目标类型) = 10(原类型)

2. 强制类型转换：大类型转换为小类型

转换条件

1）类型要兼容

2）目标类型要小于原类型

公式：目标类型 = (目标类型)原类型； 目标类型可以理解为数据类型

注意：强制类型转换对原类型定义的属性没有影响，只会让使用强制转换的地方损失数值精度

十五、随机数公式

//Math.random(); 置随机数，产生（0，0.9）之间的小数
int min = 10; int max = 20;
int random = (int)(Math.random()*(max-min+1))+min;

十六、如何处理nextInt()输入字符所出现的异常问题

Scanner scanner = new Scanner(System.in);
if(scanner.hasNextInt()){
    int number = scanner.nextInt();
}else{
    System.out.println("请输入数字!");
}
/**
*	InputMismatchExeception 输入内容的数据类型和接收的数据类型不匹配
*	hasNextInt()  判断键盘扫描仪所输入的值是否为整型，如果不是那么返回false,反之返回true
*	hasNextXXX    XXX代表其他数据类型
*/

第三章

一、为什么使用if选择结构

让程序有选择的执行代码

二、if结构

if(true){ //条件：是布尔类型的表达式
    //代码块  条件为真才执行
}
//先判断条件是否成立，如果成立就执行代码块，反之跳过进入下一个代码块

三、逻辑运算符

符号	解译	理解
&&	与	&&左右条件都满足则为真，否则为假
||	或	||左右有一个为真则为真，左右都为假则为假
!	非	取反，表达式结果为真，返回假，表达式结果为假，返回真

四、if-else判断结构

if(条件表达式){ //条件成立进入代码块一，不成立进入代码块二
    //代码块一
}else{
    //代码块二
}

五、多分支if判断结构

//该if判断等同于三个if判断，只要一个条件满足了,那么将会执行一个类似于break的方法
//break; 中断当前执行的代码块，继续运行下面的代码块
if(条件表达式1){    //条件表达式：逻辑表达式,最终结果为boolean的值
	//代码块1
}else if(条件表达式2){
	//代码块2
}else{
	//代码块三
}
/**
*	当满足条件1，则执行代码块一，否则进入else if判断条件2
*	当满足条件2，则执行代码块二，否则进入else执行else中的代码块
*/

六、嵌套if判断结构

//只要条件满足，则执行类似于break的方法，中止当前代码块的运行，进入下一个代码块
if(条件表达式1){
    //第一层代码块1
    if(条件表达式2){
        //第二层代码块1
    }else{
        //第二层代码块2
    }
}else{
    //第一层代码块2
}
/**
*	先判断条件表达式1是否满足,如果条件表达式1满足，那么进入第一层代码块,否则进入else代码块，执行第一层代码块2
*	在判断第二层if判断，判断条件表达式2是否满足，如果条件表达式2满足条件，那么执行第二层代码块1，
*	否则进入else，执行第二层代码块2
*/

七、If选择结构的注意点

1. else if的条件要按照一定的顺序排列(条件由大到小，或者由小到大)
2. else 要放到最后（可以没有，如果有，则只能存在一个else）
3. 每对{}里面的代码格式要对其
4. 条件表达式比较的两个值，只会比较内容，与比较的变量类型无关

第四章

一、为什么要使用switch结构

在处理等值判断时，用分支if判断容易出错且结构复杂，switch选择结构清晰且不容易出错

二、switch结构

switch(表达式){
    case 常量1:
        //代码块
        break;
    case 常量2:
        //代码块
        break;
    default:
        //代码块
        break;
}

(1)switch结构解析

1. 表达式：类型为int,short,byte,char,String,枚举（在jdk1.7之前不支持String）
2. break：代表中止，只会中止当前switch结构的运行，不会影响到其他代码块
3. default：默认选项，当所有的case选项都不满足时，会执行default块中的代码相当于if结构中的else
4. 注意事项：case、default都可以交换位置，但是在没有加break的话，那么case的匹配流程是依据代码顺序的，并继续匹配下面的case直到遇到break或者switch结构结束，而default不会根据代码的位置来执行，会默认放到所有case的最后

(2)switch执行流程

1. 先计算表达式的值，然后去和下面的case常量进行对比
2. 如果表达式的值和case常量值一致的话，那么执行对应的case代码块,否则继续匹配寻找有没有对应的case
3. 如果找到了对应的case，代码块中如果没有break;那么一直往下执行,否则中断switch
4. 如果所有的case常量都不匹配，那么执行default代码块

三、if选择结构和switch结构的不同点

1. 相同点

都能处理多分支的选择结构

2. 不同点

1)、多分支if不但可以处理等值判断，还能处理区间判断

2)、switch只能处理等值判断

3)、switch选择结构可以被多分支if替代,但是switch比一定可以替换多分支结构

第五章

一、为什么要使用循环结构

为了解决重复执行代码的问题

二、循环是什么

重复的做某件事情(执行代码)

三、循环的特点

1. 循环条件
2. 循环操作

四、while循环

//循环变量初始化
while(循环条件){ //循环条件
    //代码块 循环操作
    //循环变量更新
}

/**
*	先判断条件是否满足
*	如果条件满足，则进入代码块执行循环操作
*	如果条件不满足，则中止循环结构
*	记得要循环变量更新，避免死循环
*	特征:先判断，后执行
*/

五、什么是死循环

int number = 1;
while(number<=100){
    //执行循环操作
}

上面是死循环的列子，为什么会造成死循环就是因为循环变量没有做更新操作

导致循环操作一直执行

六、实现一个循环的步骤

1. 分析确认循环操作和循环条件
2. 套用循环结构
3. 防止死循环

七、循环的使用场景

1. while循环用于不确定循环条件的时候使用
2. do-while也是用于不确定循环条件的时候，但不同while，哪怕条件不满足，do-while也会执行一次循环操作

八、do-while循环结构

do{
    //代码块 循环操作
}while(true); //循环条件

/**
*	先执行代码块，在判断条件是否满足
*	如果不满足，则退出循环结构
*	如果满足，则继续进行循环操作
*	特征：先执行，后判断
*/

九、eclipse调试

1. 调试步骤

1. 设置断点

2. 单步调试

3. 发现问题

4. 解决问题

2. 调试按钮

1. F5 单步调试并进入方法体(能进入方法)
2. F6 单步调试(不会进入方法体)

第六章

一、为什么要使用for循环

通常在有确定的次数重复执行，用for结构紧凑

在数组时使用频繁

二、for循环的结构和特点

for(int i=0;i<=100;i++){
    //循环操作
}
/**
*	特点：先判断，后执行
*	流程：
*	1、初始化便变量 
*	2、判断条件是否满足 
*	3、如果条件满足，进入循环体 
*	4、循环变量++ 
*	5、再次执行2、3、4步骤,直到条件不满足后结束循环
*/

三、for循环使用场景

再确认循环次数的情况下优先使用for循环

四、for循环注意点

1. 三个部分都可以省略(会导致死循环)
2. 第1个和第三个表达式可以分开，和while相似
3. 第二个表达式不能省略，判断条件省略，默认判断结果为true，导致死循环

五、循环中的break和continue

break：中止整个循环结构

continue：中止本次循环，并继续下一次的循环

小结：只会针对本层循环,不会影响外层循环

一、final 关键字

final 关键字表示该变量是常量

final 关键字修饰的变量无法进行二次赋值

final 关键字修饰的方法无法重写

final 关键字修饰的类无法被继承

二、三元运算符

// 变量 = 条件 ? 为真的值 : 为假得值
// 一般用于给变量条件赋值
// 三元运算符 还可以嵌套使用(也就是说?和:后面的值也可以是一个三元表达式)
int a = 1<10?10:100;  //单三元运算符
int b = 1<10?(14>3?1:2):100  //嵌套三元运算符

三、逻辑运算符理解

A && B : 如果条件A的结果为true，那么B的条件表达式就不会执行了，两个条件都满足最终结果才是true

A | | B : 如果条件A的结果为true，那么B的条件表达式不执行，两个条件中只要有一个条件满足，那么最终结果为true

四、== 和 .equals()的区别

== ：判断的是变量的内存地址

.equals() ：判断的是变量的字符内容

equalsIngnoreCase() 判断的是变量的字符内容并忽略大小写

注意点：常量值是放在栈里面的,而实例化的对象会在堆内存中开辟新的空间

第八章

一、为什么要使用数组?

用一个名称来存储多个相同数据类型的数据，方便用循环来处理

二、什么是数组

数组：在内存中开辟一串连续的内存空间，可以存储多个数据类型一致的数据

三、数组的定义

1. 标识符：就是数组名称，用一个名称表示一串数据，命名要求和变量一样的，一般变量后加s，例子?(numbers)
2. 数组元素：标识符[元素下标] (表示一个数组中的一个数据)
3. 元素下标：从0开始的一个编号(大于等于0的整数)
4. 元素类型：数组元素的类型(所有数据类型都可以用)
5. 数组长度：数组要在内存空间中开辟多少个连续空间

四、数组的使用

//声明 数据类型[] 数组名称;
String studentNames;
//开辟内存空间 数组名称 = new 数据类型[空间长度];
studentNames = new String[3];
//赋值 数组名称[下标] = 值;
studentNames[0] = "张三";
studentNames[0] = "李四";
studentNames[0] = "王五";
//使用数组
System.out.println(studentNames[0]);

五、数组的常见错误

1. 下标越界：java.lang.ArrayIndexOutOfBoundsException

int[] arrays = new int[2];
arrays[2] = 100; //此处下标越界,下标 >= 空间长度 会出现下标越界的异常

2. 声明数组而不声明空间长度

int[] arrays = new int[]; //此处声明数组但是不声明空间长度，会导致编译报错(数组为初始化)

六、数组的赋值方式

//数据类型[] 数据名称 = {值一,值二,......}; 
//{}只有在一行上才能使用，分开就不行
int[] numbers = {1,2,3,4};

//会编译错误
int [] numbers;          //声明数组
numbers = {1,2,3,4};     //开辟空间并赋值


//数据类型[] 数据类型 = new 数据类型[]{值一,值二,......}; 中括号中不能写空间长度
int numbers = new int[]{1,2,3,4};

//通过数组动态赋值
int[] array = new int[5];
for(int i=0; i<array.length();i++){
    array[i] = new Scanner.nextInt();
}

七、数组输出常用的形式

1. 顺序输出(下标从0到长度-1)

for(int i=0; i < array.length;i++){
	System.out.println(array[i]);
}

2. 倒序输出(下标从长度-1到0)

for(int a = array.length-1;i >= 0;i--){
    System.out.println(array[i]);
}

3. 升序输出(数组元素从小到大排序)

int[] array = new int[]{2,1,3,5,4};
Arrays.sort(array);
for(int i=0; i < array.length;i++){
	System.out.println(array[i]);
}

4. 降序输出(数组元素从大到小排序)，冒泡排序

int[] array = new int[]{2,1,3,5,4,32,46,23,12,34};
int result = 0;
for (int i = 0; i <array.length-1 ; i++) {
		for (int j = i+1; j < array.length; j++) {
       	if(array[i]>array[j]){
              result = array[j];
              array[j] = array[i];
              array[i] = result;
          }         
       }            
}

八、数组中的默认值

类型	默认值
String	null
char	‘\0’
int	0
double	0.0

九、求最大小值

1. 假设第一个值次啊是最大和最小
2. 从第二个开始，依次比较(如果这个大于最大的或小于最小的，就改变最大或最小值)
3. 最后在循环结构外输出最大最小

int[] numbers = new int[]{90,23,45,221,156,1};
int max = 0,min = 0;
//设置最大和最小的变量(擂主)
max=min=numbers[0];
for(int i =1;i<numbers.length;i++){
    if(numbers[i] > max){
        max = numbers[i];
    }
    
    if(numbers[i] < min){
        min = numbers[i];
    }
}
System.out.println("最大值:"+max+"\t最小值:"+min);

九、算法插入排序

1. 把数列按从大到小排序
2. 循环变量数组，判断要插入的数是否大于数组中这个元素，如果是就记录这个插入位置
3. 从倒数第二个开始倒要插入位置这个元素来一次移动位置
4. 改变插入位置这个元素的值

十、为什么要使用二重循环

有时候处理复杂的重复操作，要处理3个班每个班有4个成绩，求每个班的总分和平均分，需要使用到二次循环

十一、什么是二重循环?

一个循环中的循环操作中还有一个完整的循环，循环嵌套:

执行流程：

外层循环执行一次内存循环执行多次,内层循环操作结束后，才会再次执行外层循环,当外层循环结束内层循环也结束

第十一章

一、为什么要学OOP

OOP：Object Oriented Progreamming：面向对象编程

面向过程编程不好代码重用，用OOP代码可重用，维护性好，扩展性强

二、什么是OOP、对象、类

OOP：面向对象编程

对象：客观存在的实体

对象由两部分构成

属性：对象具有的静态特征，并可以有属性值

方法：对象具有的动态行为,说明对象有什么用，能做什么

类： 是对对象的共同特征的描述

封装：把对象具有的属性和方法包括起来，提供接口访问

三、类和对象的关系

类是对象的数据类型 (可以将类理解为自定义数据类型)

对象是类的实例化 (实例就是创建对象)

四、如何定义类和使用对象

定义类：把对象的属性和方法写在类里面

/**
* 访问修饰符 class关键字 类名{
*	//定义n个属性
*	数据类型 属性名;
*	//定义方法
*	访问修饰符 返回值 方法名(){
*		//DoAnything
*	}
*}
*/
public class HelloWorld{
	//属性
   public String context;
   
   //方法
   public void sayHello(){
       
   }
}

使用对象：给对象的属性赋值，调用对象中的方法

/**
* 如何创建对象
* 类名 对象名 = new 类名();
* 如何使用对象的属性
* 对象名.xxx = xxxx;
* 如何使用对象的方法
* 对象名.xxx();
*/

public class Main{
   public static void main(String[] args){
       HelloWorld helloWorld = new HelloWorld();
       helloWorld.contenx = "hello java!!!";
       helloWorld.sayHello();
   }
}

五、类和对象的命名规则

1. 类的命名规则（帕斯卡命名法）

1）、不能使用java中的关键字

2）、不能使用符号，下划线和$除外

3）、不能用数字开头

注意：每个单词首字母大写，类名取名要做到见名知意

2. 对象的命名规则（驼峰命名法）

1）、不能使用java中的关键字

2）、不能使用符号，下划线和$除外

3）、不能用数字开头

注意：首个单词字母小写其后每个单词首字母要大写，建议对象名和类名一致，类名取名要做到见名知意

六、引用类型的默认值

类型	默认值
String	null
char	‘\0’
int	0
double	0.0
对象	null

第十二章

一、类的成员有哪些

方法(成员方法)和属性(成员属性)

二、类的方法第一和使用

方法:是属于类的行为操作,有的操作有响应结果

三、定义方法

/**
*  访问修饰符 返回值类型 方法名(){
*		//方法体
*  }
*/
public void show(){
    //do anything;
}
//注意：方法中不能嵌套方法，但是可以调用其他方法.

三、访问修饰符

1. public 公开的，内部类或者外部类都能访问
2. private 私有的，只有内部类可以访问，外部类无权访问
3. protected 受保护的, 类自己,派生类(子类)可以访问

四、返回类型

解释：说明方法执行后，是否有结果返回到方法调用的地方

返回类型的取值

基础类型：byte、short、int、long、float、double、char、boolean

引用类型：String、数组、对象数组、类（自己定义的类）、集合等其他引用类型

五、方法名命名规则（Camel命名法）

1）、不能使用java中的关键字

2）、不能使用符号，下划线和$除外

3）、不能用数字开头

注意：每个单词首字母大写，类名取名要做到见名知意

六、如何选择判断方法是否需要返回值类型

判断方法是否需要给调用者一个回复，如果不需要那么使用void，否则使用对应的返回值类型

如果确认方法不需要返回值时，要注意以下几点

1. 方法的返回值类型为void
2. 可以单独使用return关键字,但是return后面不能添加返回值

如果确认方法需要返回值时，要注意以下几点

1. 返回值必须和返回值类型相同或者类型兼容
2. 方法的返回值类型不能为void

七、关于方法的调用

1. 如果是调用本类的方法，直接写方法名即可，调用外部类的方法需要先创建对象，再通过对象名.方法名()调用

2. 如果方法有返回值那么需要声明与方法返回类型对应的变量接收，也可以不用定义变量接收，但是既然有返回值那么必定需要用到返回值做一些其他操作，所以有返回值的方法推荐声明变量接收，不然使用返回值的方法就没有意义了。反之，没有返回值的方法，直接调用即可。

八、成员变量和局部变量

名称	说明	作用域
成员变量	类里面方法外面定义的变量，	整个类里面都可以使用
局部变量	方法、过程（if、switch）里面的变量	本方法过程可以使用

九、成员变量和局部变量区别

名称	定义位置	作用域	初始值
成员变量	方法外	整个类	有
局部变量	方法过程内	方法过程内	无

十、关于成员变量和局部变量的总结

1. 不同的成员变量可以变量名一致
2. 局部变量可以和成员变量名称一致
3. 在方法中使用同名的变量时，优先使用局部变量，如果要使用成员变量那么要使用关键字this

第十三章

一、为什么要使用有参方法

有时候方法需要使用外部的材料才能实现操作，这个外部材料就是参数

例如：登录方法需要传递用户名和密码，方法才能正常执行

二、有参方法的定义和使用

/**
*	访问修饰符	返回类型	方法名(形参列表){
*		//方法体
*	}
*/
public class UserLogin(){
    public boolean login(String username,String password){
        if(username.equals("root") && password.equals("1234")){
            return true;
        }
        return false;
	}
}

三、如何调用有参方法

//1、创建对象
UserLogin userLogin = new UserLogin(); 
//2、调用方法
String username = "root";
String passwrod = "1234";
boolean isLogin = userLogin.login(username,password);

四、什么是形参、实参?

1. 形参

定义在方法中的参数列表就是形参

形参就是一个比较抽象的一个、多个参数，没有具体的值

2. 实参

调用方法时传递的参数就是实参

实参就是一个、多个具体的参数，有具体的值

五、有参方法的注意事项

1. 实参与形参的数据类型要一致
2. 实参与形参的顺序要一致
3. 实参与形参的个数要一致

第十五章

常用的字符串方法

方法名称	描述
length()	获取字符串的长度
concat()	拼接字符(有返回值) +拼接字符会造成内存浪费
indexOf()	获取搜索字符、字符串的索引(有返回值),从左到右搜索,没找到返回-1
laseIndexOf()	获取搜索字符、字符串的索引(有返回值),从右到左,下标位置还是从左到右,没找到返回-1
substring(startIndex,endIndex)	截取字符串(截取开始位置到结束位置,结束位置不包含)
substring(index)	截取字符串(从开始位置截取到结束,开始位置会包含)
trim()	去除字符串前后空格(中间的不会去除)
replace()	替换字符
split()	分割字符串为字符串数组

//创建SringBuffer对象

StringBuffer strBuffer = new StringBuffer();

//赋值方式一
StringBuffer strBuffer = new StringBuffer("");
//f