文章目录
- 前言
- 思维导图
- 前期准备
- 卸载JDK
- 安装JDK
- Hello,world
- 可能遇到情况
- java程序运行机制
- IDEA的安装
- java基础部分
- 基础语法
- 运算符
- 包机制
- javaDoc文档手册
- java流程控制
- 用户交互-Scanner对象
- 顺序结构
- 选择结构
- 循环结构
- break,continue
- 练习
- java方法详解
- 何谓方法
- 方法的定义及调用
- 方法重载
- 命令行传递参数
- 可变参数
- 递归讲解
- 数组
- 数组概述
- 数组声明创建
- 三种初始化及内存分析
- 数组下标界及小结
- 数组的使用
- 多维数组
- Arrays类
- 冒泡排序
- 稀疏数组
- 面向对象编程
- 面向对象与面向过程
- 回顾方法的定义
- 类与对象的关系
- 创建与初始化类与对象
- 构造器的详解
- 创建对象内存分析
- 简单小结类与对象
- 封装
- 继承
- Super详解
- 方法的重写
- 什么是多态
- instanceof和类型转换
- static详解
- 抽象类
- 接口
- 内部类
- 异常机制
- Error和Exception
- 捕获和抛出异常
- 自定义异常,小结
前言
思维导图
前期准备
卸载JDK
- 删除java安装目录
- 删除java_home
- 去除环境变量
- java -version
安装JDK
- 安装JDK8,找到下载地址
- 统一协议
- 下载的电脑对应版本
- 双击安装JDK
- 记住安装路径
- 配置环境变量
- 我的电脑->右键->属性
- 高级系统设置->环境变量->JAVA_HOME
- 配置path变量
- cmd检测Java是否安装:java -version
Hello,world
- 随便新建一个文件夹,存放代码
- 新建一个java文件
- 注意文件后缀
- hello.java
- 注意文档的对应信息
- Java文件编译,代码编写
public class Main {
public static void main(String[] args) {
// write your code here
System.out.print("hello,world");
}
}
- 编译javac java文件
- 运行class文件,Java class文件
可能遇到情况
- 每个单词大小写不能出错,Java大小写敏感
- 尽量使用英文
- 文件名和类名必须一致,并且手写字母大写
- 符号使用了中文
java程序运行机制
- 编译型
- 解释型
- 程序的运行机制
IDEA的安装
- IDEA的安装
- IDEA的使用
- pwvm-主函数
- sout-输出函数
- IDEA的优化
java基础部分
基础语法
- 注释、标识符、关键字
- 注释
- 书写注释是一个非常好的习惯
- 单行注释
// 单行注释-注释一行文字
// 注释
- 多行注释
// 多行注释-可以注释一段文字
/*注释*/
- 文档注释
// JavaDoc:文档注释 /** 注释*/
/**
*@Author hahaha
*/
- 标识符
- 不能使用关键字作为变量名
- 标识符大小写敏感
- 不建议中文名字进行
- 数据类型
- 强类型语言
- 要求变量的使用要严格符合规范,所有变量都必须先定义后使用
- 弱类型语言
- Java的数据类型分为两大类
- 基本类型
- 整数类型
- 浮点类型
- 字符类型
- 布尔类型
// 八大基本数据类型
// 整数
byte num1=20;
int num2=10;// 最常用
short num3=30;
long num4=50L;// 一般会再数字结尾加L
// 浮点数
float num5=40.5F; // 一般再结尾加F
double num6=3.141592653589;
// 字符类型
char name='A';
// 字符串,String不是关键字是类
String name1="halhal";
// 布尔值
boolean flag=true;
- 引用类型
- 类
- 接口
- 数组
- 数据类型扩展
// 整数扩展 进制 二进制0b 十进制 八进制0 十六进制0x
int i=10;// 十进制
int i2=010;// 八进制
int i3=0x10;// 十六进制0x
// 浮点数扩展
// 最好完全使用浮点数进行比较
// BigDecimal 数学工具类
// 字符扩展
// 所有的字符本质还是数字
// 编码
// 转义字符
// \t 制表符
// \n 换行
// ...
// 布尔值扩展
boolean flag=true;
- 类型转换
- 运算中,不同类型的数据先转化为同一类型,然后进行运算
- 内存溢出问题
- 强制转换 (类型)数据-高到低
- 自动类型转换 低到高
- 注意点
- 不能对布尔值进行转换
- 不能把对象转换为不相干的类型
- 在把高容量转换到低容量的时候,强制转换
- 转换的时候可能出现内存溢出,或精度问题
- 操作比较大的数的时候,注意溢出问题
- JDK7新特性,数字之间可以用下划线分割
- 在计算时候就进行对应类型的转换
- 变量、常量
- 变量
// 数据类型 变量名=值;
// 可以使用逗号隔开来声明多个同类型变量
注意事项
- 每个变量都有类型,类型可以是基本类型,也可以是引用类型
- 变量名必须是合法的标识符
- 变量声明是一条完整的语句,因此每一个声明都必须以分号结束
// int a=1,b=2,c=3; // 程序可读性
String name = "qinjiang";
char x='x';
double pi=3.14;
变量作用域
- 类变量
statice 数据类型 名称=值 - 实例变量
从属于对象,在方法外,类内
如果不自行初始化,这个类型默认值为 0,0.0,
布尔值默认false
除了基本类型,其余的默认值都是null - 局部变量
局部变量在方法里,必须声明和初始化值
- 常量
- final 数据类 名称=值
- 修饰符,不存在先后顺序
- 变量的密码规范
- 所有变量、方法、类名:见名知意
- 类成员变量:首字母小写和驼峰原则
- 局部变量:首字母小写和驼峰原则
- 常量:大写字母和下划线
- 类名:首字母大写和驼峰原则
- 方法名:首字母小写和驼峰原则
- 运算符
- 包机制、javaDoc
运算符
- 算数运算符
- CTRL+D复制当前行到下一行
- 运算类型以最高的为基准
- %取余符号
- 自增,自减运算符一元运算符
- 自增 ++
- ++a 先自增
- a++ 先赋值
- 自减 –
- 幂运算
- Math类
- 赋值运算符
- 关系运算符
- 逻辑运算符
- 与-and
- 两个变量都为真,结果为真
- 或-or
- 两个变量有一个真,结果为真
- 非-取反
- 如果是真则为假,如果是假则为真
- 短路运算
- 假设前面的为错,后面的结果可能不进行运算
- 位运算符(了解)
/**
A=0011 1100
B=0000 1101
A&B=0000 1100 //有0为0
A|B=0011 1101 //有1为1
A^B=0011 0001
~B=1111 0010
效率高
<< *2
>> /2
*/
```
- 条件运算符
- 三元运算符
// x?y:z
// 如果x==true,则结果为y,否则结果为z
- 扩展赋值运算符
- +字符输出,会将所有类型变为字符串连接,如果在计算前直接连接,如果在计算后,先运算再连接
- 优先级
包机制
- 区别于命名空间
- 包的本质就是文件夹
- 一般利用公司域名倒置作为包名
- 导包-import
- 分包-package
- 阿里巴巴开发手册
javaDoc文档手册
- Java api手册
/**
*@author Test
*@version 1.0
*/
- 类上是类的注释,方法上是方法的注释
- 包文档的构建
- javadoc -encoding UTF-8 -charst UTF–8 Doc.java
java流程控制
用户交互-Scanner对象
- 基础语法
// 基础语法
// 创建扫描器对象
Scanner scanner=new Scanner(System.in);
System.out.println("使用next方式接收:");
// 判断用户有没有输入对象
if(scanner.hasNext()){
// 使用next方式接收输入量
// next方法->不能得到带空格的字符串
//String str=scanner.next();
// nextLine->以Enter为结束符,可以获得空白字符
String str=scanner.nextLine();
// 输出对象内容
System.out.println(str);
}
// 使用完就关闭,凡是属于IO流不关闭会占用内存
scanner.close();
- 输出
Scanner scanner=new Scanner(System.in);
int i=0;
float f=0.0f;
// 进行整数输出
System.out.printfl("请输入一个整数");
if(scanner.hasNextInt()){
i=scanner.nextInt();
System.out.println("输入的是整数")
}
else{
System.out.println("输入的不是整数")
}
// 进行小数输出
System.out.printfl("请输入一个小数");
if(scanner.hasNextFloat()){
i=scanner.nextFloat();
System.out.println("输入的是小数")
}
else{
System.out.println("输入的不是小数")
}
scanner.close();
顺序结构
- 基本结构,从上往下执行。
- 它是任何一个算法都离不开的一种基础结构
选择结构
- if单选择结构
// 语法
if(布尔表达式){
//布尔表达式成立执行
// 判断字符串是否相等equals()方法;
}
- if双选择结构
// 语法
if(布尔表达式){
// 如果布尔表达式的值为true
}
else{
// 如果布尔表达式值为false
}
- if多选择结构
// 语法
if(布尔表达式1){
//布尔1成立
}else if(布尔表达式2){
//布尔2成立
}else if(布尔表达式3){
//布尔3成立
}
.......
else{
}
- 嵌套的if结构
// 语法
if(布尔表达式1){
if(布尔表达式2){
}
}
- switch多选择结构
- 判断变量的值是否相等
- 语法格式
switch(expreesion){
case value:
// 语句
break;//可选
case value:
// 语句
break;//可选
default://可选
//语句
}
- JDK7开始支持字符串的比较
- 反编译-(IDEA)
循环结构
- while循环
- while是最基本的循环
- 语法格式
while(表达式){
// 循环内容
}
- 我们大多数情况会让循环停止下来的,我们需要一个让表达式失效的方法来结束循环
- do…while循环
- do…while循环至少会执行一次
- 语法格式
do{
// 循环内容
}while()
- for循环
- 语法格式
for(初始化;布尔表达式;更新){
// 循环内容
}
- 是最有效、最灵活的循环结构
- 增强for循环
// 遍历数组元素
int[] numbers={1,2,3,4};//定义一个数组
for(int x:numbers){
// 根据数组进行遍历
}
break,continue
- break终止循环
- continue终止本次循环
- goto关键字
- Java没有goto
- 标签
练习
- 打印星星
- Debug-断点
java方法详解
何谓方法
- 解决方法有序的组合
- 方法包含于类或对象中
- 方法再程序中被创建 ,再其他地方被引用
- 一个方法只完成一个功能,这又有利于我们后期扩展
方法的定义及调用
- 类似函数,用来完成特定功能的代码片段
- 方法包含一个方法头和一个方法体
- 修饰符
- 返回值类型
- 方法名
- 参数类型
- 方法体
- 语法格式
// 语法格式
修饰符 返回值类型 方法名(参数类型 参数名){
方法体
}
- 形式参数,用来定义作用的
- 实际参数,实际调用传递给他的参数
- 方法的调用
- 对象.方法名(实力参数)
- 值传递(Java)
方法重载
- 方法名称必须相同
- 参数列表必须不同
- 方法的返回值类型可以相同也可以不相同
- 仅仅返回类型不同不足以成为方法的重载
- 根据参数自动匹配
命令行传递参数
- javac 类名
- java 包名
可变参数
- 在指定参数类型后加一个省略号(…)
- 一个方法中只能指定一个可变参数,它必须是方法的最后一个参数,任何普通的参数必须在它之前声明
- 相关案例
public static void main(String[0]args) i
Demoe demoe = new Demoe();
demoe4.test(1,2,3,4);
}
public void test(int... i){
system.out.print1n(i[0]);
}
递归讲解
- 自己调用自己
- 递归结构包括两个部分
- 递归头:什么时候不调用自身方法,如果没有头,将陷入死循环。
- 递归体:什么时候需要调用自身方法。
- 使用栈机制
- 主要学习递归思想
数组
数组概述
- 数组是相同类型数据的有序集合
- 描述若干个数据,按一定的先后顺序组合而成
- 每个数据成为数组元素,可以使用下标来访问它们
数组声明创建
- 首先必须声明数组变量,才能在程序中使用数组,
dataType[] arrayRefVar;// 首选
或
dataType arrayRefVar[];// 效果相同,但是不是首选
- Java语言使用new操作符来创建数组
dataType[] arrayRefVar=new dataType[arrayRefVar];
- 数组元素是通过索引访问的,数组索引从0开始
- 获取数组长度:arrays.length
三种初始化及内存分析
- Java内存
- 堆
- 栈
- 方法区
- 三种初始化
- 静态初始化
// 静态初始化:创建+赋值
int[] a={1,2,3,4,5};
- 动态初始化
// 动态初始化
int[] b=new int[10];
- 数据默认初始化
数组下标界及小结
- 其长度是确定的。数组一旦被创建,它的大小就是不可以改变的。
- 其元素必须是相同类型,不允许出现混合类型。
- 数组中的元素可以是任何数据类型,包括基本类型和引用类型。
- 数组变量属引用类型,数组也可以看成是对象,数组中的每个元素相当于该对象的成员变量。
- 数组本身就是对象,Java中对象是在堆中的,因此数组无论保存原始类型还是其他对象类型,数组对象本身是在堆中的。
- 下标合法区间:[0,length-1]
数组的使用
- 下标使用-for循环
- for-each循环-没有下标
- 打印数组元素方法
- 输出数组
- 反转数组
for(int i=0,j=result.lengtj-1;i<arrays.length;i++,j--){
result[j]=arrays[i];
}
多维数组
- 可以看成数组的数组-数组的嵌套
int[][] arrays={{1,2},{2,4}};
- 二维数组
int a[][]=new int[2][5];
Arrays类
- 查看JDK文档
- 不建议重复造轮子
- 常用方法
- toString方法
- fill方法
- sort方法
冒泡排序
- 两层循环,外层冒泡层次,内存数值比较
- 比较数组中,两个相邻的元素,如果第一个数比第二个数大,我们就交换他们的位子
- 每次比较,都会产生一个最大,或最小的数字
- 下一轮则可以少一次排序
- 一次循环,直到结束
稀疏数组
- 数据结构
- 压缩算法
- 大部分都为0,或相同
- 处理方法
- 记录数组几行几列
- 把不同值的元素和行列值记录在一个小规模的数组中
// 正常创建
int[][] array1=new int[11][11];
array1[1][2]=1;
array1[2][3]=1;
// 转换成稀疏数组
int sum=0;
for(int i=0;i<11;i++){
for(int j=0;j<11;j++){
if(array1[i][j]!=0)
sum++;
}
}
// 创建一个二维数组,将非零的值,存放稀疏数组中
int[][] array2=new int[sum+1][3];
array2[0][0]=11;
array2[0][1]=11;
array2[0][2]=sum;
// 记录稀疏数组
int count=e;
for (int i = e; i < array1.length ; i++) {
for (int j - e; j < array1[i].length; j++) {
if ( array1[i][j]!=0){
count++;
array2[count][0] = i;
array2[count][1] = j;
array2[countj][2] = array1[i][j];
}
}
}
// 还原稀疏数组
//1.读取稀疏数组
int[][]array3 = new int[array2[0][0]][array2[0][1]];
//2.给其中的元素还原它的值
for (int i = 1; i < array2.length; i++) {
array3[array2[i][0]][array2[i][1]] = array2[i][2];
}
面向对象编程
面向对象与面向过程
- 面向过程
- 线性步骤
- 面向对象
- 物以类聚-分类思想
- 对于描述复杂的事物,为了从宏观上把握、从整体上合理分析,我们需要使用面向对象的思路来分析整个系统。但是,具体到微观操作,仍然需要面向过程的思路去处理。
- 以类的方式组织代码,以对象的组织(封装)数据。
- 抽象
- 封装,继承,多态
回顾方法的定义
- 方法的定义
- 修饰符返回类型
- break:跳出switch,结束循环和return的区别
- 方法名:注意规范就OK见名知意
- 参数列表:(参数类型,参数名)…
- 异常抛出
修饰符 返回值类型 方法名(){
// 方法体
return 返回值;
}
// break,continue
- 方法的调用
- 静态方法直接使用,非静态方法,需要实例化后才能使用
- 静态方法
- 非静态方法
- 形参和实参
- 值传递和引用传递
- 值传递
- 引用传递->对象,本质还是值传递
- this关键字
类与对象的关系
- 类
- 类是一种抽象的数据类型,它是对某一类事物整体描述定义,但是并不能代表某一个具体的事物.
- 抽象的
- 对象
- 对象是抽象概念的具体实例
- 具体的
创建与初始化类与对象
- 一个项目应该只存在一个main方法
- 类
- 属性:字段
- 方法
- 使用new关键字创建对象
- 学程序好?对世界进行更好的建模
构造器的详解
- 一个类,即使什么都不写,他也会存在一个方法
- 构造器作用
- 使用new关键字,必须要有构造器,本质是在调用构造器
- 用来初始化值
- alt+insert
- 构造器创建
- 和类名相同
- 没有返回值
- 注意点
- 一旦定义了有参构造,无参就必须显示定义
创建对象内存分析
简单小结类与对象
- 类与对象
- 类是一个模板:抽象,对象是一个具体的实例
- 方法定义、调用!
- 对应的引用
- 引用类型:基本类型(8)
- 对象是通过引用来操作的:栈—>堆
- 属性:字段Field成员变量
- 默认初始化:
- 数字
- char
- boolean
- 引用
- 修饰符﹑属性类型属性名=属性值!
- 对象的创建和使用
- -必须使用new关键字创造对象,构造器Person kuangshen = new Person( );
- -对象的属性uangshen.name
- -对象的方法euangshen.sLeep()
- 类;
静态的属性 属性
动态的行为 方法 - 封装、继承、多态
封装
- 该露就露,改藏就藏
- 高内聚,低耦合
- 类的内部数据操作细节自己完成,不允许外部干涉
- 仅暴露少量的方法给外部使用
- 数据隐藏
- 属性私有,get/set
- private-私有数据
- get/set
- 提供一些public的get,set方法
- alt+insert
- 封装的意义
- 提高程序的安全性,保护数据
- 隐藏代码的实现细节
- 统一接口
- 系统的可维护增加了
- 方法的重载
- 方法名,参数列表
继承
- 继承本质上对某一批类的继承,对世界更好的建模
- extands的意思是扩展,子类是父类的扩展
- Java类中只有单继承,没有多继承
- CTRL+H-查看继承情况
- 在Java中,所有的类,都默认直接或间接继承object
- object类
Super详解
- 父类的属性和方法
- 私有的东西无法被继承
- 子类继承,默认先执行父类的无参构造-调用父类的构造器,必须放在子类构造器的第一行
- 注意点
- super调用父类的构造方法,必须在构造方法的第一个
- super必须只能出现在子类的方法或者构造方法中
- super和this不能同时调用构造方法
- Vs this
- 代表对象不同:
- this 本身调用者这个对象
- super 代表父类对象的应用
- 前提
- this 没有继承也可以使用
- super 只能在继承条件下才可以使用
- 构造方法
- this() 本类的构造
- super() 父类的构造
方法的重写
- 重写都是方法的重写,与属性无关
- 父类的引用指向了子类
- 静态方法和非静态方法不一样
- 需要有继承关系,子类重写父类的方法
- 方法名必须相同
- 参数列表必须相同
- 修饰符:范围可以扩大
- 抛出的异常:范围可以被缩小,但是不能扩大
- 重写,子类的方法和父类必须一致,方法体不同
- alt+insert
什么是多态
- 动态编译:类型:可扩展性
- 一个对象的实际类型是确定的
- 可以指向的引用类型就不确定
- 父类引用指向子类
- 对象能执行哪些方法,主要看对象左边的类型,和右边关系不大
- person 父类型,可以指向子类,但是不能调用子类独有的方法
- 注意事项
- 多态是方法的多态,属性没有多态
- 父类和子类,有联系 类型转换异常
- 存在条件:继承关系,方法需要重写,父类的引用指向子类对象
- 以下内容不能重写
- static方法,属于类,不属于实例
- final 常量
- private方法
instanceof和类型转换
- 判断一个对象时什么类型,判断是否存在父子类关系
System.out.println(x instanceof y);
// 能不能编译通过,X,Y的关系
- 有关系才能使用instanceof
- 类型之间的转化
- 基本类型转换
- 父子之间的转换
- 高转低需要强制转换
- 子类转换为父类可能丢失原来的一些方法
- 注意点:
- 父类引用指向子类对象
- 把子类转换为父类,向上转型
- 把父类转换为子类,向下转型,强制转换
- 方便方法的钓鱼呢,减少重复的代码
- 抽象思想
static详解
- 类的字段
- 静态变量
- 执行顺序:静态代码块(只执行一次),匿名代码块,构造方法
- 静态导入包
import static java.lang.Math.random;
抽象类
- abstract进行代码的修饰
- 约束
- 抽象类的所有方法,继承了它的子类,都必须需要实现它的方法
- 抽象方法,只有方法名字,没有方法的实现
- extends-单继承
- 接口可以多继承
- 注意点:
- 不能new这个抽象类,只能靠子类去实现它,约束
- 抽象类可以写普通方法
- 抽象方法必须卸载抽象类中
- 抽象的抽象:约束
- 抽象类存在构造器嘛?
- 抽象类存在的意义?
接口
- 普通类:只有具体实现
- 抽象类:具体实现和规范(抽象方法)都有!
- 接口:只有规范!自己无法写方法~专业的约束,约束和实现分离,面向接口编程
- 接口就是规范,定义一组规则,
- 接口的本质是契约
- 通过 interface进行定义
- 接口中的所有定义其实都是抽象的-publice abstract
- 接口都需要实现类
- 类可以实现一个接口,impements
- 实现了接口的类,就需要重写接口中的方法
- 利用接口实现多继承
- 作用
- 约束
- 定义一些方法,让不同的人实现
- public abstract
- public static final
- 接口不能被实例化,接口中没有构造方法
- implements可以实现多个接口
- 必须要重写接口中的方法
- 总结博客
内部类
- 成员内部类
- 通过类来实例化内部类
outer.new Inner();
- 静态内部类
- 局部内部类
- 一个Java中可以有多个class类,但是只能由一个public类
- 匿名内部类
- 没有名字的初始化类,不用将实例保存到变量中
异常机制
Error和Exception
- 异常机制
- 程序报错,异常
- 检查性异常
- 运行时异常
- 错误
- Error
- 虚拟机异常
- 运行时异常
- Exception
- 逻辑错误
- 非运行时异常
- Error时致命性错误,Exception尽可能处理异常
捕获和抛出异常
- 抛出异常
- 捕获异常
- try{}-监控异常
- catch(){}-捕获
- ()参数的捕获类型
- 可以多层异常嵌套进行-层层递进
- ERROR->Exception->Throwable
- 从小到大的捕获异常
- finally{}-善后
- IO,资源,关闭
- 可以不用
- CTRL+ALT+T
- 主动的抛出异常 throw throws-一般在方法中使用
- 发现处理不了的异常也可以主动抛出
自定义异常,小结
- 自定义异常的使用-框架
- 创建自定义异常类。-继承Exception
- 在方法中通过throw关键字抛出异常对象/构造器。
- 如果在当前抛出异常的方法中处理异常,可以使用try-catch语句捕获并处理;否则在方法的声明处通过throws关键字指明要抛出给方法调用者的异常,继续进行下一步操作。
- 在出现异常方法的调用者中捕获并处理异常。
- 处理异常
- 处理运行时异常时,采用逻辑去合理规避同时辅助try-catch处理
- 在多重catch块后面,可以加一个catch (Exception)来处理可能会被遗漏的异常
- 对于不确定的代码,也可以加上 try-catch,处理潜在的异常
- 尽量去处理异常,切忌只是简单地调用printStackTrace()去打印输出具体如何处理异常,要根据不同的业务需求和异常类型去决定
- 尽量添加finally语句块去释放占用的资源