day02、03、04:java语言基础组成
关键字
标识符
定义
在程序中自定义的一些名称
由26个英文字母大小写，数字：0-9 符号：_$
定义合法标识符规则
1.数字不可以开头
2.不可以使用关键字
java中严格区分大小写
注意：起名字时，为了提高阅读性，要尽量有意义
一些规范
1.包名：多单词组成时所有字母都小写 xxxyyyzzz
2.类名接口名：多单词组成时，所有单词首字母大写 XxxYyyZzz
3.变量名和函数名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写 xxxYyyZzz
4.常量名：所有字母都大写，多单词时每个单词用下划线连接 XXX_YYY_ZZZ
注释
注释一些规则在day01文章中有提及
常量和变量
常量
对于整数：java有三种表现形式 十进制、八进制（用0开头表示）、十六进制（用0x开头表示）
二进制三位代表一位：八进制
二进制四位代表一位：十六进制
负数二进制：正数二进制取反再加1（负数最高位都是1）
整数常量
小数常量
布尔型常量
只有两个值 true false
字符常量
‘4’ ‘=’
字符串常量
“adcadc” “a” " "
null常量
只有一个值null
类型转换
byte b = 3;
b = b + 2;程序会报错，2是int型
byte b = 3;
b = byte (b + 2);类型强制转换
变量
将不确定的数据进行存储，需要在内存中开辟一个空间
数据类型 变量名 = 初始化值;
float f = 2.3f;
char ch = ‘4’;
char ch1 = ’ ';
boolean b = true;
运算符
算数运算符
- -1%5为-1 1%-5为1
- b=++a a先自增1，再赋给b
- “hhhh”+"aaaa"字符串相连
字符串数据和任何数据使用+都是相连接，最终都会变成字符串 - 转义字符：通过\ \n换行 \b退格 相当于backspace \r按下回车键 \t制表符，相当于tab键
输出"hello" --> SyStem.out.println(" \ “hello” \ “)
输出\hello\ --> System.out.println(” \ \hello\ \ ")
赋值运算符
+= -= *= /= %=
- ep1:
short s=4;
s=s+5; s+5得到的是int型的值，不能赋给short型的s
s+=5; +=会自动做类型转换
比较运算符
== != < > >= <=
逻辑运算符
& | ^ ! && ||
- 3<x<6 要写成 x>3&x<6
- ^ 异或：当true^true = false 就是前后一致时为真
- && 短路：当左边为false时，右边不运算
- ||：当左边为true时，右边不运算
位运算符
- “<<” 左移
- ">>"右移
- ">>>"无符号右移
-
- 3<<3 --> 3*2^3=24
6>>1 --> 6/(2^1)=3
“<<”:乘以2的移动的位数次幂；原有数据的最高位是什么，左移后就补什么
“>>”:除以2的移动的位数次幂
“>>>”:无论最高位是什么，右移后，都用0补
- 3<<3 --> 3*2^3=24
- “&” 与运算
- “|” 或运算
- “^” 异或运算
“^” 一个数异或同一个数两回，结果还是那个数(加密算法) - “~” 反码
//需求：通过右移获取一个数的16进制表现形式
class OperateDemo1
{
public static void main(String[] args)
{
int num = 60;
//获取60的最低4位，通过&15；
int n1 = num & 15;
System.out.println(n1>9?(char)(n1-10+'A'):n1);
//要获取下一组4位，将60右移4位
int temp = 60 >> 4;
//对temp的值进行最低4位的获取
int n2 = temp & 15;
System.out.println(n2>9?(char)(n2-10+'A'):n2);
/*
0-9 'A' 'B' 'C' 'D' 'E' 'F'
10 11 12 13 14 15
获取12的16进制表现：12 - 10 = 2 + 'A' = (char)67;
*/
}
}
三元运算符
- y = (x>1)?100:200;
语句
程序流程控制结构
判断结构
if语句
- 三元运算符与if语句比较:
好处：可以简化if else 代码
弊端：因为是一个运算符，所以运算完必须有一个结果
选择结构
swich语句：
- 使用注意事项及格式
class SwitchDemo
{
public static void main(String[] args)
{
int x = 2;
switch (x)//x只接受四种类型 byte short int char
{
case 4:
System.out.println("a");
break;
case 6:
System.out.println("b");
break;
case 2:
System.out.println("c");
break;
default://输入其他值，执行完所有最后执行default
System.out.println("d");
break;
}
System.out.println("Hello World!");
}
}
- if和switch语句区别
如果判断的具体数值不多，而且x符合格式（四种类型）使用switch语句
其他情况：对区间判断，对结果为boolean型判断，使用if语句 - eg1
/*
需求：根据用于指定月份，打印该月份所属的季节
3,4,5春季 6,7,8夏季 9,10,11 秋季 12,1,2 冬季
*/
class SwitchTest
{
public static void main(String[] args)
{
int x = 4;
switch (x)
{
case 3:
case 4:
case 5:
System.out.println(x+"春季")
break;
case 6:
case 7:
case 8:
System.out.println(x+"夏季")
break;
case 9:
case 10:
case 11:
System.out.println(x+"秋季")
break;
case 12:
case 1:
case 2:
System.out.println(x+"冬季")
break;
default:
}
System.out.println("Hello World!");
}
}
循环结构
while 语句
- while判断完条件是否满足，满足就开始循环，循环完之后再判断条件是否满足，满足则再循环，以此类推
定义初始表达式;
while（条件表达式）
{
循环体（执行语句）;
}
- do while特点是条件无论是否满足，循环体至少被执行一次。
do
{
执行语句；
}while（条件表达式）；
for 语句
1.格式：
for语句
for（初始化表达式;循环条件表达式;循环后的操作表达式）
{
执行语句;
}
2.变量有自己的作用域，对于 for 来讲，如果将用于控制循环的增量定义在 for 语句中，那么该变量只有在 for 语句中有效。for 语句执行完毕，该变量在内存中被释放。
3. for 和 while可以进行互换，如果需要定义循环增量，用 for 更为合适。如下，for 语句执行完毕，变量就会在内存中释放
class ForDemo
{
public static void main(String[] args)
{
for (int x = 0; x<3 ; x++ )
{
System.out.println("x="+x);
}
int y = 0;
while (y<3)
{
System.out.println("y="+y);
y++;
}
}
}
4.for 语句的初始化表达式和循环后操作表达式，可以有不同表现形式，如：
class ForTest
{
public static void main(String[] args)
{
int x = 1;
for (System.out.println("a"); x<3 ;System.out.println("c"))
{
System.out.println("d");
x++;
}
//另一种表达
int x = 1;
for (System.out.println("a"); x<3 ;System.out.println("c"),x++)
{
System.out.println("d");
}
//结果：adcdc
}
}
5.eg1
/*
需求：
1.获取1~10的和，并打印
2.1~100之间7的倍数的个数，并打印
思路：
1.先对1~100进行遍历，通过循环的形式
2.在遍历过程中，定义条件，只对7的倍数进行操作
步骤：
1.定义循环语句，选择for语句
2.在循环中定义判断，，使用if语句
*/
class ForTest2
{
public static void main(String[] args)
{
//1
int sum = 0;
for (int x=1;x<=10;x++)
{
sum = sum + x;
}
System.out.println("sum="+sum);
//2
int count = 0;
for (int x = 1 ; x <= 100 ; x++ )
{
if (x % 7 == 0)
{
count++;
}
}
System.out.println("count="+count);
/*
计数器思想。
通过一个变量记录住数据的状态变化
*/
}
}
6.无限循环的最简单表现形式。
for(;;){}
while(true){}
双重 for 循环
/*
语句嵌套形式
循环嵌套
*/
class ForForDemo
{
public static void main(String[] args)
{
for (int x = 0; x<3 ; x++)
{
for (int y = 0; y<4 ; y++)
{
System.out.print("*");
}
System.out.println();//只有换行功能
}
System.out.println();
//对于打印长方形，外循环控制行数。内循环控制的是每一行的列数，也就是一行中元素的个数
}
- eg1
/*
需求：
*****
****
***
**
*
*
**
***
****
*****
*/
class ForForDemo
{
for (int x = 5; x>0 ; x--)
{
for (int y = x ; y>0 ; y--)
{
System.out.print("*");
}
System.out.println();//只有换行功能
}
System.out.println();
for (int x = 1; x<=5 ; x++)
{
for (int y = 1 ; y<=x ; y++)
{
System.out.print("*");
}
System.out.println();//只有换行功能
}
System.out.println();
/*
需求：九九乘法表
1*1=1
1*2=2 2*2=4
1*3=3 2*3=6 3*3=9
*/
for (int x = 1; x<=9 ; x++)
{
for (int y = 1 ; y<=x ; y++)
{
System.out.print(y+"*"+x+"="+(x*y)+"\t");
}
System.out.println();//只有换行功能
}
/*
需求：
----*
---* *
--* * *
-* * * *
* * * * *
*/
for (int x = 1; x<=5 ; x++)
{
for (int y = 5 ; y>x ; y--)
{
System.out.print(" ");
}
for (int y = 1 ; y<=x ; y++)
{
System.out.print("* ");
}
System.out.println();//只有换行功能
}
}
}
其他
break(跳出)，continue（继续）
break语句：
应用范围：选择结构和循环结构
continue语句：
应用于循环结构，结束本次循环继续下次循环
函数
概述
- 定义：
函数就是定义在类中的具有特定功能的一段独立的小程序
函数也称为方法 - 函数的格式
修饰符 返回值类型 函数名(参数类型 形式参数1,参数类型 形式参数2,...)
{
执行语句;
return 返回值;
}
返回值类型：函数运行后的结果的数据类型
形式参数：是一个变量，用于存储调用函数时传递给函数的实际参数
实际参数：传递给形式参数的具体数值
return：用于结束函数
当该函数没有返回值时，返回值类型用void标识
当函数的返回值类型是void时，函数中return语句可以省略不写
- 特点：提高代码复用性
- 如何定义一个函数：
（1）明确函数返回值类型：
既然函数是一个独立的功能，那么该功能的运算结果是什么先明确
（2） 明确参数列表：
明确该功能是否需要未知的内容参与运算 - eg
/*
需求：
1.定义一个功能，用于打印矩形
2.定义一个打印99乘法表功能的函数
*/
class FunctionTest
{
public static void main(String[] args)
{
rectangle(3,4);
nine(5);
}
public static void rectangle(int a,int b)
{
for (int x=1 ; x<= a ; x++)
{
for (int y=1 ; y<=b ; y++)
{
System.out.print("*");
}
System.out.println();
}
}
public static void nine(int a)
{
for (int x = 1; x<=a ; x++)
{
for (int y = 1 ; y<=x ; y++)
{
System.out.print(y+"*"+x+"="+(x*y)+"\t");
}
System.out.println();//只有换行功能
}
}
}
重载
- 概念：在同一类中，允许存在一个以上的同名函数，只要它们的参数个数或者参数类型不同即可
- 特点：与返回值类型无关，只看参数列表
- 好处：方便于阅读，优化了程序设计
- 什么时候用重载？
当定义的功能相同，但参与运算的未知内容不同。就定义一个函数名称以表示其功能，方便阅读，而通过参数列表的不同来区分多个同名函数
数组
概述
- 定义：同一种类型数据的集合。数组是一个容器
- 数组的优点：可以自动给数组中的元素从0开始编号，方便操作这些元素
- 格式
元素类型[] 数组名 = new 元素类型[元素个数或数组长度];
数组内存特点
java程序在运行时，需要在内存中分配空间。为了提高运算效率，对空间进行了不同区域的划分，因为每一片区域都有特定的处理数据方式和内存管理方式
栈内存
用于存储局部变量，当数据使用完，所占空间会自动释放
堆内存
数组和对象，通过new建立的实例都存放在堆内存中
- 每一个实体都有内存地址值
- 实体中的变量都有默认初始化值
- 实体不在被使用，会在不确定的时间内被垃圾回收器回收
方法区、寄存器
class ArrayDemo
{
public static void main(String[] args)
{
//需求：定义一个可以存储3个整数的容器
int[] x = new int [3];//x是数组类型
x[0] = 59;
x = null;//x不再指向数组,此时数组被视为垃圾
/*
1.主函数运行，在栈内存中开辟空间，存放变量数组型变量x；
2.假如运行show函数，在栈内存中继续开辟空间，执行完之后，所存放的变量消失
3.new 在堆内存中开辟空间，存放[0][1][2]中数据
4.堆内存中每一个实体都有内存地址值，将地址值赋给栈内存中的数组型变量x(x引用堆内存中的数组)
*/
int [] x = new int [];
int [] y = x;
y[1] = 89;//此时x[1]=89
x = null;
int a = 5;
int b = a;
b = 8;//只涉及栈内存
System.out.println("Hello World!");
}
}
数组应用
数组寻找最值
/*
给定一个数组{5,1,6,4,2,8,9}
1.获取数组中的最大值以及最小值
*/
class ArrayTest
{
public static void main(String[] args)
{
int[] arr = {5,1,6,4,2,8,9};
int max = getMax(arr);
int min = getMin(arr);
System.out.println("the max:"+max);
System.out.println("the min:"+min);
}
public static int getMax(int[] arr)
{
int max = arr[0];
for (int x=0; x<arr.length ; x++)
{
if (arr[x]>max)
{
max = arr[x];
}
}
return max;
}
public static int getMax_2(int[] arr)
{
int max = 0;
for (int x=0; x<arr.length ; x++)
{
if (arr[x]>arr[max])
{
max = x;
}
}
return arr[max];
}//max存角标
public static int getMin(int[] arr)
{
int min = arr[0];
for (int x=0; x<arr.length ; x++)
{
if (arr[x]<min)
{
min = arr[x];
}
}
return min;
}
}
数组排序
/*
对给定数组进行排序
{5,1,6,4,2,8,9}
*/
import java.util.Arrays;//导包
class ArrayTest2
{
public static void main(String[] args)
{
int[] arr = {5,1,6,4,2,8,9};
printArray(arr);
//selectSort(arr);
//bubbleSort(arr);
//Arrays.sort(arr);//java中定义好的排序方式，开发中使用
printArray(arr);
}
//选择排序:内循环结束一次，最值出现头角标位置上
public static void selectSort(int[] arr)
{
int temp;
for (int x = 0; x<arr.length-1 ; x++)
{
for (int y = x+1; y<arr.length ; y++)
{
if (arr[x]> arr[y])
{
/*temp = arr[x];
arr[x] = arr[y];
arr[y] = temp;*/
swap(arr,x,y);
}
}
}
}
public static void printArray(int[] arr)
{
System.out.print("[");
for (int x=0; x<arr.length ; x++)
{
if (x!=arr.length-1)
{
System.out.print(arr[x]+",");
}
else
System.out.println(arr[x]+"]");
}
}
//冒泡排序：第一圈最值出现在最后位
public static void bubbleSort(int[] arr)
{
for (int x = 0; x<arr.length-1 ; x++)
{
for (int y = 0; y<arr.length-x-1 ; y++)//-x:让每一次比较的元素减少，-1：壁面角标越界
{
if (arr[y]>arr[y+1])
{
/*int temp = arr[y];
arr[y] = arr[y+1];
arr[y+1] = temp;*/
swap(arr,y,y+1);
}
}
}
}
public static void swap(int[] arr,a,b)
{
int temp = arr[a];
arr[a] = arr[b];
arr[b] = temmp;
}
}
数组查找操作
class ArrayTest3
{
public static void main(String[] args)
{
int[] arr = {3,2,1,5,4,2,9};
int index = halfSearch(arr,2);
System.out.println("index="+index);
}
//定义功能，获取key第一次出现的数值中的位置，没有则返回-1
public static int getIndex(int[] arr,int key)
{
for (int x=0; x<arr.length ; x++)
{
if (arr[x]==key)
{
return x;
}
return -1;
}
}
//折半查找,保证数组是有序数组
public static int halfSearch(int[] arr,int key)
{
int min,max,mid;
min = 0;
max = arr.length-1;
mid = (min+max)/2;
while (arr[mid]!=key)
{
if(key>arr[mid])
min = mid + 1;
else if (key<arr[mid])
{
max = mid - 1;
}
if(min>max)
return -1;
mid = (min+max)/2;
}
return mid;
}
/*
折半的第二种方式
*/
public static int halfSearch_2(int[] arr,int key)
{
int min,max,mid;
min = 0;
max = arr.length-1;
while (min<=max)
{
mid = (max+min)>>1;
if (key>arr[mid])
{
min = mid + 1;
}
else if (key<arr[mid])
{
max = mid - 1;
}
else
return mid;
}
return -1;
}
/*
练习：有一个有序的数组，想要将一个元素插入到该数组中，还要保证该数组是有序的
*/
public static int getIndex_2(int[] arr,int key)
{
int min,max,mid;
min = 0;
max = arr.length-1;
while (min<=max)
{
mid = (max+min)>>1;
if (key>arr[mid])
{
min = mid + 1;
}
else if (key<arr[mid])
{
max = mid - 1;
}
else
return mid;
}
return min;
}
}
数组进制转换
class ArrayTest4
{
public static void main(String[] args)
{
/*toBin(6);
toHex(60);
toBin_2(6);
toHex_2(60);*/
toBin_3(-6);
toHex_3(-60);
}
//十进制-->二进制
public static void toBin(int num)
{
StringBuffer sb = new StringBuffer();//一种容器
while (num>0)
{
sb.append(num%2);//往容器里添加
num = num / 2;
}
System.out.println(sb.reverse());
}
//十进制-->十六进制
public static void toHex(int num)
{
StringBuffer sb = new StringBuffer();
for (int x=0; x<8 ; x++)
{
int temp = num & 15;
if (temp>9)
{
//System.out.println((char)(temp-10+'A'));
sb.append((char)(temp-10+'A'));
}
else
//System.out.println(temp);
sb.append(temp);
num = num >>> 4;
}
System.out.println(sb.reverse());
}
/*
查表法：将所有元素临时存储起来，建立对应关系
每一次&15后的值作为索引去查建立好的表，就可以找对应的元素
这样比 -10+'a'简单的多
这个表可以通过数据对的形式来定义
使用数组完成反转功能
*/
public static void toHex_2(int num)
{
char[] chs = {'0','1','2','3'
,'4','5','6','7'
,'8','9','A','B'
,'C','D','E','F'};
char[] arr = new char[8];
int pos = arr.length;
while(num!=0)
{
int temp = num & 15;
//System.out.println(chs[temp]);
arr[--pos] = chs[temp];
num = num >>> 4;
}
//存储数据的arr数组遍历
for (int x=pos; x<arr.length ; x++)
{
System.out.print(arr[x]+",");
}
}
public static void toBin_2(int num)
{
//定义二进制表
char[] chs = {'0','1'};
//定义一个临时存储容器
char[] arr = new char[32];
//定义一个操作数组的指针
int pos = arr.length;
while (num!=0)
{
int temp = num & 1;
arr[--pos] = chs[temp];
num = num >>> 1;
}
for (int x=pos; x<arr.length ; x++)
{
System.out.print(arr[x]);
}
}
//优化
//十进制转二进制
public static void toBin_3(int num)
{
trans(num,1,1);
}
//十进制转八进制
public static void toBa_3(int num)
{
trans(num,7,3);
}
//十进制转十六进制
public static void toHex_3(int num)
{
trans(num,15,4);
}
public static void trans(int num,int base,int offset)
{
char[] chs = {'0','1','2','3'
,'4','5','6','7'
,'8','9','A','B'
,'C','D','E','F'};
char[] arr = new char[32];
int pos = arr.length;
while (num!=0)
{
int temp = num & base;
arr[--pos] = chs[temp];
num = num >>> offset;
}
for (int x=pos; x<arr.length ; x++)
{
System.out.print(arr[x]);
}
}
}
二维数组
class Array2Demo
{
public static void main(String[] args)
{
int[][] arr = new int[3][4];
int[][] arr = new int[3][];
arr[0] = new int [3];
arr[1] = new int [1];
arr[2] = new int [2];
arr.length//是二维数组的长度3
arr[0].length//二维数组中第一个一维数组长度
int[][] arr = {{3,5,1,7},{2,3,5,8},{6,1,8,2}}
}
}
/*
int[] x,y[];
上式中，x是一维数组，y是二维数组
*/
3万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
