本文详细介绍了Java编程的基础知识，包括标识符、注释、常量、进制转换、变量、算术运算符、比较运算符、逻辑运算符、位运算、三元运算符、程序流程控制等核心概念及实例应用。
1.概念
（1）标识符：
由26个英文字母大小写，数字：0-9 符号：_ $ 组成
定义合法标识符规则：
1、数字不可以开头。
2、不可以使用关键字。
3、Java中严格区分大小写。
（2）Java中的注释格式：
单行注释：
格式： //注释文字
多行注释：
格式： /* 注释文字*/
文档注释：
格式：/** 注释文字 */
（3）常量：
常量表示不能改变的数值。
java中常量的分类：
1、整数常量。所有整数
2、小数常量。所有小数
3、布尔型常量。较为特有，只有两个数值。true 和false。
4、字符常量。将一个数字字母或者符号用单引号( ' ' )标识。
5、字符串常量。将一个或者多个字符用双引号标识。
6、null常量。只有一个数值就是:null.
对于整数：java有三种表现形式。
十进制：0-9 ，满10进1.
八进制：0-7 ，满8进1. 用0开头表示。
十六进制：0-9，A-F，满16进1. 用0x开头表示。
（4）进制的基本转换：
1、十进制二进制互转：
十进制转成二进制除以2取余数，能整除就计为0，不能整除计为1，从右往左写。
例如：6是十进制，变二进制的时候就用6去除以2,6除以2等于3，能整除计为0。
3在除以2于1，不能整除，就计为1。然后1再除以2，计为1。依次从右往左写，为110。
2、二进制转成十进制乘以2的幂数：
例如：将110变成十进制，整数是4个8位，00000000 00000000 00000000 00000110
从右往左，开始位为2的0次方，然后指数逐渐的增加，最后将2的幂次方结果乘以二进制位，
所以上边的从右往左，第一个1对应的是2，第二个1对应的是4，然后相加，等于6。
3、十进制十六进制互转：
先将十进制转成二进制，再转成十六进制，4个二进制位代表1个十六进制位。
4、负数的二进制表现形式：
对应的正数二进制取反加1
（5）变量：
就是将不确定的数据进行存储，也就是需要在内存中开辟一个空间。
1、变量的概念：
内存中的一个存储区域。
该区域有自己的名称（变量名）和类型（数据类型）。
该区域的数据可以在同一类型范围内不断变化。
2、为什么要定义变量：
用来不断的存放同一类型的常量，并可以重复使用。
3、使用变量注意事项：
变量的作用范围（在一对{}中有效）。
4、变量的格式：
数据类型 变量名 =初始化值;
Java语言是强类型语言，对于每一种数据都定义了明确的具体数据类型，在内存总分配了不同大小的内存空间。
开辟空间有三个要素：
1、数据类型。
2、变量名称。
3、数据。
整数默认：int 小数默认：double
自动类型转换（也叫隐式类型转换）
强制类型转换（也叫显式类型转换）
类型转换的原理 ：
表达式的数据类型自动提升：
1、所有的byte型、short型和char的值将被提升到int型。
2、如果一个操作数是long型，计算结果就是long型；
3、如果一个操作数是float型，计算结果就是float型；
4、如果一个操作数是double型，计算结果就是double型。
自动类型提升例子：
byte b = 5;
int x = 6;
x = x + b; //b会自动提升为int类型进行运算。
强制类型转换例子：
byte b = 5;
b = b + 6; //报错 因为b是byte类型的，6是int类型的，
b = (byte)b+6;//强制类型转换，强制将b+6的结果转换为byte类型，再赋值给b。
（6）算术运算符：
Java中的运算符主要有 +（加）、-（减）、*（乘）、/（除）、%（求余数），它们都是二元运算符。
（7）比较运算符：
比较运算符属于二元运算符，用于程序中的变量之间，变量和自变量之间以及其他类型的信息之间的比较。比较运算符的运算结果是boolean型。当运算符对应的关系成立时，运算结果是true,否则为false。所有比较运算符通常作为判断的依据用在条件语句中。
（8）逻辑运算符：
“&”和“&&”的区别：
单&时，左边无论真假，右边都进行运算；
双&时，如果左边为真，右边参与运算，如果左边为假，那么右边不参与运算。
“|”和“||”的区别同理，双或时，左边为真，右边不参与运算。
（9）位运算：
1、通过第三方变量交换两个变量的值：
int temp;
temp = n;
n = m;
m = temp;
2、不用第三方变量交换两个变量的值：
n = n + m;//如果n和m的值非常大，容易超出int范围。
m = n - m;
n = n - m;
n = n ^ m;
m = n ^ m; //(n^m)^m;
n = n ^ m; //n ^ (n ^ m)
移位操作：
还可以对二进制位进行移位操作，java中移位运算有三种。
（1） <<: 左移
（2） >>: 右移
（3） >>>>: 无符号右移
（10）三元运算符：
格式：
(条件表达式)?表达式1：表达式2；
如果条件为true，运算后的结果是表达式1；
如果条件为false，运算后的结果是表达式2；
（11）程序流程控制：
判断结构：if语句
三种格式：
1、if(条件表达式)
{
执行语句；
}
2、if(条件表达式)
{
执行语句；
}
else
{
执行语句；
}
3、if(条件表达式)
{
执行语句；
}
else if (条件表达式)
{
执行语句；
}
……
else
{
执行语句；
}
if语句特点：
1、每一种格式都是单条语句。
2、第二种格式与三元运算符的区别：三元运算符运算完要有值出现。
好处是：可以写在其他表达式中。
3、条件表达式无论写成什么样子，只看最终的结构是否是true 或者false。
（12）选择结构：
switch语句
格式：
switch(表达式)
{
case 取值1:
执行语句；
break；
case 取值2:
执行语句；
break；
......
default:
执行语句；
break；（可以省略）
}
switch语句特点：
1、switch语句选择的类型只有四种：byte，short，int，char。
2、case之间与default没有顺序。先执行第一个case，没有匹配的case执行default。
3、结束switch语句的两种情况：遇到break，执行到switch语句结束。
4、如果匹配的case或者default没有对应的break，那么程序会继续向下执行，运行可以执行的语句，直到遇到
break或者switch结尾结束。
如果判断的具体数值不多，而且符合byte short int char这四种类型。
虽然两个语句都可以使用，建议使用swtich语句。因为效率稍高。
其他情况：对区间判断，对结果为boolean类型判断，使用if，if的使用范围更广。
（13）循环结构：
while语句格式：
while(条件表达式)
{
执行语句；
}
do while语句格式：
do
{
执行语句；
}
while(条件表达式);
do while特点是条件无论是否满足，
循环体至少被执行一次。
格式：
for(初始化表达式；循环条件表达式；循环后的操作表达式)
{
执行语句；
}
1、for里面的连个表达式运行的顺序，初始化表达式只读一次，判断循环条件，为真就执行循环体，然
后再执行循环后的操作表达式，接着继续判断循环条件，重复找个过程，直到条件不满足为止。
2、while与for可以互换，区别在于for为了循环而定义的变量在for循环结束就是在内存中释放。而while
循环使用的变量在循环结束后还可以继续使用。
3、最简单无限循环格式：while(true) , for(;;),无限循环存在的原因是并不知道循环多少次，而是根据某
些条件，来控制循环。
break(跳出)，continue(继续)：
break语句：应用范围：选择结构和循环结构。
continue语句：应用于循环结构。
（14）for和while的区别：
1、变量有自己的作用域，对于for来说：如果将用于控制循环的增量定义在for语句中。那么该变量只在for语
句内有效。For语句执行完毕，该变量在内存中被释放。
2、For和while可以进行互换，如果需要定义循环增量。用for更为合适。
例子：
for(int x=0;x<6;x++)
{
System.out.println("x"+x);
}
int x =0;
while(x<6)
{
System.out.println("x=="+x);
x++;
}
for练习:
1、
*
**
***
****
*****
例子：
for(int x=0; x<5; x++)
{
for(int y =0; y<=x; y++)
{
System.out.print("*");
}
System.out.println();
}
2、
1
12
123
1234
12345
例子：
for(int x=1; x<5; x++)
{
for(int y=1; y<=x; y++)
{
System.out.print(y);
}
System.out.println();
}
3、
九九乘法表:
1*1=1;
1*2=2; 2*2=4;
1*3=3 2*3=6; 3*3=9;
1*4=4; 2*4=8; 3*4=12; 4*4=16;
1*5=5; 2*5=10; 3*5=15; 4*5=20; 5*5=25
例子：
for (int x=1; x<=9 ; x++)
{
for (int y=1; y<=x; y++)
{
System.out.print(y+"*"+x+"="+y*x+"\t");
}
System.out.println();
}
（15）函数：
1、什么是函数：
函数就是定义在类中的具有特定功能的一段独立小程序，是最小的功能单元,函数也称为方法。
2、函数的格式：
修饰符 返回值类型 函数名(参数类型形式参数1，参数类型形式参数2，)
{
执行语句;
return 返回值;
}
返回值类型：函数运行后的结果的数据类型。
参数类型：是形式参数的数据类型。
形式参数：是一个变量，用于存储调用函数时传递给函数的实际参数。
实际参数：传递给形式参数的具体数值。
return：用于结束函数。
返回值：该值会返回给调用者。
3、函数的特点：
3.1、定义函数可以讲功能代码进行封装。
3.2、便于对该功能进行复用。
3.3、函数只有被调用才会去执行。
3.4、函数的出现提高了代码的复用性。
3.5、对于函数没有具体返回值的情况，返回值类型用关键字void来表示，那么此时
该函数中的returm语句可以省略不写。
注意：
函数中只能调用函数，不可以下函数内部定义函数。
定义函数时，函数的结果应该返回给调用者，交由调用者处理。
例子：
public static void main(String[] args)
{
int x =getSum(3);
System.out.println(x);
}
public static int getSum(int num)
{
return num+3;
}
4、重载：
在同一个类中，允许存在一个以上的同名函数，只要它们的参数个数或者参数类型不同即可。
例子：void show(int a,char b,double c){} 判断与给定函数是否重载：
4.1、void show(int x,char y,double z){} //没有重载，与原函数一样。
4.2、int show(int a,double c,char b){} //重载，因为参数列表与原函数的参数列表顺序不一样。
4.3、boolean show(int c,char b){} // 重载，参数列表的个数不同。
4.4、void show(double c){} // 重载，参数列表的个数不同。
4.5、double show(int x,char y,double z){} //没有重载，不可以与原函数同时出现在一个类中，因为它与原函数的
参数列表相同，且它有返回值类型，如果放在同一个类中，就分不清调用的是有返回值类型的函数，还是没
有返回值类型的参数。
重载特点：
与返回值类型无关，只看参数列表（参数的个数，参数的类型，参数的顺序）。
2.数组：
（1） 数组的慨念：
1、具有相同数据类型的一组数据的集合，其实数组就是一个容器。
2、包含一维数组和二维数组。
3、可以自动给数组中的元素从0开始编号，方便操作这些元素。
4、元素类型[] 数组名= new 元素类型[元素个数或数组长度];
（2）一维数组例：
格式1：int[] arr =new int[3];
格式2：int[] arr ={1,3,4,5};
格式1：
定义了名称为arr的一维数组，这个一维数组的长度是3。
格式2：
arr数组中的长度是4，并且明确了元素。
（3）二维数组例：
格式1：int[][] arr = new int[3][2];
格式2: int[][] arr = new int[3][];
格式3: int[][] arr = {{1,9,2},{2,5},{4,8,0,2}};
格式1：
定义了名称为arr的二维数组二维数组中有3个一维数组,每一个一维数组 中有2个元素， 一维数组的名称分别
为: arr[0], arr[1], arr[2]，给第一个一维数组1脚标位赋值为78写法是：arr[0][1] = 78;
格式2：
arr中定义了3个未定义长度的一维数组。
格式3：
arr中定义了3个一维数组，第一个一维数组为{1,9,2}，第二个一维数组为{2,5}，第三个一维数组{4,8,0,2};
（4） 栈内存：
1、作用：用于存储局部变量。
2、特点：当数据使用完，所占空间会自动释放。
（5） 堆内存：
1、作用：数组和对象，通过new建立的实例都存放在堆内存中，用来封装数据。
2、特点：
2.1、每一个实体都有内存地址值。
2.2、 实体中的变量都有默认初始化值，初始化值根据数组中元素的类型而定。
例：int型的初始化值为0。
double型的初始化值为0.0。
float型的初始化值为0.0f。
boolean型的初始化值为false。
String型的初始化值为null。
3、当实体不在被使用时，会在不确定的时间内被垃圾回收器回收。
（6）数组在内存中的分配情况：
（7）数组的应用：
获取最大值第一种方式：
class ArrayDemo1
{
public static void main(String[] args)
{
int[] arr ={1,3,5,6,8};
int max =getMax(arr);
System.out.println(max);
}
public static int getMax(int[] arr)
{
int max =[0]; //定义一个变量max，赋一个数组中的值。
for(int x=1; x<arr.length; x++)
{
if(arr[x]>max) //如果数组中某一个值大于max对应的值，
max = arr[x]; //就将数组中的值赋给max。
}
return max; //将获取到的最大值返回。
}
}
（8）获取最大值第二种方式：
class ArrayDemo2
{
public static void main(String[] args)
{
int[] arr ={1,3,5,6,8};
int max =getMax(arr);
System.out.println(max);
}
public static int getMax(int[] arr)
{
int max =0; //定义一个变量max，赋一个数组中的角标。
for(int x=1; x<arr.length; x++)
{
if(arr[x]>arr[max])
max = x; //如果数组中的值大于arr[max]的值，
} //就将这个值对应的角标赋给max。
return arr[max]; //将获取到的最大值返回。
}
}
（9）排序：
1、选择排序：
原理：
如图（1）每次都是前一个和后一个比，而且第一圈比完，最小值就去了前面。当0角标位和其它的角标位比完以后，那么第二次是从1角标位开始与后面的角标位比，以此类推，每次比完就减少一位，当只剩下最后一个角标位时就不用比了。比的时候需要定义一个第三方变量，如图（2）：3大于1，所以将3赋给变量，1到了3的位置上，然后变量再将3赋到1的位置上。
public static void selectSort(int arr[])
{
for(int x=0; x<arr.length-1; x++) //外循环控制次数，最后一个角标里面的数
{ //不用比了，所以arr.length-1;
for(int y=x+1; y<arr.length; y++) //内循环每次都是前一个和后一个比
{ //所以int y=x+1;
if(arr[x]>arr[y])
{
int temp =arr[x]; //如果前一个数大于后一个数，那么就将这
arr[x] =arr[y]; //个大值赋给变量temp，然后小值去了大
arr[y] =temp; //值的位置，大值去了小值的位置
}
}
}
}
2、冒泡排序：
原理：
如图（3）：每次都是相邻的俩个比较，而且第一圈比完，最大值就去了后面，每次都减少一位，每次都是从0角标位开始比，如图（4）：3大于1，所以将3赋给变量，1到了3的位置上，然后变量再将3赋到1的位置上。
public static void bubbleSort(int[] arr)
{
for(int x=0; x<arr.length-1; x++) //外循环控制次数，最后一个角标里面的数
{ //不用比了，所以arr.length-1;
for(int y=0; y<arr.length-x-1; y++) //arr.length减去x表示每次相邻位比较的
{ //时候就少比较一位，减去1是为了防止角
//标越界
if(arr[y]>arr[y+1]) //每次都是相邻的两个比较，所以是y和
{ //y+1比
int temp =arr[y]; //如果前一个数大于后一个数，那么就将这
arr[y] =arr[y+1]; //个大值赋给变量temp，然后小值去了大
arr[y] =temp; //值的位置，大值去了小值的位置
}
}
}
}
（10）查找：
一般查找：
public static int getIndex(int[] arr,int key)
{
for(int x=0,x<arr.length;x++)
{
if(arr[x]==key)
{
return x; //如果arr[x]等于了这个要查找的key值
} //就返回arr[x]对应的角标
return -1; //如果不等于就返回 -1
}
}
1、折半查找：
前提：必须是有序的数组。
原理：定义3个变量，最小角标min，中间角标mid，最大角标max,
int min =0; mid =(min+max)/2; max = arr.length-1; 它们分别对应了一个指针，当我们要查找的值大于了中间角标所对应的值，那么将min+1，也就是
min所对应的指针向右移动一位，当要查找的值大于了中间角标所对应的值，那么将max-1，也就是max所对应的指针向左移动一位。如果数组中存在这个值，直到找到为止，但是得确保min<=max。
第一种方式：
public static int halfSearch_1(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) //如果min<=max这个条件满足就开始折半
{
mid = (min+max)/2;
if(key>arr[mid])
min=mid+1;
else if(key<arr[mid])
max=mid-1;
else
return mid;
}
return -1;
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
