1、需求
工作需求
跳槽对方需求
技术控
2、能否使用传统技术解决
能解决但是不完美
解决不了
3、引出我们学习的新技术和知识点
4、学习新技术或者知识点的基本原理和基本语法
5、快速入门(基本程序,CRUD)
6、开始研究技术的注意事项,使用细节使用规范如何优化 注:优化无止境
JDK = JRE + java开发工具
JRE = JVM + 核心类库
JDK Java Development Kit 针对 Java 开发员的软件开发工具包 没有JDK就无法编译程序
JRE Java Runtime Environment java运行环境 没有JRE程序无法运行 内置了 Java虚拟机
1、为了在Dos的任意目录可以使用java,javac命令
2、先配置JAVA_HOME 指向JDK的安装主目录
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6FXgebFL-1666510554270)(./images/JAVA_HOME.png)]
3、在path环境变量中增加%JAVA_HOME%bin %代表引用
jdk 和jre 都需要添加进去
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-uDCTL7Rc-1666510554271)(./images/path.png)]
4、编写Java的源代码 javac __ 编译 java __ 运行 运行时不用加class后缀
栈:一般存放基本数据类型(局部变量)
堆:存放对象(Cat cat ,数组等)
方法区:常量池(常量,比如字符串),类加载信息
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-efW6zoiE-1666510554272)(./images/oopcreate.png)]
新建一个hello.java文件输入代码
public class hello {
public static void main (String [] args){
System.out.println("Hello world");
}
}
类名必须与文件名一致
编码可以用Ascll编码
带中文需要更换编码格式 否则可能会报错
javac hello.java编译该程序
java hello运行该程序
Javap 是jdk 提供的一个命令工具,javap能对给定的class文件提供的字节代码进行反编译 简单来说就是 将 .class -> .java
使用格式
javap
常用 javap -c /-v
-version 版本信息
-v -verbose 输出附加信息
-i 输出行号和本地变量表
-public 仅显示公共类和成员
-protected 显示受保护成员和上面的
-package 显示程序包和上面的
-p - private 显示所有类和成员
-c 对代码进行反汇编
-s 输出内部类型签名
-sysinfo 显示正在处理的类的信息
…
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7YfZIQqn-1666510554272)(./images/hello.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-aU11YXnf-1666510554273)(./images/datatype.png)]
变量:先声明再使用
JAVA中默认为Double
int 4个字节 byte short 2个字节
float 4个字节
double 8个字节
char 2个字节
boolean 1个字节(true/false)
class 类 <---- string 属于类里面的
interface 接口类型
数组[]
1、类型
null表示的是一个对象的值,而不是一个字符串。例如声明一个对象的引用,
String a=null。
“”表示的是一个空字符串,也就是说它的长度为0。例如声明一个字符串
String s=”“。
2、 内存分配
String a=null;表示声明一个字符串对象的引用,但指向为null,也就是说还没有指向任何的内存空间。
String s=”“;表示声明一个字符串类型的引用,其值为“”空字符串,这个s引用指向的是空字符串的内存空间;
浮点数 = 符号位 + 指数位 + 尾数位
JAVA中默认为Double
例如:
float num1 = 1.1; //错误 1.1 是Double类型 大-->小 需要强制转换
float num2 = 1.1f; //对
float num3 = 3.1415926535F;
//输出结果为3.1415926
double num4 = 8.1 / 3;
double num5 = 2.7;
//输出 num4 = 2.69999999999999997
if(num4 ==num5)
//输出为false
总结 当运算结果进行相等判断时要小心,应是两者差值的绝对值在某个精度
如
if(Math.abs(num5 - num4)<0.000001)
char c1 = 'a';
char c2 = 97;
//输出结果都是 a
'a'--> ascll码 97 --> (10001)B -->存储
char本质是一个整数 输出一个Unicode编码代表对应一个字符
ASCLL码 1个字节表示 0000 0000 一共有128个字符 但可以表示256个 只用了128
UTF - 8 字母 1个字节 汉字三个字节 0000 0000
Unicode 固定大小 字母汉字都是2个字节
char -> int -> long -> float -> double
byte -> short -> int ->long -> float ->double
byte char short 中不发生自动转换 计算时首先转换成int类型
当多种类型转换时 转为最大容量的类型
运算结果自动提升至操作数中最大类型
注意:
三元运算符是一个整体,如果中间有不同类型的数据,会转会最大容量的类型
int a=10;
float = a + 1.1;
//报错 1.1 已经是Double 类型 小不能转大
大–>小 只作用于最近的操作数
int i = (int)(3.5*10 +6 *44)
//结果为44
如不加强转将报错
基本类型数据转String
int i = 10;
i + "";
//即为string
char 与 string 转换时只取第一个
String a = "guofeng";
char b = a.charAt(0);// 选择取第几个
//输出b = g;
String 转其他数据类型
String S1 = "123";
//转int
int num = Integer.parseInt(S1);
Double num1 = Double.parseDouble(S1);
Float num2 = Float.parseFloat(S1);
char num3 = S1.charAt(1);
System.out.println(num);
System.out.println(num3);
System.out.println(num1);
System.out.println(num2);
// 123
// 2
// 123.0
// 123.0
加减乘除主要是除法需要注意
复合赋值运算会进行类型转换
byte b =3;
b += 2;
// 等价 b = (byte)(b+2); b++; b--; 同理
//如写成 b = b + 2;则报错 大转小需强制转换
System.out.println(10.0 / 4); // 2.5
Double d = 10 / 4; // 2.0
a % b = a - a / b * b
当a 是负数时 a - (int) a / b * b
10 % 3 // 1 a % b = a - a / b * b
-10 % 3 // -1
10 % -3 // 1
// 10-10/(-3)*3 = 10 -9 = 1
-10 % -3 // -1
// -10 -(-10)/(-3)*(-3) = -10-(-3)*(-3) = -10 + 9 = -1
本质 有一个 temp 变量
i++:
temp = i;
i = i + 1;
i = temp;
++i:
i = i + 1;
temp = i;
i = temp:
自加在前 先运算再赋值
自加在后 赋值后在运算
int i = 1;
i = i++;
print(i)
//输出 i = 1;
int i = 1;
i = ++i;
print(i)
//输出 i = 2
== != >= <= > <
运算结果都是Boolean型
逻辑运算符
短路 与 && 或 || 取反 !
逻辑 与& 或 | 异或 ^
**短路与逻辑 之间的差别:**以 “与”为例子
第一个条件为false, 则第二个条件不会判断(执行)
不管第一个是否为false,第二个条件都会判断(执行)
短路 或|| 第一个为true 第二个不判断
进制类型
二进制 ob 开头
十进制
八进制 数字0开头
十六进制 Ox
十六进制Ox 3B5C转换成二进制
每一位都是表示4个二进制 2^4
0011 1011 0101 1100
二进制转十进制
取 1 位一组相加
(0011 1011 0101 1100)B
2^13 + 2^12 + 2^11 +2^9 +2^8 + 2^6 + 2^4 +2^3 +2^2
=35534
二进制转八进制
从右往左取3位一组相加
二进制转十六进制
取4位一组相加
计算机中数据存储都是以二进制保存计算 Binary 二进制
一切运算都是以补码的方式来运算
>> 向右位移两位
低位溢出,符号位不变并用符号位补溢出的高位
本质就是 / 2
<< 向左位移两位
符号位不变,低位补零
本质就是 * 2
>>> 无符号右移
**<<<**无符号左移
~ 按位取反
& 按位与
| 按位或
^ 按位异或
//计算下面结果
//int 4 个字节
0000 0000 | 0000 0000 | 0000 0000 | 0000 0000
//下面计算忽略前面3个字节
~ 2
// 0000 0010 先算出补码 正数的补码就是他本身
// 取反操作(它的补码)
// 1111 1101
// 求原码 -1
// 1111 1100
// 0000 0011
//结果为3 但是补码的符号位是1所以最后结果是 -3
2 & 3
//求出补码
//0000 0010 2
//0000 0011 3
//与运算 得补码
//0000 0010
//求原码 正数即是本身
//结果为 2
2 | 3
// 0000 0010
// 0000 0011
// 0000 0011
//结果为3
~ -5
//求补码 -5
//负数的补码是除了符号位外取反 + 1
// 1000 0101
// 1111 1011
//取反操作
// 0000 0100 求原码 正数
//结果 4
-3 ^ 3
// 1000 0011 -3
// 0000 0011 3
//求补码
// 1111 1101
// 0000 0011
// 异或操作
// 1111 1110 求原码
// 1111 1101
// 0000 0010
//结果为 -2
API application programming interface 应用程序编程接口
可以看到里面的各种包 里面接口 类 异常…
中文在线文档
www.matools.com
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-M4fgAucx-1666510554274)(./images/Api.png)]
基本语法
if ( 判断语句){
}else{
}
判断语句必须结果必须是Boolean类型,非真即假
switch (表达式)
{
case 常量表达式1: 语句1
case 常量表达式2: 语句2
┇
case 常量表达式n: 语句n
default: 语句n+1
}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-iIFS55y2-1666510554275)(./images/xunhuan.png)]
public class Multable{
public static void main (String [] args){
int i,j=1;
for( i = 1;i<10;i++){
for( j = 1;j<10;j++){
if(i==j){
System.out.println(i+" x "+ j +" = "+i*j);
}else if(j<i){
System.out.print(j + " x "+ i +" = "+i*j +"\t");
}
}
}
}
}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-QGFfogPS-1666510554275)(./images/Multable1.png)]
import java.util.Scanner;
public class stars{
public static void main (String [] args){
/*
* * 3个空格 第1行 1个*
*** * * 2个空格 第2行 3个*
***** * * 1个空格 第3行 5个*
******* ---> * * 0个空格 第4行 7个*
***** * * 第5行 5个*
*** * * 第6行 3个*
* * 第7行 1个*
*/
Scanner myscanner = new Scanner(System.in);
System.out.print("输入要打印菱形大小");
int N = myscanner.nextInt();
for(int i = 1;i <= N ;i ++){
//控制行数
for(int j = 1; j<= N - i;j++){
//行数前空格输出
System.out.print(" ");
}
for(int k = 1;k <= 2 * i - 1;k++){
// 每行输出的* 为2n - 1
if(k==1||k==2 * i - 1){
//只输出第一个和最后一个*
System.out.print("*");
}else
System.out.print(" ");
}
System.out.println("");
//打印完一行立刻换行
}
for(int i = N - 1 ; i>0;i--){
//倒过来输出 从最后一行往上打印
for(int j = N - i;j>0;j--){
System.out.print(" ");
}
for(int k = 2 * i - 1;k>0;k--){
if(k==1||k==2 * i - 1){
System.out.print("*");
}else
System.out.print(" ");
}
System.out.println("");
}
}
}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-EHnHAive-1666510554276)(./images/stars.png)]
数组可以存放多个同一类型的数据。数组也是也一种数据类型,是引用类型。即:数组就是一组数据
数组的使用
方式1动态初始化
数组的定义:
//数据类型 数组名 [] = new 数据类型 [大小]
int a [] = new int [5];
//定义了一个数组 名字叫a 存放5个int
数组的引用
//数组名[下标/索引] 例如要使用a 数组的第三个数
a[2]
方式2 动态初始化
先声明再创建数组
// 数据类型 数组名 [];
int a [];
// 数组名 = new 数据类型[大小];
a= new int [10];
方式3 静态初始化
初始化数组
// 适用于已知大小的数组
// 数据类型 数组名 [] ={元素值,元素值...}
int a [] = {
1,2,3,4,5}
//相当于
int a[] = new a[5];
a[0]=1;a[1]=2;a[2]=3;a[3]=4;a[4]=5;
例题1:
/*
创建一个char类型数组,分别放置'A'-'Z',
使用for循环所有元素并打印出来。
提示:char 类型数据运算 'A' + 1 = 'B'
*/
char [] chars = new char[26];
for ( int i = 1; i< chars.length;i++){
//遍历数组所有值
//chars[i] = (char)('A') +(char)(i);
//这样写是错误的 强转为char再计算 但是char类型在进行计算时是会自动转换为int类型来计算
//int 再转为chars[i] 属于小转大 报错
chars[i] = (char)('A' + i);
}
}
例题2:
/*
求出一个数组int[]的最大值{4,-1,9,10,23},并得到对应的下标
*/
int a[] = {
4,-1,9,10,23,9};
max = a[0]; //假定你是最大值
int maxindex = 0;
for(int i = 1; i< a.length;i++){
//遍历数组 如果你比他大 不做改变 如果比他小 更换最大值
if(max < a[i]){
max = a[i];
maxindex = i;
}
}
System.out.print("最大值是"+max+"下标为"+maxindex);
基本数据类型赋值,这个值解释具体的数据,而且相互不影响 值拷贝
数组在默认情况下是引用传递,赋的值是地址 引用拷贝
int arr1[]={
1,2,3};
int arr2[] = arr1;
arr2[0] = 10;
for(int i =0; i<arr1.length;i++){
System.out.print(arr1[i] + " ");
//输出结果为 10 2 3
}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-UP5Ye8ve-1666510554277)(./images/array1.png)]
将int [] arr1 = {10,20,30};拷贝到arr2数组,要求数据空间是独立的
int arr1[] = {
10,20,30};
int arr2[] = new int arr2[arr1.length];
//给arr2开辟哟个新的空间
//所以两个独立了
for (int i =0 ;i< arr1.length;i++){
arr2[i] = arr1[i];
}
要求实现动态的给数组添加元素效果,实现对数组扩容。
原始数组使用静态分配 int array[] = {1,2,3}
添加的元素,直接放在数组的最后 array = {1,2,3,4}
用户可以通过如下方法来决定是否继续添加,添加成功,是否继续? y/n
使用do-while 会更简单 一点
import java.util.Scanner;
public class Array03{
public static void main (String [] args){
/*
1. 原始数组使用静态分配 int array[] = {1,2,3}
2. 添加的元素,直接放在数组的最后 array = {1,2,3,4}
3. 用户可以通过如下方法来决定是否继续添加,添加成功,是否继续? y/n
*/
int arr1 [] = {1, 2, 3};
int arr2 [];
char flag = 'y'; //初始化循环标志
Scanner input = new Scanner(System.in);
while('y'==flag){
for(int j = 0 ; j < arr1.length; j++)
System.out.print(arr1[j]+" "); //输出当前数组
System.out.println("是否添加数组 y/n");
flag = input.next().charAt(0);
if ('n'==flag) { //判断是否添加数组
break;
}else{
System.out.println("输入你要添加的元素");
int j = input.nextInt(); //得到你要添加的元素
arr2 = new int [(arr1.length+1)]; //初始化数组 长度为arr1 + 1
for(int i=0;i
}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pJX1GhIX-1666510554278)(./images/array2.png)]
### 5.冒泡排序
BubbleSort
~~~java
import java.util.Scanner;
public class bubbleSort{
public static void main (String [] args){
Scanner input = new Scanner(System.in);
System.out.println("请输入你要排序的个数");
int k = input.nextInt();
int arr0[] = new int [k];
for(int i = 0;iarr0[i+1]){
int temp;
temp = arr0[i];
arr0[i] = arr0[i+1];
arr0[i+1] = temp;
}
}
System.out.println("排序后的数组");
for(int m = 0;m < arr0.length;m++)
System.out.print(arr0[m]+" ");
}
}
优化:如果给定的数组是有序的,不需要排序 可以提前结束
思路 添加一个count 计数,每次排序结束后+1 判断如果和之前的一样 就退出循环
使用方法二:
先声明再使用
int array [] [] ;
array = new int [2] [3];
列数不确定性
//案例 定义一个二位数组 要求输出
public class doubleArray{
public static void main (String [] args){
// 1
// 2 2
// 3 3 3
int array [][] = new int [3][];
for(int i = 0; i< array.length;i++){
//遍历 数组 的所有元素
array[i] = new int [i+1]; // 开辟空间
for(int j = 0;j < array[i].length;j++){
//给开辟的空间赋值
array[i][j] = i+1;
}
}
for(int i = 0;i<array.length;i++){
//输出二维数组
for(int j = 0; j< array[i].length;j++){
System.out.print(array[i][j]+" ");
}
System.out.print("\n");
}
}
}
使用方法三:
静态定义:
int array [3] [3] = { {1}, {2,2},{3,3,3} };
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-IBZdH0Ys-1666510554278)(./images/er_array.png)]
int array [] [] = { {},{},{},{}}
原来一维数组的每个元素是一堆数组 构成了二维数组
如果需要得到每个一维数组的值还需要再次遍历
如果我们要访问第 (i+1)个数组的第(j+1)个值 array[i] [j]
下标都是从零开始
//输出
// 0 0 0
// 1 0 1
// 0 1 0
int array [] [] = {
{
0,0,0},{
1,0,1},{
0,1,0} };
for(int i = 0; i< array.length;i++){
//遍历二维数组的每个元素
//每个元素也是一个数组
for(int j = 0; j<array[i].length;j++){
//得到二维数组对应的每个元素(一维数组)的长度
System.out.print(array[i][j] + "\t");
}
System.out.println();//换行
}
//使用二维数组打印10行杨辉三角
// 1
// 1 1
// 1 2 1
// 1 3 3 1
// 1 4 6 4 1
// 1 5 10 10 5 1
// ......
//使用二维数组打印10行杨辉三角
// 1 5个空格 每行元素 1
// 1 1 4 从第三行开始 对于非第一个和最后一个元素的值
// 1 2 1 3 array[i][j] = array[i-1][j-1] + array[i-1][j]
// 1 3 3 1 2
// 1 4 6 4 1 1
// 1 5 10 10 5 1 0
// ......
public class doubleArray1{
public static void main (String [] args){
// 先死后活
int array [] [] = new int [10][];
for(int i =0;i<array.length; i++){
//打印行数
array[i] = new int [i+1];
for(int j =0; j < i + 1;j++){
//每行个数 = 行数
if(j == 0 || j ==i){
//判断是否是第一个和最后一个
array[i][j] = 1;
}else{
array[i][j] = array[i-1][j-1] + array[i-1][j];
}
}
}
for(int i = 0;i<array.length;i++){
for(int j = 0 ;j<array[i].length;j++){
// if(j == 0){ // 排版一下
// for(int k= array.length - array[i].length;k>0;k--)
// System.out.print(" ");
// }
System.out.print(array[i][j]+" ");
}
System.out.println();
}
}
}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-C8zTA2HM-1666510554279)(./images/arraywork1.png)]
第一题
BD
第二题
blue
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4sjTKipk-1666510554279)(./images/arraywork2.png)]
1
3
5
7
第四题
import java.util.Scanner;
public class work1{
public static void main (String [] args){
//要求:
//已知一个升序数组,要求插入一个元素,该数组依旧是升序,比如[10,12,45,90]
//添加23后,数组为[10,12,23,45,90]
Scanner input = new Scanner(System.in);
int []arr1={
10,12,45,90};
System.out.println("输入你要添加的数字");
int num = input.nextInt();
int flag = -1;
int [] arr2 = new int [arr1.length + 1];
for(int i = 0;i<arr1.length;i++){
//遍历原来数组
if (num <= arr1[i]){
//如果当前数字比输入的大
flag = i;
break;
//找到要插入的位置
}
}
System.out.println(flag);
if(flag == -1){
//如果没有找到比插入的数字大的 则加到最后
for(int i =0;i<arr1.length;i++)
arr2[i]=arr1[i];
arr2[4] = num;
}else{
for(int i =0;i<arr2.length;i++){
if(i ==flag){
arr2[i]=num;
}else if(i>flag){
arr2[i] = arr1[i-1];
}else
arr2[i] = arr1[i];
}
}
for(int i=0;i<arr2.length;i++){
System.out.print(arr2[i]+" ");
}
}
}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Mq4PgkFw-1666510554279)(./images/arraywork3.png)]
第五题
public class work2{
public static void main (String [] args){
//随机生成10个整数(1-100) 并保存到数组,并倒序打印
//求出其最大值最小值的下标和平均值
//并查找里面是否有8
int []arr1 = new int [10];
for(int i = 0;i<10;i++){
arr1[i] = (int)((Math.random()*100)+1);
}
double sum = 0;
for(int i =0;i<10;i++){
sum+=arr1[i];
System.out.print(arr1[i]+" ");
if(arr1[i]==8){
System.out.println("有8");
}
}
System.out.println();
System.out.println("平均值为"+sum/10);
System.out.println("排序之后的数组");
for(int i= 0;i<9;i++){
//遍历数组
for(int j =0; j < 9-i;j++){
//进行比较
if(arr1[j]<arr1[j+1]){
int temp = arr1[j];
arr1[j] =arr1[j+1];
arr1[j+1] = temp;
}
}
}
System.out.println();
for(int i =0;i<10;i++){
System.out.print(arr1[i]+" ");
}
}
}
张老太养了两只猫:一只小白 今年三岁 白色
一只小花 今年五岁 花色
请编写一个程序,当用户输入小猫的名字时,
就显示该猫的信息,输入小猫名字错误则提示张老太没有这只猫
//单独变量来解决 ==> 不利于数据管理 (把猫的信息进行了拆解)
String cat1Name = "";
int cat1Age = "";
String cat1Color = "";
String cat2Name = "";
int cat2Age = "";
String cat2Color = "";
//数组==> 1. 数据类型体现不出 2.只能通过下标获取信息
//造成变量名和内容的对应关系不明确3.不能体现猫的行为
String [] cat1 = {
"", "", "",};
String [] cat2 = {
"", "", "",};
引用新的技术:OOP 面向对象
一个程序就是一个世界,有很多事务(对象[属性,行为/方法])
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-RNHqx2dy-1666510554280)(./images/oop.png)]
使用面向对象的方式来解决养猫的问题
//实例化一只猫[创建一个猫对象]
// new Cat () 创建一只猫
// Cat cat1 = new Cat(); 把创建的猫赋给 cat1
Cat cat1 = new Cat();
cat1.name = “”;
cat1.age = ;
car1.color = “”;
Cat cat2 = new Cat(); //创建第二个猫对象/实例化另一只猫
cat2.name = “”;
cat2.age = ;
car2.color = “”;
System.out.println("第一只猫信息"+ cat1.name + cat1.age+cat1.color);
System.out.println("第二只猫信息"+ cat2.name + cat2.age+cat2.color);
class cat{
//属性
String name;
int age;
String color ;