新手热门JAVA----随手笔记（上册）（有需要什么的可以私聊我qq1442828743）
2024-05-26 08:16:23
学习方法：
1、记笔记。
2、代码加注释
3、问
=============================================day1============================================
一、Java简介：
1、Java是一门程序设计语言。
自然语言
（程序设计语言）
机器语言
2、Java历史：
1）1990年底 Sun公司 Green 项目组，James Gosling 詹姆斯 高斯林
2）1992年 Oak语言诞生
3）1993年 第一次投标失败
4）1994年 Oak 改名为 Java ，在互联网行业的冲击下，被业界所认可。
5）1995年5月23日 Sun公司 正式发布Java 1.0
6）2009年4月20日 被Oracle 收购 ，市值74亿。
3、Java语言特点：
1）纯面面向对象
2）简单性 PK c++
3）跨平台
4、Java语言运行机制：
源文件（.java）---->编译器----->字节码文件（.class）---->JVM---->解释器---->CPU运行
二、Java开发前准备
1、搭建环境：
1）JRE（Java Runtime Environment）：Java运行环境 ，包含 JVM，解释器。
2）JDK（Java Developement Kit ）：Java开发工具包 ，包含 JRE、类库、工具、编译器等。
2、安装JDK：
*安装目录不允许出现中文
3、配置环境变量
右键计算机---->属性---->高级系统设置--->环境变量--在系统变量中新建环境变量。
JAVA_HOME ：JDK安装目录
(修改) path : %JAVA_HOME%\bin
ClassPath : .
三、第一个Java程序（HelloWorld）
1、新建源文件：xxxx.java 2、在源文件中进行编码
关键字 类名
public class HelloWorld{
主函数（程序的入口函数）
public static void main(String args[]){
向控制台输出一句话 ： 你吃了吗？
System.out.println("你吃了吗？");
}
}
3、将.java文件编译成.class文件
javac 文件名.java
4、执行.class文件
java 类名
*注意：
1. public class 类名：代表公开类，公开类的类名要与文件名一致，一个源文件中只能有一个公开类。
2.class 类名 ：非公开类，允许类名与文件名不一致，一个源文件中可以有多个非公开类。
3.先编译： javac 文件名.java
后解释运行：java 类名
四、包（package）：指定源文件编译后的.class文件保存在哪一个文件夹下
1、package 包名，放在代码的第一行。
2、编译时使用 javac -d . 文件名.java
3、运行时使用 java 包名.类名
4、引入包 import 包名;
多包 import 包名.包名.......;
import 包名.*; 引入 该包下的所有内容
五、注释：一段描述性文字，增加代码可读性，不参与编译过程。
1、单行注释： //注释文字
2、多行注释：/* 注释文字 */
3、javadoc ：/** 注释文字 */
六、标识符：Java中各个组件的命名规则
1、语法 ：由数字、字母、下划线、$组成，数字不能开头。
2、编程习惯：望文知意
1）包名：全小写 例：helloworld
2）类名：单词首字母大写 例：HelloWorld
3）变量名、函数名：驼峰命名 例：helloWorld
4）常量名：全大写 例：HELLO_WORLD
七、变量：
1、变量是JVM内存当中的一块空间，用于保存数据。
2、变量类型：
1）基本类型：
类型 占用空间 数据范围 例
byte 1b -2^7--2^7-1 byte b = 1;
short 2b -2^15--2^15-1 short s = 100;
int 4b -2^31--2^31-1 int i = 200;
long 8b -2^63--2^63-1 long l = 300L;
float 4b float f = 0.35F;
double 8b double d = 0.8;
boolean true | false boolean bb = true;
char 2b 任何字符 char c = 'A';
char c1 = 79;
2）对象类型：
String 字符串 自面值："HelloWorld"
3、使用变量
1）变量的声明：
int a; 声明一个 int 类型的变量，变量名为 a
String str; 声明一个 String 类型的变量，变量名为 str
2）变量的赋值：
int a;
a = 10; 给变量a赋值为10
3）声明同时赋值
int a = 200;
4、局部变量：
1）定义在函数内部的变量
2）重合范围内变量名不允许重复
3）必须先赋值后使用
4）局部变量的使用范围，在定义它的代码块开始，到代码块结束。
八、运算符&表达式
int a = 10;
int b = 2;
1、数学运算符： + - * / %（求余） ++ --
1） a + b -----> 12
2） a - b -----> 8
3） a * b ----->20
4） a / b -----> 5
5） a % b -----> 0
6） a++、++a ------>a的值为 11 (a=a+1)
7） a--、--a ------>a的值为 9 (a=a-1)
2、赋值运算符：= += -= /= *= %=
1） a = b -----> 把b的值赋给a
2） a += b -----> 把 a+b的值赋给a （a = a+b）
3） a -= b -----> a的值为 8 （ a = a-b）
4） a /= b -----> a的值为 5
5） a *= b -----> a的值为 20
6） a %= b -----> a的值为 0
3、逻辑运算符：< > == && || !
运算出的结果全部为 boolean 类型
1）a大于10 并且小于 b
a>10 && a<b ----->false
2）a等于10 并且 大于b
a==10 && a>b ---->true
3）a不等于10
a != 10 ---->false
4）结果取反
! (a == 10) -----false
4、三目运算符
语法：
（布尔表达式） ? 表达式1 : 表达式2;
int x = a>b ? 10: 300;
流程：
当布尔表达式为true时 结果为 表达式1，反之结果为 表达式2
5、强制类型转换
当较大数据类型给较小数据类型赋值时，会出现丢失精度的错误，此时需要强制类型转换
语法：double b = 20.8;
int a =(int) b;
==================================day2=================================================
*Scanner 可以让用户从控制台输入一个数字或字符，输入的字符会为程序中的一个变量赋值。
使用步骤：1、引入包：import java.util.Scanner;
2、 创建Scanner:
Scanner sc = new Scanner(System.in);
System.out.println("请您输入两个整数：");
int i = sc.nextInt(); --从控制台接收一个int类型的值
double b = sc.nextDouble();--从控制台接收一个double类型的值
String str = sc.next(); --从控制台接收一个字符串
===============================================================================
一、流程控制
1、if
语法：if( 布尔表达式 ){
当布尔表达式为true时，执行该内容
}
2、if-else if
语法：if( 布尔表达式 ){
}else if( 布尔表达式 ){
当不满足if条件时判断 else if中的表达式是否为真
}
3、if-else if -else
语法：if( 布尔表达式 ){
}else if(布尔表达式){
}else{
}
4、switch
语法：switch( 整形变量|整形表达式 ){
case 值1: 要执行的代码;
case 值2：要执行的代码;
default : 都不满足时执行的代码;
}
*整形变量包括：char byte short int
jdk 7.0以后 支持 String
=========================day2 PM===================
循环结构
定义：重复且有规律的做一件事情
三要素：循环初值 循环结束条件 循环递增量
一、while循环
语法： while(布尔表达式){
//循环体语句
}
当布尔表达式为true的时候，则执行循环体语句，执行完后再判断布尔表达式是否为true；
如果为false，则跳出循环，执行后面的语句。
1.打印100遍HelloWorld
注意：缺少循环递增量会造成死循环。
2.计算100以内的偶数的个数。
3.输入一个整数，判断它是几位数？
二、do...while 循环
语法： do{
//循环体语句
}while(布尔表达式);
先执行循环体语句，再判断布尔表达式是否为true，如果为true，则再次执行循环体语句。
如果布尔表达书为false，跳出循环，继续执行下面的语句。
三、for 循环
语法： for(初值;循环结束条件;循环递增量){
//循环体语句
}
先附初值，判断循环结束条件，如果条件为true，则执行循环体语句，执行完循环体语句后，
再执行循环递增量，再判断循环结束条件，如果为false，则跳出循环，继续往下执行。
小结：1.while 先判断，再执行。 0-多次。
do...while 先执行，后判断。 1-多次。
2.for ,知道执行多少次的情况。
次数未知的情况，用while /do...while
四、循环控制语句
break;//跳出整个循环,可以跳出死循环！
continue;//跳出本次循环
五.循环嵌套
for(){
for(){
//循环体语句
}
}
1.打印一个99乘法表
2.打印一个三角形
*
***
*****
*******
*****
***
*
=======================================day3===============================
函数：
一、函数的作用：
1、减少冗余代码
2、提高程序复用性
3、方便维护
二、语法：
1、声明函数：
public static 返回值类型 函数名 (参数表)
1）参数表：函数中一个有效的局部变量，是函数的入口
参数表中可以定义多个 形参，要求调用者使用该函数时，传递形参类型相同的字面值。
定义多个参数：(String str , int a)
(String s,int b,double c,double d .......)
*注意调用函数时，传递的数据类型、个数、位置需要全部匹配
2）返回值类型：8种基本类型，对象类型。
*一个函数如果是非void返回值类型，那么这个函数就必须 return 一个结果。
3）函数返回结果：return 返回值;
*返回值的类型要与返回值类型相同。
4）控制void函数执行流程：return;
2、函数实现：
{ }
3、使用函数：
函数名(参数表);
4、函数的递归
=============================day4 AM============================
数组：
是一个对象类型（引用类型）；
代表一块连续的内存空间，用于存储相同类型的数据。
注意：连续 相同类型 数组的长度不可变
一、数组的定义
1.数组的声明
数据类型 [] 变量名;
int [] a;//声明数组
a= new int[5];//给数组分配空间，定义长度为5、
int [] a=new int[5];
int[] a={1,4,5,2};//声明数组，给数组赋值。
int[] a=new int[]{1,4,2,6};//声明数组，根据{}中数组的个数，分配空间、
注意：
1）显示初始化，要和声明数组一起进行。
2）int[] a=new int[]{1,4,2,6},[]中不能指定大小。
2。默认值
数值类型：0或者0.0
布尔类型：false
char类型：'\u0000' 或者 ''空字符
String类型：null
注意：数组下标越界异常；
二.数组的使用
1.下标
范围： 0 ~ 数组的长度-1
2.遍历(重点)
for(int i=0;i<a.length;i++){
System.out.print(a[i]+" ");
}
System.out.println();
三、数组的扩容
1.大搬家
思想：重新定义一个数组，把原有数组的值赋值给新数组。
for(int i=0;i<arr.length;i++){
b[i]=arr[i];
}
2.API的方法
System.arraycopy(原数组,原数组的起始下标,新数组,新数组的起始下标,长度);
=====================day4 PM===================
四.二维数组
一维数组的数组
int [][] a=new int[3][2];
二维数组中第一个[]控制的高纬长度（必须写）
二维数组中第二个[]控制的低纬长度（可以不写）
int[][] a={{1,2,3},{4,5,6},{7,8,9}};
五、排序
1.冒泡排序
排序思想（以从小到大排序为例）：两个相邻的数比大小，
大的放在前面，小的放在后面,每一次冒泡都会产生一个最大的数。
2.，选择排序
排序思想（以从小到大排序为例）：每一次选择出一个最小的元素，
放到序列的起始位置，然后依次从后面选择最小的元素，往后排；
3.java.util.Arrays.sort(a);
=========================================day5========================================
面向对象
一、什么是面向对象思想？
1、面向过程编程思想：自顶向下，逐步求精。
2、面向对象编程思想：从客观世界出发。
二、什么是对象？
1、一切客观存在的事物都是对象。
2、对象：属性 有什么
方法 能干什么
3、对象的属性有可能是另一个对象。
4、对象调用另外一个对象的方法，完成某些功能。
三、计算机中的对象代表了客观世界的对象。
计算机中的对象就是一组不可分割的数据，保存在JVM中。
四、使用面向对象思想，解决客观问题？
1、找到能够解决问题的对象
2、对象间相互配合
五、面向对象的优势：
各司其职： 对象应该保持简单，由简单的对象组成复杂的系统。
弱耦合性：对象与对象之间的联系应该保持弱耦合。
可重用性：对象可以重复使用
可扩展性：再原有对象的基础上，扩展出新的对象。
六、类：对象的模板，人对客观事物的抽象。
关键字 class 类名
1、属性：实例变量|成员变量|全局变量
1）定义位置，类的里面方法的外面。
2）有默认值（0 false null）
3）作用范围至少是全类内部
4）允许实例变量与局部变量命名冲突，使用时局部变量优先。
2、方法
1）方法声明：（能做什么）
修饰符 返回值类型 函数名 (参数表) 抛出的异常
public
2）方法的实现 （怎么做）
3）方法的重载（Overloading） 一个类中，可以有多个重名的方法，从参数表 数量、类型、位置上区分。
函数名相同，参数表不同，返回值无要求。
参数表不同：数量
类型
位置
七、创建对象：
1、语法：类名 引用名 = new 类名();
例：Student stu = new Student();
2、对象是JVM中的一块内存空间
八、使用对象：
1、使用属性：
1）访问属性：引用名.属性名;
2）设置属性：引用名.属性名 = 值;
2、使用方法：
引用名.方法名(参数);
九、构造方法（构造器）
1、方法名和类名相同
2、没有返回值类型
3、不允许手工调用，只会在对象构造过程中自动调用一次。
十、this
1、this.属性名 ：使用当前对象属性，区分局部变量和成员变量。
this.方法名：使用当前对象的方法。
2、this() ：调用本类的其他构造方法，必须出现在构造方法的第一行。
十一、创建对象的过程：
1、分配空间 属性被赋予 默认值 (null false 0 0.0)
2、初始化属性 属性被赋予 初始值 (属性：String name="张三";)
3、调用构造方法 属性被赋予 构造参数
十二、java中数据的传递规则
1、简单类型传值
2、对象类型传引用（地址）
==========================================day6===================================================
面向对象三大特性
封装：明确对象的边界，由边界起到保护内部属性的作用。
数据隐藏：
一、修饰符：public 公开的，随意获取，随意设置
private 私有的，只能本类使用
二、提供get/set： get方法用于获取属性
set方法用于设置属性
三、封装步骤：
1.属性私有
2.提供公开的get、set方法
=======================================day6pm=======================================
继承
从父类--子类 一般----特殊
子类可以继承子类可调用的方法。
一、访问权限修饰符：
关键字 使用范围 能否被继承
private 本类内部 不能
(default) 本类+同包 同包子类可以继承
protected 本类+同包+子类 可以继承
public 所有 可以继承
从严到宽
二、方法覆盖（Override）
1.作用：子类用特殊的方法实现，替换掉父类继承给它的一般实现。
2.语法：方法名、返回值类型、参数表一致，访问权限修饰符相同或更宽。
三、super
super. 访问父类被覆盖的属性或方法
super() 调用父类哪个构造方法，写在子类构造方法的第一行
四、对象的创建过程：
1.分配空间，属性被赋予默认值。
2.构造父类对象。
3.初始化本类属性，属性被赋予初始值。
4.调用本类构造方法。
C ---- B -----A
分配空间
初始化A类属性
调用A类构造方法
初始化B类属性
调用B类构造方法
初始化C类属性
调用C类构造方法
**Java中 继承关系 为 单继承，每个类只允许有一个父类。
一个父类可以有多个子类。
==================================day7==========================================
多态
子类的对象可以看作是父类的对象，子类是特殊的父类。
子类对象可以放入父类引用。
例如：Animal a = new Dog(); Dog是Animal的子类
1.对象类型不变
2.只能对引用调用其引用类型中声明的方法
3.运行时，会根据对象实际类型找子类覆盖后的方法
子类引用赋值给父类引用 可以直接赋值
Dog d = new Dog();
Animal a = d;
父类引用赋值给子类引用 必须强制类型
转换 保证编译通过，运行时可能产生类型转换异常。
Animal a = new Dog();
Dog d =(Dog) a;
关键字：
引用 instanceof 类名 值为 boolean 类型
判断引用中保存的对象是什么类型
多态使得程序变得更通用，说话、办事越是针对父类越通用。
多态能够屏蔽众多子类之间的差异，使得程序更加灵活。
多态用在方法参数上：
m( A a)：形参可以是父类类型，实参为形参的子类。
多态用在方法返回值上：
A m()：m方法完全可以返回一个 A 的子类对象。
=================三大修饰符===============
static 、final 、abstract
一、static （静态）
1.属性（实例变量）
static 修饰的属性 称为 静态属性，也叫类变量。
语法： static 访问修饰符 类型 变量名；
特点：static修饰的属性被所有对象共享（与对象无关）
使用：1）new 对象
对象名.属性；
2）类名.属性（建议使用）
2.方法
static 修饰的方法 称为静态方法，也叫类方法；
语法: static 访问修饰符 返回值类型 方法名（形参列表）{}
使用:
1)对象名.方法名；
2）类名.方法名；（建议使用）
注意：1）static 方法中不能使用 this 或者 super
2)静态的方法不能直接调用非静态的方法，可以直接调用静态的方法。
静态的方法可以简介调用非静态的方法（使用new 对象的方法）。
3）static方法可以被覆盖，但是static方法，只能覆盖static方法，但是没有多态。
4）引用 被覆盖的static方法时，引用本身的方法会被执行。
3.初始代码块
定义位置：类以内，方法以外。
初始代码块：用于创建对象时候，按照定义的顺序进行初始化工作。
static修饰的初始化代码块，称为 静态初始化代码块。
静态初始化代码块：用于类加载的时候，按照定义的顺序进行初始化工作。
4.类加载
定义：当JVM第一次运行某个类时，会提前在classpath路径下，找到这个类所对应的class文件，
并进行类的读取，获取到这个类的相关信息（属性，方法。返回值类型...）,
把相关的类信息保存在内存中，类加载只进行一次；
类加载的时机：
1）创建对象时，进行类加载；
2）调用该类静态成员（属性。方法）时，进行类加载。
3）创建子类对象的时候，也进行类加载。
二。final （最终的）
1.变量（局部变量，类变量，实例变量）
final 修饰的变量，称为最终变量，只能赋值一次，且不可修改
注意：
1）final 修饰的实例变量，不再提供默认值，
会在声明 或者 构造方法中进行赋值。
若果再构造方法里赋值，所有构造方法中都必须赋值。
2）final 修饰类变量。不再提供默认值、
会在声明 或者 静态初始化代码块中进行赋值。
2.方法
final 修饰的方法为最终方法 ，可以被继承，不能被覆盖。
3.类
final 修饰类，为最终类 ，不能被继承。
三、abstract （抽象） 不完整
1.方法
抽象方法：只有声明，没有实现（意味着{}都没有）。
public void xxx();
2。类
抽象类，不能实例化。
注意：
1）抽象类，不能创建对象。但是可以声明引用。
2）子类继承 抽象类， 必须实现父类中所有的抽象方法，除非子类还是抽象的。
3）抽象类中，可以有抽象的方法，也可以非抽象的方法。
4) 有构造方法，当子类对象创建时，调用
特点：强制使用多态。
==================================================================
接口: interface
特殊的抽象类:
抽象类:
不完整的类
接口:
方法： 所有的方法公开抽象方法;public abstract 可省略
属性： 所有的属性都是公开静态的常量;public static final 可省略
构造方法: 没有
interface IA{
public static final int AGE = 0;//常量名:全部大写
public abstract void method();//
}
声明接口语法:
对比:abstract class MyClass{
//一般方法
//抽象方法
}
interface MyInterface{
//方法:
//属性
}
实现类使用接口
class Xxxx implements 接口{
}
*接口有抽象方法，实现抽象方法；
*一个类可以extends 父类同时还能实现implements多个接口
class Ca extends SuperClass implements IA,IB,IC{
//将IA,IB,IC接口中方法全部实现
}
作用:
【定义标准】
将标准的[实现者]和标准的使用者分离;
[变相实现多继承]
一个类可以实现多个接口同时继承一个父类
//造一个灯泡，造台灯，用台灯点亮灯泡;
问题:一种台灯只能点亮一种灯泡?
解决:
1.将所有灯泡的接口统一标准:
2.设计台灯，符合灯泡的标准;
制定标准-----弱耦合
作业:
11题，17题(思考)
=========================内部类======================
定义：定义在一个类的 内部的类
是编译时的一个概念，编译后会产生相应的.class
1.成员内部类
相当于成员变量，定义在类以内，方法以外。
1）成员内部类创建对象时，先创建外部类的对象，再外部类对象的基础上创建内部类对象。
Outer o1=new Outer();
Outer.Inner in= o1.new Inner();
2）this. 当前对象的成员。 想用父类的属性；外部类类名.this来调用。
3）成员内部类中不能定义static 成员，
原因（内部类创建对象必须依托于外部类的对象，static是与对象无关的，矛盾了！）
特点：不破坏封装的前提下，使用外部类的私有属性。
2.静态内部类
相当于类变量，定义在类以内，方法以外。
1）创建内部类对象时，不需要先创建外部类对象，可以直接创建内部类对象、
Outer.Inner in=new Outer.Inner();
2）静态内部类中，只能调用外部静态的成员。
3）静态内部类中定义的变量与外部类定义的变量重名时，
可以用 类名.成员调用外部类成员。
3.局部内部类
相当于局部变量，定义在方法以内。
1）局部内部类，和局部变量的作用范围是一样。
2）局部内部类创建对象时，必须在它的作用范围内；
Inner in =new Inner();
3）局部内部类，要想使用外部类方法中的属性，必须定义为final的。
4.匿名内部类
特殊的内部类。
1）只创建一个对象。
2）这个必须 从 父类/父接口 中 进行 继承/实现
return new Animal(){
public void eat(){
System.out.println("========够吃骨头======");
}
};
父类/父接口 应用名 = new Animal(){
public void eat(){
System.out.println("========够吃骨头======");
}
};
=======================集合（II）===================
泛型集合：强制集合中的类型必须统一。
为了防止类型转换异常。
工具类（Collections）：提供了一些对集合/数组的一些简单操作：排序。
public static void reverse(List<?> list)//进行倒序
public static void shuffle(List<?> list)//随机产生顺序
public static void sort(List<T> list)//按照一定的规则进行排序
需要排序规则
lang包中的规则：Comparable接口
实现compareTo方法；
//比较 this 和 指定对象stu的大小
//this > stu 返回>0
//this < stu 返回<0
//this == stu 返回=0
public int compareTo(Student stu){
if(this.age >stu.age)
return 1;
else if(this.age<stu.age)
return -1;
else {
return 0;
}
}
三、set接口
1、特点
元素无顺序，无下标，不可以重复。
2、方法
从Collection继承来的所有方法。
3、遍历
for-each
迭代器
4、实现类
1）HashSet
如果要实现HashSet中元素的值不重复。
1，覆盖HashCode
确保相同的对象 返回相同的int值（HsahCode值）
为了提高效率，尽量做到不同的对象 返回不同的int值。
通常把对象的属性值加到一起，如果是对象类型 调用该对象的HashCode方法。
2.覆盖equals
当在同一位置上已经存在集合元素时，会再调用equals方法，判断2个对象的内容是否相同，
如果相同则拒绝加入集合。
2）TreeSet
实现了SortedSet接口，也是Set的子接口
自动进行排序。
排重：实现java.lang.Comparable接口,实现接口中的方法compareTo方法。如果返回值0，重复了就不会添加。
四、Map接口
1.特点
存放任意的键值对（Key----Value）。
键：无序，无下标，元素不可重复。（键是唯一的）
值：无序，无下标，元素可以重复。
2.方法
V put(K key, V value)//往map中添加一个元素，假如键已经存在，会覆盖原有的值
V remove(Object key)// 根据键删除对应的键值对。
V get(Object key)// 根据键获得对应的值。
boolean containsKey(Object key) //判断Map集合中是否包含指定的键。
boolean containsValue(Object value) //判断Map中是否包含指定的值。
3.遍历
1.键遍历
Set<K> keySet()
2.值遍历
Collection<V> values()
3.键值对
Set<Map.Entry<K,V>> entrySet()
4.实现类
1）hashMap（假如键为自定义类型，需要覆盖hashCode和equals方法，保证键唯一）
jdk1.2 线程不安全，快
允许key和value都为null
2) hashTable
jdk1.0 线程安全，慢
允许key和value都不为null
3)Properties
是hashTable的一个子类，要求key和value必须都为String类型。
多数用于 读取配置文件。
4)TreeMap
实现了SortedMap接口，是Map的子类。会根据键进行排序。
实现Compareble接口，实现里面的compareTo方法。返回值是0，覆盖了原有的值。
集合小结
Collection
list Set
有序 无序
有下标 无下标
可以重复 不可重复
Map
键值对
键：无序，无下标，不可重复（键唯一）
值：无序，无下标，可以重复
LinkedList和ArrayList的区别？
链表 查询慢，增删快
数组 查询快，增删慢
ArrayList和Vector的区别？
1.2 线程不安全，快，轻量级
1.0 线程安全，慢，重量级
HashMap 和Hashtable的区别？
jdk1.2 线程不安全，快
允许key和value都为null
jdk1.0 线程安全，慢
允许key和value都不为null
Hashtable和Properties的区别？
泛型集合的好处？
数据安全。强制集合中的类型必须统一
HashSet和TreeSet分别如何实现 元素不重复？
Collection和Collections的区别？
list:
1.下标遍历
list.add();
for(int i=0;i<list.size();i++){
}
2.Iterator迭代遍历
Iterator in=list.interator();
while(in.hasNext()){
Obeject o=in.next();
}
3.for(Object o: list ){}
Set
Map:
1.键遍历
Set<K> set=map.keySet()
2.值遍历
Collection<V> con=map.values()
3.键值对遍历
Set<Map.Entry<K,V>> entrySet =map.entrySet();
========================异常==========================
异常：程序运行过程中，出现的错误，例外。
异常处理：异常发生之后，会执行一段预先写好的代码，减少损失。
一、异常分类
Throwable
|-Error 错误，底层代码出现严重问题，无法避免，程序员无法解决，无需程序员来解决
|-Exception 异常
|-RuntimeException 运行时异常/未检查异常 编译时忽略 可以避免 可以处理也可以不处理
|-IndexOutOfBoundsException
|-NullPointerException
|-ClassCastException
|-非RuntimeException 非运行时异常/已检查异常 编译时会出错，必须要处理
二、异常的产生和传递
1.异常的产生
1）自动产生
程序运行时，遇到出错的代码，自动产生异常，程序自动终止。
2）手动产生
throw new 异常名称（实参）；//手动抛异常，必须定义在方法以内。
程序执行到手动抛异常，会把 throw 后面 new 的异常对象抛出，程序自动终止。
2.异常的传递
异常堆栈信息：
Exception in thread "main" java.lang.ArithmeticException: / by zero
at Day17.TestException.m3(TestException.java:24)
at Day17.TestException.m2(TestException.java:19)
at Day17.TestException.m1(TestException.java:14)
at Day17.TestException.main(TestException.java:9)
程序因异常终止后，会以 函数的调用的反方向 进行传递。
三、异常的处理【重点】
1.消极的处理（声明异常）
语法：（定义在方法声明的后面）
修饰符 返回值类型 方法名（形参列表） throws 异常的名称1, 异常的名称2... {
//方法体
}
使用throws 只是消极的把异常继续往后传递，并没有解决问题。
2.积极地处理（捕获异常）
try{
//可能出现异常的语句
}catch(IOException e){
//处理异常的语句
}finally{
//一定会被执行。
}
注意：1）try后面可以跟多个catch,但是父类异常必须放到后面。
2）catch可以捕获异常，可能出现非RuntimeException或者runtimeException
3)finally 中的语句，一定会被执行。
try...catch...
try...catch...finally...
try...finally...
try...catch...catch...catch...
try...catch...catch...catch...finally...
try...(try...catch...finally...)...catch...(try...catch...finally...)...finally...(try...catch...finally...)...
消极处理和积极处理是可以搭配使用。
四、自定义异常类
public class MyException extends Exception {
MyException (){}
MyException(String msg){
super(msg);
}
}
五、方法的覆盖
1.语法要求：方法名，返回值类型，形参列表必须相同。
2.访问修饰符 可同或更宽。
3.子类的方法中，不允许抛出更多、更广的异常。
=======================================线程=========================================
一、概念
进程：操作系统中，并发执行的任务。
并发执行原理：宏观并行，微观串行。
线程：在一个进程中，并发执行的多个程序逻辑。
主线程：main函数。
特点：多线程中，先后顺序不确定。
不因任何线程结束而结束。
线程的组成：
1）CPU 操作系统（OS）选中。
2）内存分配
栈空间 局部变量 独立
堆空间 new 对象 被所有的线程所共享。
3）代码
1.继承 Thread 父类。
覆盖run方法。
创建线程对象：MyThread1 t1 = new MyThread1();
启动线程：t1.start();
2.实现Runnable 接口
实现run方法
创建线程对象：
//创建目标对象
Target t = new Target();
//创建线程对象
Thread t2 = new Thread(t);
启动线程：
t2.start();
二、线程的状态
详情,请看线程状态图
三、线程同步/安全[重点]
临界资源：多线程并发时，共享的一个对象
原子操作：要执行的代码 作为一个整体，如果执行则执行，如果不执行则不执行。
线程同步/安全：多线程并发时，为了保证临界资源的正确性，而不破坏 代码的原子操作。
线程同步的2种方法：
synchronized
1)同步代码块
使用在方法内部，语法：
synchronized (临界资源对象){
//原子操作
}
线程 只有获取到 临界资源对象的锁标记，才能执行后面{}中的代码，
并且必须等{}中的所有代码都执行完，才释放该对象的锁标记。
如果 没有获取到 临界资源对象的锁标记，则该线程处于 等待状态（锁池状态）。
直到拿到锁标记，才能执行代码块。
2)同步方法
synchronized 修饰方法
synchronized 返回值类型 方法名(形参){
//原子操作
}
等同于:
synchronized (this){
//原子操作
}
新手热门JAVA----随手笔记（上册）（有需要什么的可以私聊我qq1442828743）相关推荐
- java随手笔记 接口的理解
接口 接口在java中将方法设计和方法实现.打个比方,有哺乳动物IMammal,猫cat,狗dog,这样我们就能将哺乳动物IMammal设计成接口,然后在里面设计相应的speak方法, ...
- 配置多个git账号_docker随手笔记第七节 jenkins通过git部署java微服务插件安装
docker随手笔记第一节 docker概念及安装 docker随手笔记第二节 docker常用命令解析 docker随手笔记第三节 docker构建java镜像 docker随手笔记第四节 dock ...
- docker 安装git_docker随手笔记第十二节 jenkins+docker+nginx+纯静态页面配置
docker随手笔记第一节 docker概念及安装 docker随手笔记第二节 docker常用命令解析 docker随手笔记第三节 docker构建java镜像 docker随手笔记第四节 dock ...
- docker nginx配置_docker随手笔记第十二节 jenkins+docker+nginx+纯静态页面配置
docker随手笔记第一节 docker概念及安装 docker随手笔记第二节 docker常用命令解析 docker随手笔记第三节 docker构建java镜像 docker随手笔记第四节 dock ...
- 【JAVA学习笔记】
该笔记是学习bilibili中狂神说大咖的随手笔记,主要是由文字,代码和图片结合记录,有利于回顾(路漫漫其修远兮,吾将上下而求索),希望大家多写代码,多写笔记,多思考,最重要的就是坚持.推荐该大咖网址 ...
- Javassist 官方文档 随手笔记
Javassist 官方文档 随手笔记 Javassist.CtClass Class search path Introspection and customization \$0, \$1, \$ ...
- java学习笔记(三)：前端miniUI控件库入门
java学习笔记(三):前端miniUI控件库入门 最近在一家公司实习学习,一上来就需要学习了解相关的前端内容--miniUI.而这个内容自己本身并没有了解学习过,上手也是遇到了不少的问题,于是想把自 ...
- 新手参加java培训都学什么
互联网的强大使得很多IT技术变得越来越吃香,java技术就是其中的一种,很多人都开始学习java技术,下面小编就为大家分享一些新手参加java培训都学什么?希望能够给零基础的学员带来一些帮助. 新手参 ...
- java学习笔记11--Annotation
java学习笔记11--Annotation Annotation:在JDK1.5之后增加的一个新特性,这种特性被称为元数据特性,在JDK1.5之后称为注释,即:使用注释的方式加入一些程序的信息. j ...
最新文章
- ceph-objectstore-tool工具使用详解
- OpenCV对象检测实例
- 转：eclipse Failed to load JavaHL Library.
- vm显示打不开 /dev/vmmon：Broken pipe
- android studio 65536错误的解决
- 基于.NET SingalR,LayIM2.0实现的web聊天室
- python virtualenv
- Spring Cache 介绍
- 学计算机软件编程就业前景,2021计算机编程就业前景好吗 有哪些就业方向
- Ubuntu升级Ruby
- ntfs文件系统服务器版,详解NTFS文件系统+NTFS 文件系统解析
- ArcGIS实验教程——实验二十：ArcGIS数字高程模型DEM建立
- Python-pvm解释器运行程序原理
- python批量请求url_python批量请求注册接口爬虫相关问题记录
- C++数据结构 交通咨询系统设计（一）
- 程序员的10000个小时理论
- python统计英文文章中单词出现的次数
- 华为p8青春版（ALE-UL00）刷机教程
- html 淡出淡入轮播图,用CSS3 transition属性实现淡入淡出轮播图
- ICCV 2021 最新200篇ICCV2021论文分方向汇总