day-1
jvm–java虚拟机，实现java跨平台
jre–java运行环境，包含jvm
jdk–java开发工具–包含jre
// public：在此处用于限定类名与文件名要一样
// class：定义一个类
// HelloWorld：类名
public class HelloWorld{
// public：范围修饰符
// static：静态的
// void：代表没有返回值
// main：方法名
// String[] args：参数列表
// 该方法为java程序的主方法，一个类里只能有一个主方法，但不是必须的
public static void main(String[] args){
//输出打印语句，括号里些什么就输出什么
System.out.println("HelloWOrld");
}
}
安装JDK
下载成功后，双击运行安装包，一路下一步直至完成。如不想安装在c盘，就自行选择安装目录，安装目录不能出现中文字符，默认安装在C:\Program Files\Java路径下。
复制路径：C:\Program Files\Java\jdk-11
在系统搜索框中搜索path
没有找到的，1.设置–系统–系统信息–高级系统设置 2.此电脑–右键–属性–高级系统设置
新建系统变量：JAVA_HOME，值为C:\Program Files\Java\jdk-11
在系统变量中找到path，双击进入编辑，新增：%JAVA_HOME%\bin
验证
至此jdk安装配置完成。
jdk提供了两个非常重要的命令，java和javac
新建HelloWorld.txt文件，后缀改为java(HelloWorld.java)
将开头的那段代码复制，文件名和类名保持一致
保存，关闭文件
在文件所在目录下打开cmd
javac HelloWorld.java
java HelloWorld
运行成功，打印输出HelloWorld
好了，你已经运行成功你的第一个java程序了，接下来安装ideaidea安装教程
使用idea创建第一个Java项目
基础语法
- 注释–对代码的解释说明，不参与编译与运行
- 单行注释 //注释内容
- 多行注释 /注释内容/
- 文档注释 /*注释内容/
- 关键字
特点：
①完全是小写的字母
②常见的开发软件中会有特殊颜色标识 - 常量/字面量–在程序运行过程中,固定不变的量
| 分类 | 值 |
|---|---|
| 整数常量 | 1 2 100 -1等 |
| 小数(浮点数) | 1.0 -1.1等 |
| 字符常量(有且仅有一个字符) | ‘1’ ‘,’ ‘你’ ‘a’ 等 |
| 字符串常量 | “你好” " " "a"等 |
| 布尔常量 | true false |
| 空常量 | null |
- 变量–程序运行期间,其值可以发生改变的量，一般是用来存储一些数据
- 数据类型–分为基本数据类型和引用数据类型
| 类型 | 解释 | 符号 | 大小(bit) |
|---|---|---|---|
| 整数 | 字节型 | byte | 1 |
| 短整型 | short | 2 | |
| 整型 | int | 4 | |
| 长整型 | long | 8 | |
| 浮点型 | 单精度 | float | 4 |
| 双精度 | double | 8 | |
| 字符型 | char | 2 | |
| 布尔型 | boolean | 1 |
- 标识符–变量,方法或者类取的名字
①标识符可以包含英文大小写字母,数字,$和_ 中文也可以(不要用中文)
②不能以数字开头
③不能是关键字
day-2
类型转换
自动转换
1.概念:由小的数据类型提升为大的数据类型,系统自动完成的
2.规则:数据范围从小到大 byte/short/char --> int --> long --> float – > double
3.整数默认是int类型，byte、short和char类型数据参与运算均会自动转换为int类型。强制转换
1.概念:由大的数据类型转为小的数据类型,系统不能自动完成
2.格式: 目标类型 变量名 = (目标类型)被转换的数据;
3.注意事项：强制类型转换一般不推荐使用,因为可能会发生精度损失,数据溢出
运算符
|/||:逻辑或，两边都为假时，结果为假
&/&&：逻辑与，两边都为真时，结果为真
|和||的区别：|左边的表达式为真时，右边的式子不予运行，||两边的表达式都会运行。&和&&同理
还有一个’!'：取反，!true = false,!false = true
System.out.println(7 > 5 & 5 > 4);//true & true--->true
System.out.println(7 < 5 & 5 < 4);//false & false--->false
System.out.println(7 < 5 & 5 > 4);//false & true--->false
System.out.println(7 > 5 & 5 < 4);//true & false-->false
System.out.println(7 > 5 | 5 > 4);//true | true--->true
System.out.println(7 < 5 | 5 < 4);//false | false--->false
System.out.println(7 < 5 | 5 > 4);//false | true--true
System.out.println(7 > 5 | 5 < 4);//true | false-true
System.out.println(!true);//false
System.out.println(!false);//true
System.out.println(!(5 < 4));//true
System.out.println(7 > 5 ^ 5 > 4);//true ^ true>false
System.out.println(7 < 5 ^ 5 < 4);//false ^ false->false
System.out.println(7 < 5 ^ 5 > 4);//false ^ true-true
System.out.println(7 > 5 ^ 5 < 4);//true ^ false->true
分支语句
switch (普通表达式) {
case 值1:
语句体1;
break; case 值2:
语句体2;
break; case 值3:
语句体3;
break; … default:
语句体n+1;
break; // 最后一个break语句可以省略，但是强烈推荐不要省略 }执行流程: 看表达式的结果和哪个case后面的值相同,就执行那个case后面的语句体,碰到break就结束switch.
如果没有符合要求的case则执行default后面的语句体.注意事项:
①switch后面小括号当中只能是下列数据类型：基本数据类型：byte/short/char/int
引用数据类型：String字符串、enum枚举②switch可以没有default,但是一般都会加上
③case语句后面可以不加break.但是如果不加break就会出现case穿透问题.匹配哪一个case就从哪一个位置向下执行，直到遇到了break或者整体结束为止;
循环
for(初始化语句;比较表达式;步进语句){ 循环体; }
注意事项:for循环的变量在小括号当中定义，只有循环内部才可以使用。
格式：
for (int i = 初始值; i < 末值 ; i++) {
//循环体
}
初始化语句; while(比较表达式){ 循环体; }
看判断表达式的结果,如果为false循环结束,如果为true,则执行循环体.循环体执行完后继续看判断表达式的结果以此类推
格式：
while (循环条件){
//循环体
}
初始化语句; do{ 循环体; }while(比较表达式);
先执行循环体，然后看判断表达式的结果如果为true则继续执行循环体如果判断表达式的结果为false则循环结束，如此反复。
格式：
do{
//循环体
}while(循环条件)
1、for循环和while循环的区别
for循环的特点：初始化表达式只在当前的循环范围内有效。
出了循环的大括号以外，就无法使用了(tips:for循环的初始化表达式，也可以定义在外面)
while循环的特点：初始化表达式是定义在循环的外面。出了循环也可以继续使用。
2.do-while循环和for、while循环的区别
do-while循环会至少先执行一遍循环体。然后再做条件判断
而for、while循环都是先判断条件。如果条件满足才执行循环体。
如果条件不满足，就直接结束循环
3.使用场景
一般在循环次数确定的时候，推荐使用for循环
一般在循环次数不确定的时候，推荐使用while循环
do-while循环很少很少会用到
break用于结束循环，只能出现在循环中或者switch中，continue跳过本次循环,继续下次循环
假如不知道循环结束的条件(死循环如何跳出)
1.标号
lo:while (true){
System.out.println("循环");
break lo;
}
2.System.exit(0)–等价于停止运行程序，用这个不仅结束了循环，也结束了程序，也就是循环后面写的代码都不执行了。而标号形式的结束循环依然可以继续执行后续代码。
while (true){
System.out.println("循环");
System.exit(0);
}
键盘录入
//格式：Scanner 变量名= new Scanner(System.in);
System.out.println("请输入一个数字:");
Scanner scanner = new Scanner(System.in);
System.out.println(scanner.nextInt());
生成随机数
获取一个范围在1-10之间的随机数(包含10) r.nextInt(10)+1;
获取一个范围在1-100之间的随机数(包含100) r.nextInt(100)+1;
获取一个范围在20-80之间的随机数(包含80) r.nextInt(61)+20;
Random random = new Random();
int x = random.nextInt(100);//[0-100]之间的随机数
猜数字小游戏
public class Demo04 {
public static void main(String[] args) {
// 程序自动生成一个1-100之间的数字，使用程序实现猜出这个数字是多少?
Random random = new Random();
int x = random.nextInt(100);
//System.out.println(x);
lo:
while (true) {
System.out.println("请输入你猜想的数字:");
Scanner sc = new Scanner(System.in);
int i = sc.nextInt();
if (i > x) {
System.out.print("比目标数字大~");
} else if (i < x) {
System.out.print("比目标数字小~");
} else if (i == x) {
System.out.print("恭喜你猜对啦");
break lo;
}
}
}
}
day-3：一维数组
概念：用来存储一组相同数据类型数据的容器
定义格式：
格式一：数据类型[ ] 变量名 //推荐使用
范例：int[ ] array;
格式二：数据类型 变量名[ ]
范例：int array[ ];
初始化：
1.动态初始化：数据类型 变量名[ ] = new 数据类型[数组长度];
2.静态初始化：数据类型 变量名[ ] = {值1,值2,…};
数组元素：数组里的单个数据就是一个数组元素
假设有如下数组为例
获取数组的第一个元素“1”，使用：arr[0]
获取数组的第二个元素“2”，使用：arr[1]
以此类推可以获取数组的全部元素
改变数组元素的值，使用：arr[下标] = 值
数组的内存图：数组中的实际数据是保存在堆里的
1.java内存中的几块区域(重要的)
①栈
方法被调用的时候都会入栈
局部变量都被保存在栈中
②堆
new出来的东西都在堆中
堆中的东西都有默认初始化值
方法区: 源文件编译成字节码文件后存放的区域
局部变量:定义在方法中的变量
数组的实体保存在堆中
数组名实际保存的是数组实体的地址值
arr中存储的是数组的首地址，但是因为数组是引用数据类型，打印arr时，会自动调用arr数组对象的toString()方法(后面面向对象讲)，默认该方法实现的是对象类型名@该对象的hashCode()值的十六进制值。
数组长度的表示：数组名.length，数组的长度一旦确定就无法更改。
数组的遍历
案例1：从目标数组中查找最大值
int[] arr ={63,68,39,44,8,9,4,15};
public class Arr {
/*
* 思路：
* 定义一个变量max，将数组的第一个元素值赋值给max
* 遍历数组，用数组中第二个元素开始和max比较
* 如果元素值>max,将该元素值赋值给max
* */
public static void main(String[] args) {
int[] arr = {63,68,39,44,8,9,4,15};
int max = arr[0];
for (int i = 1; i < arr.length; i++) {
if (arr[i]>max) {
max = arr[i];
}
}
System.out.println(max);
}
}
案例2：键盘录入5个整数存入数组，求和
public class Add{
/*
* 思路：
* 创建Scanner对象
* 创建数组对象，长度为5
* 定义sum变量用于计算总和
* 使用循环录入数组并计算总和
* */
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int[] arr = new int[5];
int sum = 0;
System.out.println("请输入五个整数:");
for (int i = 0; i < 5; i++) {
arr[i] = sc.nextInt();
sum+=arr[i];
}
System.out.println(sum);
}
}
案例3：在目标数组中查找目标值的索引
public class Index {
/*
* 思路：
* 遍历数组
* 拿数组中的元素与目标数值进行比较
* 找到下标后退出循环
* */
public static void main(String[] args) {
int[] arr = {19, 28, 37, 46, 50};
Scanner sc = new Scanner(System.in);
System.out.println("请输入整数:");
int num = sc.nextInt();
for (int i = 0; i < arr.length; i++) {
if (arr[i]==num){
System.out.println(i);
break;
}
}
}
}
案例4：数组反序(学完方法回来看)
public class ArraysAreInReverseOrder {
public static void main(String[] args) {
int[] arr = {11, 22, 33, 44, 55, 66};
System.out.println(Arrays.toString(reverseOrder(arr)));
}
static int[] reverseOrder(int[] arr) {
int left = 0;
int right = arr.length - 1;
while (left < right) {
arr[right] += arr[left];
arr[left] = arr[right] - arr[left];
arr[right] = arr[right] - arr[left];
//以上三行为不开辟空间实现换位
left++;
right--;
}
return arr;
}
}
数组排序
1.选择排序
在排序过程中一共需要进行 n(n-1)/2 次比较，互相交换 n-1 次。
选择法排序简单、容易实现，适用于数量较小的排序。
public class SelectSort {
public static void main(String[] args) {
int[] arr = {63, 68, 39, 44, 8, 9, 4, 15};
//从小到大排序
for (int i = 0; i < arr.length-1; i++) {
int minIndex = i; //假设当前位置就是最小值的下标
for (int j = i+1; j < arr.length; j++) {
if (arr[j]<arr[minIndex]){
minIndex = j;
}
}
//已经找到最小值的索引，将它放在开头
int temp = arr[i];
arr[i] = arr[minIndex];
arr[minIndex] = temp;
}
//遍历输出数组
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i]+"\t");
}
}
}
2.冒泡排序
最好的情况是正序，因此只要比较一次即可；
最坏的情况是逆序，需要比较 n*n 次。
冒泡法排序是稳定的排序方法，当待排序列有序时，效果比较好。
class BubblingSort {
public static void main(String[] args) {
int[] arr = {63, 68, 39, 44, 8, 9, 4, 15};
for (int i = 0; i < arr.length-1; i++) {
for (int j = 0; j < arr.length - 1 - i; j++) {
if (arr[j] > arr[j+1]) {
int temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
}
//遍历输出数组
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + "\t");
}
}
}
留个坑位，回头填
3.交换排序
交换法排序和冒泡法排序类似，正序时最快，逆序时最慢，排列有序数据时效果最好。
4.插入排序
需要经过 n-1 次插入过程
如果数据恰好应该插入到序列的最后端，则不需要移动数据，可节省时间。
因此，若原始数据基本有序，此算法具有较快的运算速度。
class InsertionSort {
public static void main(String[] args) {
int[] arr = {63, 68, 39, 44, 8, 9, 4, 15};
for (int i = 1; i < arr.length; i++) {
int temp = arr[i];
int j;
for (j = i; j > 0 && temp < arr[j - 1]; j--) {
arr[j] = arr[j - 1];
}
arr[j] = temp;
}
//遍历输出数组
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + "\t");
}
}
}
5.折半排序
对于较大的 n 时，是速度最快的排序算法
当时当 n 很小时，此方法往往比其他排序算法还要慢
折半法排序是不稳定的，对应有相同关键字的记录，排序后的结果可能会颠倒次序。
以上5种排序算法：插入法、冒泡法、交换法排序的速度较慢，但参加排序的序列局部或整体有序时，这种排序能达到较快的速度；当 n 较小时，对稳定性不做要求时，宜选用选择法排序；对稳定性有要求时，宜选用插入法或者冒泡法排序。
day-4:方法
方法也叫函数，是一段具有独立功能的代码集。方法需要自己定义，与main方法平级。自定义的方法需要在main方法中进行调用才会执行。
方法可以提搞代码的复用性、可读性，不能提高程序的运行效率。
方法的定义格式：
[范围修饰符] [static/final/abstract] 返回值类型 方法名(参数列表){方法体;[return 返回值;]}
**注意事项**：方法不能嵌套定义，各个方法之间都是平级的关系。当返回值类型为void时，表示方法没有返回值，可以写return结束方法，也可以不写，如果写，return后不跟返回值。
方法的重载：在同一个类中,方法名相同,参数列表不同的方法才叫重载
参数列表不同:
参数个数不同
参数类型不同
参数的多类型顺序不同
例：从三个数字中，找到最小值并输出
有返回值
public class GetMin {
public static void main(String[] args) {
System.out.println(min(22, 11, 33));
}
static int min(int a,int b,int c){
int min = (a>b?b:a)>c?c:(a>b?b:a);
return min;
}
}
无返回值
public class GetMin {
public static void main(String[] args) {
min(22, 11, 33);
}
static void min(int a,int b,int c){
int min = (a>b?b:a)>c?c:(a>b?b:a);
System.out.println(min);
}
}
day05-二维数组和进制转换
二维数组：二维数组也是一种容器，不同于一维数组，该容器存储的都是一维数组,存的是一维数组的地址
二位数组的定义格式：
数据类型 [ ] [ ] 变量名;
二维数组的初始化：
动态初始化：数据类型 [ ] [ ] 变量名 = new 数据类型[ m ] [ n ];
静态初始化：数据类型 [ ] [ ] 变量名 = new 数据类型[ ] [ ] { {元素1,元素2...}, {元素1, 元素2...}... };
元素访问：数组名[横坐标][纵坐标]
二维数组遍历
public class TwoDimensionalArrayTraversal {
public static void main(String[] args) {
int[][] arr = {{1,2,3},{4,5,6},{7,8,9}};
for (int i = 0; i < arr.length; i++) {
for (int j = 0; j < arr[i].length; j++) {
System.out.print(arr[i][j]+"\t");
}
System.out.println();
}
}
}
进制：人为规定的一种形式
十进制：逢10进1，日常生活中用的都是十进制。
二进制：逢2进1，以0b开头
八进制：逢8进1，以0开头
十六进制：逢16进1，0~9，a~f，以0x开头
进制之间的转换
任意进制转十进制公式：系数*基数的权次幂相加
二进制基数就为2，八进制基数就为8，以此类推。
权次幂就是从后往前，基数的次幂从0开始依次+1。
任意进制转十进制公式：除基取余(商为0为止)，余数倒着拼起来
二进制转十进制：1001，从后往前，1*2^0+0*2^1+0*2^2+1*2^3=9
十进制转二进制：9，
9/2 = 4···1
4/2=2···0
2/2=1···0
1/2=0···1
余数从下往上拼起来：1001
原码、补码、反码
原码:一个十进制的数直接转换成二进制的数，即为原码。
一个字节由八位二进制比特位组成，数据以补码形式进行计算。
八位二进制的最高位为符号位，0正1负
正数的原码、反码、补码是一样的。
反码：负数的反码除符号位其余按位取反。
补码：反码+1
day06-面向对象
面向对象：java的核心思想
面向过程：做事的时候，每一步都是亲历亲为，自己是一个执行者，代表性语言：C
面向对象：将自己的身份从执行者编程指挥者，指挥别人(对象)去做事。---懒人思想
面向过程的效率更高，因为面向对象的底层逻辑还是面向过程，比原本的面向过程多了一步调用。
比如上面说的打印输出数组中的元素，就可以调用已经写好的方法Arrays.toString(数组名)
面向对象三大特征：封装、继承、多态
如果有人提到四大特征的话，就是抽象
类：是对现实事物的抽象
比如学生，有学号、姓名、身高、体重等个人信息，有说话、吃饭、笑等行为，现实事物的基本信息可以抽象为属性，现实事物的行为可以抽象为方法。
对象：类的实例化
现在可以先理解为new出来的都叫对象
封装
第一种体现：将一类具有相同属性(成员变量)和行为(成员方法)的事物封装成一个类(JavaBean，java实体类)。
创建对象：
类名 对象名 = new 类名();
成员变量的使用格式:对象名.成员变量名
1.定义位置
成员变量：定义在类中方法外。作用于整个类中
局部变量：定义在方法内或方法的声明上。作用于方法里
2.在内存中的位置
成员变量：在堆内存中
局部变量：在栈内存中
3.生命周期
成员变量：随着对象的创建而创建。随着对象的消失而消失
局部变量：随着方法的调用而创建。随着方法的消失而消失
4.初始化值
成员变量：有默认初始化值
局部变量：没有默认初始化值。使用之前必须赋值
实体类
public class Stu {
String name;//属性
int age;
void study(){}//方法
void eat(){}
}
//新建一个类
public class Demo01 {
public static void main(String[] args) {
Stu s1 = new Stu();//创建对象
s1.name = "小张";
s1.age = 18;
System.out.println(s1.name + "------" + s1.age);
Stu s2 = new Stu();
s2.name = "小李";
s2.age = 16;
System.out.println(s2.name + "------" + s2.age);
Stu s3 = new Stu();
s3.name = "小王";
s3.age = 20;
System.out.println(s3.name + "------" + s3.age);
}
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
