华杉研发九学习日记13 ----java总结
文章目录
- java总结
-
- 一，JAVA学习前准备
-
- 1.1 java的发展历史：
- 1.2 java环境变量配置：
- 二，java基础语法
-
- 2.1 标识符：java中的名称（项目名 类名 包名 变量名 常量名 对象名 方法名 接口名 枚举名）
- 2.2 Java中的关键字:
- 2.3 java中的保留字：
- 2.4 Java中的数据类型：
- 2.5 java运算符：
- 三，流程控制语句
-
- 3.1 分支结构:
- 3.2 循环结构：
- 四，数组
-
- 4.1 数组声明定义以及默认值
- 4.2 数据的遍历方式:
- 4.3 数组的排序: (升序为例)
- 五，面向对象
-
- 5.1 类的格式与关键字
- 5.2 面向对象的特征：
- 5.3 接口：公共的规范标准，主要用来解决单继承的缺陷问题
-
- 5.3.1 this关键字和super关键字的区别：
- 5.3.2 方法的重载和方法的重写的区别：
- 5.4 内部类:
- 5.5 枚举
- 六，API
-
- 6.1 java.lang.*;
- 6.2 java.util.*
- 6.3 java.test.*
- 七，异常
- 八，集合
- 九，IO流
- 十，多线程
java总结
一，JAVA学习前准备
java就是一种高级的汇编语言，就是人机交互，也就是一种能够让计算机识别的语言。
1.1 java的发展历史：
1991 提出来 OAK GREEN TEAM java之父（詹姆斯.高斯林）
1993 java
1995
…
1.2 java环境变量配置：
1.下载JDK1.8 www.oracle.com 官网 找到对应版本，或者找到网盘资源
2.安装JDK
3配置JDK环境
电脑设置–>关于–>高级系统设置–>环境变量–>系统变量新建【变量名：JAVA_HOME 变量值：JDK安装目录】
----->系统变量path编辑–>新建 【 %JAVA_HOME%bin 】
4.验证
win+r输入cmd进入控制台
java
javac
java-version
java特征：
面向对象(封装 继承 多态) 简单 健壮 多线程 跨平台【JVM】
java的开发工具：
IDEA Eclipse MyEclipse
二，java基础语法
2.1 标识符：java中的名称（项目名 类名 包名 变量名 常量名 对象名 方法名 接口名 枚举名）
规则【SUM公司定义的，必须遵循】
1.由字母，数字，下划线，美元符号组成，且不能以数字开头
2.不能使用关键字和保留字
3.大小写敏感
4.长度不限制，最好在16个字以内
习惯【众多程序员默认的习惯，建议遵循，便于团队开发】
项目名，对象名，变量名，方法名 一般采用小驼峰式命名规范，由一个单词组成，全部小写；如果由多个单词组成，从第二个单词开始，首字母大写，其余小写
类名，接口名，枚举名一般采用驼峰式命名规范，由一个单词组成，首字母大写，其余小写；由多个单词组成，每一个单词首字母都要大写，其余小写。
常量名一般全部大写，如果由多个单词组成，单词与单词之间用下划线拼接
包名一般全部小写
2.2 Java中的关键字:
byte short int long float double char boolean public private protected classinterface enum if else switch case break continue for while do final static abstract packageimport extends implements this super default new return instanceof
2.3 java中的保留字：
const goto
2.4 Java中的数据类型：
基本数据类型： byte short int long float double char boolean
引用数据类型： 类 【自定义类 String Random Scanner】 接口 数组
Java中的类型转换：
自转：
从精度低->精度高 int -> double
double d=11;
小的数据类型->大的数据类型 byte -> int
byte b=11;
int i=b;
强转：
从精度高的向精度低的数据类型转换 double->int
double d=11;
int a=(int)d;
从大的数据类型向小的数据类型转换
int i=128;
byte b=(byte)i; //结果为-128 因为byte的范围是-128--127
2.5 java运算符：
算术运算符：+ - * / %
赋值运算符： = += -= *= /= %=
逻辑运算符：& | && || ! ^
比较运算符：> >= < <= == !=
三目运算符：？：
位运算符： & | ^ << >> >>>
三，流程控制语句
3.1 分支结构:
1.单分支的if语句
if(boolean表达式){
true时执行的语句块;
}
2.双分支的if-else语句
if(boolean表达式){
true时执行的语句块;
}else{
false时执行的语句块
}
3.多分支的if-else语句
if(boolean表达式1){
表达式1true时执行的语句块;
}else if(boolean表达式2){
表达式2true时执行的语句块;
}else{
表达式1、表达式2都为false时执行的语句块
}
......
4.多分支的开关语句
switch(变量){ // byte short int char String enum
case 值1:
与值1相同时执行的语句块；break；
case 值2:
与值2相同时执行的语句块；break；// break为终止switch语句，否则继续执行下面的语句
......
default: 默认执行的语句块;
}
3.2 循环结构：
1.for循环
for(初始化表达式；条件表达式；迭代语句){
循环体；
}
2.while循环
初始化表达式；
while（条件表达式）{
循环体；
迭代语句；
}
3.do-while循环
初始化表达式；
do{
循环体;
迭代语句;
}while（条件表达式）;
break和continue的作用
1.break可以作用于循环中和switch中，可以用来终止整个循环
2.continue只能作用于循环中，用来终止本次循环，进入下次循环
循环标记：
当有多层循环或switch嵌套时，或有无限循环，可以采用break/continue+循环标记来进行操作
a: //标记
for(int i=1;i<=9;i++){ // 打印九九乘法表
for(int j=1;j<=i;j++){
System.out.print(j+"*"+i+"="+i*j+"\t");
if(i*j==8)break; // 只会终止里层循环j 继续遍历i
if(i*j==25)break a; // 直接终止外层标记的循环
}
System.out.println();
}
测试结果：
1*1=1
1*2=2 2*2=4
1*3=3 2*3=6 3*3=9
1*4=4 2*4=8
1*5=5 2*5=10 3*5=15 4*5=20 5*5=25
四，数组
4.1 数组声明定义以及默认值
数组就是用来保存多个具有相同数据类型数据的容器。
- 数组可以保存多个数据
- 数据类型要相同，可以是任意数据类型
- 数组的长度一旦定义，永不可变
- 数组的长度使用length获取，数组的下标从0开始到length-1
数组的定义方式：
数据类型 数组名【】=new 数据类型 【长度】
int arr[] = new arr[10]; //定义整型数组长度为10，不再变化
数据类型【】 数组名 =new 数据类型【】{值1，值2，…}
char[] ch = new char[]{'a','b','c',.......}; //定义字符数组并且初始赋值为 a,b,c,.....
//其长度用ch.length表示（自动计算字符个数）
数据类型 数组名【】={值1，值2，…}
String str[] = {"aBc","1@3","你好呀",....}; //定义字符串数组并且不采用new而是直接初始化
数组的赋值：
数组名【下标】=值；
int arr[1] = 123; // 数组下标是从0开始的，所以这里实际上指的是数组的第二个元素
数组的取值：
数组名【下标】
数组的默认值：
| 数据类型 | 默认值 |
|---|---|
| 整型 | 0 |
| 浮点型 | 0.0 |
| 字符 | 空白 |
| 布尔 | false |
| 引用数据类型 | null |
4.2 数据的遍历方式:
1.普通for循环
int arr[]={1,2,3,4,5}; // 定义整型数组
for(int i=0;i<arr.length;i++){ // 用i
System.out.println(arr[i]); // 逐个输出
}
2.加强型for循环
往往用于简写for循环
int arr[]={1,2,3,4,5};
for(int a :arr){ // int a为数组内元素的数据类型 arr为数组名字
System.out.println(a); // 输出
}
4.3 数组的排序: (升序为例)
//整型数组
int arr[]={1,22,333,44,5,66,777,88,9};
1.选择排序 每次将当前最小值放入数组左边
for(int i=0;i<arr.length-1;i++){ // 外层循环从左只有选择一个值用来与右边的元素进行比较 所以只需要length-1次
int minIndex=i; // 将当前下标定义为最小值的下标
for(int j=i+1;j<arr.length;j++){// 遍历当前元素右边的元素
if(arr[j]<arr[minIndex])
minIndex=j; // 判断大小，并将下标赋值给minIndex
}
int temp=arr[minIndex]; // 当前下标的值与minIndex下标的值进行替换
arr[minIndex]=arr[i];
arr[i]=temp;
}
2.冒泡排序 每次将当前最大值放入数组右边
for(int i=0;i<arr.length-1;i++){ //外层循环每次将一个最大值推入最右边，到最后剩一个值不需要再推，所以只需length-1次
for(int j=0;j<arr.length-1-i;j++){ // 因为每次右边已经放了i个最大值，且每次都跟后面的值比较，所以length-1-i
if(arr[j]>arr[j+1]){ // 与后面的值比较大小
int temp=arr[j]; // 交换
arr[j]=arr[j+1];
arr[j+1]=temp;
}
}
}
3.快速排序
Arrays.sort(arr); // java工具包util中Arrays类中自带的实现数组升序的方法 sort(数组名);
五，面向对象
面向对象的思想:就是把万物都看成对象，在程序中都可以直接写入程序。
本质:找对象，找到合适的对象，使用对象，解决问题
创建类，创建对象，使用对象，解决问题
5.1 类的格式与关键字
类的格式：
public class 类名 extends 父类 implements 接口1，接口2{
//属性
private int age;
//方法
public void/返回值类型 方法名（参数列表）{
方法体；
{return...}
}
//构造器
public 类名（参数列表）{
this.属性=值；
}
//代码块
{
}
//内部类 -- 成员 静态 局部 匿名
//主方法
public static void main(String[] args){
}
}
- static：静态的，属性 方法 代码块
static修饰的属性为为类变量，可用类访问，也可以用对象访问
static修饰的方法为为类方法，可用类访问，也可以用对象访问，其中，类方法中只能访问类变量
static修饰的代码块为静态代码块，在第一次引用类【创建对象】时自动执行，往后不再执行
注意：代码块执行顺序优先于构造方法，且静态代码块优先于普通代码块
- final：最终的，变量 方法 类
final修饰的变量为常量，不可以进行二次赋值
final修饰的方法为最终方法，不可以进行方法的重写
final修饰的类为最终类，不可以再被子类给继承
- abstract：抽象的，方法 类
abstract修饰的方法为抽象方法，只能存在于抽象类中
抽象方法不能有主体，只能通过重写方法来实现abstract修饰的类为抽象类，抽象类里面可以没有抽象方法
抽象类不能直接创建对象
- instanceof：判断属于的意思
对象名 instanceof 类名
判断某个对象是否属于某个类，返回值为boolean类型
访问权限 ：private < 缺省的 < protected < public
5.2 面向对象的特征：
封装：属性私有化，提供公共的get和set方法
private String name;
private int age; // private封装私有属性
public String getName() { // get方法获取数据
return name;
}
public void setName(String name) { // set方法给数据赋值
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
继承：把多个类中的相同的代码提取出来，放入到父类中，子类都可继承，实现省写代码的过程
public class Father{
String name;
int age;
public void aa();
}
======================================
public class Son extends Father{
// 也包含了Father里面的成员变量和方法
// 不需要写出来，省写代码
}
多态：一种事物的多种表现形态
- 数组表示
父类Animal 子类Cat、Dog
Cat cat=new Cat();
Dog dog=new Dog();
Animal animal[]={cat,dog}; // 父类对象数组保存两个子类对象 实现向上转型（类似于自动转换）
// 向上转型之后子类独有的方法会被隐藏，但是重写的方法就会保持
// 使用子类的方法 例如Cat类里有个独有的sleep();
(Cat)animal[0].sleep; // 这里使用（Cat） 对其进行向下转型（类似于强制转换），使用被隐藏的子类方法sleep
// 注意：必须先进行向上转型，再进行向下转型
- 参数表示
父类Person 子类Student、Teacher
// 假设在Person类中有一个方法eat(Person person);
public void eat(Person person){
System.out.println(person.name+"吃饭");
}
==================================
// 测试类中
Student student = new Student();
student.name="小孤鸡";
Teacher teacher = new Teacher();
teacher.name="大孤鸡";
Person person = new Person();
person.eat(student); // 将子类对象作为参数 接收的形参类型为父类Person 实现向上转型
person.eat(teacher);
5.3 接口：公共的规范标准，主要用来解决单继承的缺陷问题
public interface 接口名{
只能放置 **常量 抽象方法 静态方法 默认方法**
......
}
Java中 单继承，多实现
public class 类名 extends 父类 implements 接口1，接口2{
}
5.3.1 this关键字和super关键字的区别：
1、this用于访问本类的展性; super用于访问父类继承过来的展性(尤其是父子类同名的展性)。
2、this用于访问本类的方法; super用于访问父类继承过来的方法(尤其是父子类同名的方法)。
3、this用于调用本类的构造方法;super用于调用父类的构造方法。
4、this是对象，是调用当前方法的对象;super只是关键字。
5.3.2 方法的重载和方法的重写的区别：
重载(Overload):发生在同一个类之中，方法名相同，参数类型不同或参数的个数不同
重写(Override):发生在子类和父类之间，当父类的方法不满足子类的需求时，可以重写父类的方法
5.4 内部类:
成员内部类
在类中再创建一个内部类，该类只有在外部类创建对象时才能引用
静态内部类
在类中创建一个由static修饰的内部类，只能访问外部类的static属性
局部内部类
在方法体中创建一个内部类，只有在调用方法时才会引用
匿名内部类(重点)
不创建抽象方法的实现类是而直接对方法进行重写时使用
使用情景： 如果只是对一个方法进行重写,没有其他的属性和方法的扩展，匿名内部类来实现
// 假设接口AA有抽象方法aa();
AA a = new AA(){
@Override
public void aa(){
System.out.println("aaa");
}
}
lambda表达式用来简化匿名内部类的使用
使用条件：
接口必须是函数式接口(该接口中的抽象方法只能有且仅有一个)
// 无返回值
接口名 抽象方法名()->重写的方法体;
// 有返回值
接口名 抽象方法名(参数列表)->{
重写方法体;
return 返回值;
} //大括号和return可以视情况而省略
5.5 枚举
// 性别的枚举，男 女
public enum Sex {
// 对象
// 类似于 new MALE("男"); 实现构造器
MALE("男"),FEMALE("女");
private String name;
public String getName() { // 这里只用到get方法，而不用set方法，因为枚举类的对象不能再另外对其赋值
return name;
}
Sex(String name) {
this.name = name;
}
}
public static void main(String[] args) {
//男生
Sex man=Sex.MALE;
// 打印枚举值
System.out.println(man.getName());
// 获取枚举类里面的所有的值
Sex se[]=Sex.values();
for(Sex s:se){
System.out.println(s.getName());
}
}
六，API
API：就是java中提供的接口文档说明书。
常用类库：SUN公司提供的专门用来为java开发的基础类。
6.1 java.lang.*;
java.lang.*被称为是java的基础包，该包中的类不用导包
Object：所有的类包含数组的超类，所有的类直接或间接的继承Object
学习：无参的构造器Object（） 方法：equals() hashCode() wait() notify() notifyAll() finalize()…
重点：其他类都可以向上转型为Object
String：用来定义不可变字符串，使用最多，也是重点内容
学习：构造器String() String(“”) String (Byte []b) String (char ch[])
方法：length() equals() equalsIgnoreCase() toUpperCase() toLowerCase() contains() startsWith() endsWith() subString() matches() join() split() trim() repalce()
**StringBuffer,StringBuilder：**可变字符串，可以对字符串进行空间扩容
学习：append（）
重点：两者与String的区别
**System：**系统类
重点：System.out.println() System.exit(0)
**Math：**数学类
重点：round();
**包装类：**对java中的八种基本数据类型进行类的封装
int–Integer char–Character
重点：String<---->int
6.2 java.util.*
java.util.*：java中用来定义工具的类型的类的包
Date：时间类，时间类型中最为常见的，经常被使用的类
重点：构造器 Date（） Date（long time）
方法：getTime() toString() before() after() equals()
Calendar：日历类，主要是用来替代Date
重点： Calendar.getInstance()
get( YEAR/MONTH/DATE/DAY_OF_MONTH/HOUR/HOUR_OF_DAY/MINUTE/SECOND/MILLISECOND )
add()
set()
getTime()
**Scanner：**控制台输入类
重点：获取数据 nextInt（） next（）
**Random：**随机数类
重点： nextInt（max）
**UUID：**生成唯一随机字符串的类
重点：randomUUID（）.toString（）
6.3 java.test.*
java.test.*：用来保存java中的格式化类的包
**SimpleDateFormat：**日期格式化类
重点：
SimpleDateFormat(“yyyy-MM-dd HH:mm:ss E”)
format()
parse()
**DecimalFomat：**数字格式化类
重点：
DecimalFormat(“#,###.00”)
format()
parse()
七，异常
异常：java程序中出现的例外情况。
异常分类：
- 编译时异常：必须处理，如果不处理，则IDEA会报错
- 运行时异常：可以处理，也可以不处理，建议处理
- 空指针异常 类型转换异常 数组下标越界异常 算术异常
异常处理方案：
- try…catch…finally
- throws…
自定义异常：
- 继承RuntimeException异常类
- 继承Exception异常类
八，集合
单列集合：
- List集合：有序的，可以包含重复元素的集合
- 子类： ArrayList（） LinkedList（） Vector（）
- 方法： add() remove() get() iterator()
- 功能： 遍历
- Set集合：无序的，不可以包含重复元素的集合
- 子类： HashSet LinkedHashSet HashTable
- 方法： add() remove() iterator()
- 功能： 遍历
双列集合：
- Map集合：用来保存键值对的集合，key唯一，valuse可以重复
- 子类： HashMap LinkedHashMap HashTable
- 方法： put() remove() containsKey() containsValue entrySet() keySet() get()
- 功能： 遍历
九，IO流
IO流就是使用java来操作文件的输入输出操作。
File :代表的是硬盘中的文件或文件夹对象。
构造器：
File(String aa)
File(String p,String ch)
File(File p, String ch)
方法：
exists()
isFile()
isDirectory()
listFile()
list()
creatNewFile()
mkdirs()
delete()
字节流、字符流：
十，多线程
多线程概念
java实现线程的方式
- 继承Thread类
- 实现Runnable接口
- 线程池实现
- 实现Callable接口
线程的常见方法：
currentThread（） setName（） getName（） getPriority（） sleep（） run（） start（）
join（）
线程的生命周期：
初始化状态 可运行状态 运行状态 阻塞状态 死亡状态
线程同步问题：
- 同步代码块
- 同步方法
- lock锁
线程的死锁：
wait（） notify（） notifyAll（）
线程的通信：
wait（） notify（） notifyAll（）