java编程基础
需掌握的知识点概括:关键字，标识符，注释，常量和变量，运算符，语句，函数，数组。
1，关键字
被java语言赋予特殊含义的单词。
Const和goto关键字未被使用但是仍然被保留。
true、false和null虽然看起来像关键字，但是它们实际上是literals(常量)而不是关键字，你不能用他们来做变量名。
2，标识符
在程序中自定义的一些名称
组成：
26个英文字母大小写，数字0-9，符号$_
规则：
不可以数字开头，不可以使用关键字，尽量起有意义的名称。严格区分大小写。
规范：
包名全小写；类接口名首字母大写；变量名和函数名首字母小写，后面的单词首字母大写；
常量全大写，单词用下划线隔开。
3，注释
方便理解程序，调试程序，产生文档。
单行注释：//
多行注释：/*代码*/
文档注释：/**代码*/
文档注释是java特有的注释，注释内容被java虚拟机提供给javadoc解析，生成网页形式的程序说明文档。
4，常量
常量是java当中固定不变的数据。
整数，小数，布尔型(true,false)，字符(eg：’a’)，字符串(eg：”a”)，null值。
整数的进制：
二进制，八进制，十进制，十六进制
进制转换：
(1)，十进制转二进制
总结：除2取余，逆序编排余数1或0，得到数的二进制表示。
eg：将10进制数 6 转换为二进制表示
6除2取余的到011，逆序编排得到二进制110.
(2)，二进制转十进制
总结：各位二进制位1或0乘以2^n的和(n为对应位的角标)。
eg：将二进制110转换为10进制表示。
二进制位： 1 1 0 ----》 (0*2^0)+(1*2^1)+(1*2^2) = 0+2+4 =6
对应角标n： 0 1 2
(3)，二进制转其它进制
转为八进制：二进制每3位二进制位进行十进制转换运算，得到的数按从左到右的顺序编排。
转为十六进制：二进制每3位二进制位进行十进制转换运算，得到的数按从左到右的顺序编排。
(4)，十进制转其他进制
方法：是先转为二进制，然后转换为其它进制。
(5)，负数的二进制表现形式
方法：对应的正数的二进制取反加1。
>
优化进制转换的示例：
/*
*这是进制转换优化的的练习
*思路:定义一个进制转换抽取的方法trans，通提高复用。
在trans方法中定义一个表，这个表包含0-15的十六进制的对应元素0-9，A,B,C,D,E,F。
定义一个数组，存储查表后的值。
将需要转换的值num&"对应进制的数"，通过得到的值查找对应的表的值并向后存储到定义的数组。
无符号右移相应的位数，再执行循环，直到num=0结束循环。
*/
class BaseTrans {
public static void main(String[] args) {
toBin(-60);
toHex(-60);
toOct(-60);
}
//十进制转化成二进制
public static void toBin(int num){
trans(num, 1, 1);
}
//十进制转化成八进制
public static void toOct(int num){
trans(num, 7, 3);
}
//十进制转化成十六进制
public static void toHex(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[] res=new char[32];
int pos=res.length;//定义指针偏移量，记录从后往前存入数组时，最后一个存入元素的位置。
while(num!=0){//有效数字取完则结束循环
int temp = num&base;//取最低的offset位的值。
res[--pos]=chs[temp];//将值存入结果数组中
num =num >>> offset;//无符号右移offset位。
}
//打印结果
for(int x = pos;x
System.out.print(res[x]);
}
System.out.println();
}
}
5，变量
就是将不确定的数据进行存储，也就是需要在内存中开辟一个空间，该空间有自己的名称和类型，即变量名称和数据类型。
格式：
数据类型变量名=初始化值；
数据类型：
基本数据类型：整数数值型(byte,short,int,long)、浮点数值型(float,double)、布尔型(boolean)、字符型(char)
引用数据类型：类(class)、接口(interface)、数组([ ])
数据类型的转换：
分为自动类型转换(隐式类型转换)和强制类型转换(显示类型转换)
自动类型转换：
转换的优先级是double>float>long>int>byte,short,char。byte、short和char是平级的，它们参与运算时都至少先转为int，然后再参与运算。
强制类型转换：
也叫显式类型转换。当把优先级高的数据类型或表达式结果赋值给优先级低的数据类型时，要强转。
给一个变量赋值，
大体可以分为下面两类：
a：等号右边全是由常量和运算符组成的表达式：因为都是常量，所以虚拟机在编译期就能知道表达式的结果，并判断结果是否在被赋值的变量的类型范围内，如果在则直接赋值，如果不在则需要强制转换。
b：等号右边有变量参与运算：如果参与运算的变量是byte、short、char，它们会先转变为int类型，再参与运算，类型总是会提升。
6，运算符
(1)算术运算符(7个)
+：正号，加，字符串连接符。
-：负号，减。
*：乘
/：除(整数处时，结果仍为整数，e.g.：int num=3570；num=num/1000*1000，结果num的值为3000)
%：取模(取余数)(注意：结果的正负紧跟左边的符号)
++：前自增，后自增
--：前自减，后自减。
(2)赋值运算符：
= , +=, -=, *=, /=, %=(6个)
注意：对于byte x=5；来说，x=x+1，是错误的，需要强制转换；x+=1，x+=1000000却可以直接通过编译。
(3)比较运算符：
==，!=，，<=，>=，instanceof(检查是否是类的对象)
注意：比较运算符的结果都是boolean型的，==不能误写成=。
(4)逻辑运算符(6个)：
用于连接boolean型表达式
&：与–有false则为false，两边都为true则为true。
|：或–有true则true，两边都为false则为false。
!：非：非true为false。
^：异或，一真一假则为true，全真或全假则为false(与|的不同是：两边为true时，结果为false)。
&&：与短路，左边为false，则右边不再运算。
| |：或短路，左边为true，则右边不再运算。
(5)位运算符：
主要是二进制运算，是效率最高的。
<
>>：带符号右移，最高位是0，则空位补0；最高位是1，则空位补1。
>>>：无符号右移，无论最高位是0还是1，空位都补成0。
&：相应位上都为1，结果才为1。(与上1，7，15，结果相当于取出该数的最低1位、3位和4位，与>>>配合使用，可以取出
一个数的所有二进制位。)
|：相应位上只要有一个为1，结果就为1.
^：相应位上不同，结果才为1。(特性：一个数m，连续^n两次，结果仍为m)
~：单元运算符，二进制位上若为0，则变为1；若为1，则变为0。
(6)转义字符：
通过\来转变后面字母或者符号的意义。
\n：换行
\b：退格
\r：按下回车键
\t：制表符
7，语句
判断结构语句if；选择结构语句switch；循环结构语句while，do while，for。
if：
有3种形式。if..else.. ,>
根据指定月份，打印该月份的季节
/*这是if语句练习*/
//需求：根据指定月份，打印该月份的季节
//3,4,5 春季 6，7,8 夏季 9，10,11 秋季 12,1，2 冬季
class IfTest
{
public static void main(String[] args)
{
int x = 3;
if(x>12 && x<1)
System.out.println(x);
else if(x>=3 && x<=5)
System.out.println(x+"春季");
else if(x>=6 && x<=8)
System.out.println(x+"夏季");
else if(x>=9 && x<=11)
System.out.println(x+"秋季");
else
System.out.println(x+"冬季");
}
}
switch：
选择的类型有short，byte，int，char，枚举。
case和default之间没有顺序，匹配哪个执行哪个语句。
遇到break则结束switch语句。
while与do while：
它们的区别是do while至少执行一次循环体一次。
for：
格式是for(初始化表达式；循环条件表达式；循环后的操作表达式){执行语句}
for循环和while循环的区别是在变量在内存中的驻留时间不同，for的变量只在循环体内有效。
注意：break(跳出)和continue(继续)的使用。
break只能做循环语句和switch语句中使用，continue只能用于循环结构。
break和continue单独存在时，后边不能有语句，因为读不到，编译器会报错。
可以通过给循环定义标签的方法，来决定break和continue是作用于那个循环。
编程练习：打印九九乘法表，金字塔图形
for嵌套的九九乘法表的练习：
/*
*这是for嵌套的九九乘法表的练习
*需求：打印九九乘法表
*形如：1*1=1
1*2=2 2*2=4
1*3=3 2*3=6
…………
*/
class ForForTest
{
public static void main(String[] args)
{
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();
}
}
}
打印图形字符：
class ForForDemo
{
/* 这是for嵌套的练习*/
/*
需求：打印字符图形
形如：
***** 或者 *
**** **
*** ***
** ****
* *****
*/
public static void main(String[] args)
{
for (int x = 0; x<5 ;x++ )
{
for (int y = x;y<5 ;y++ )
{
System.out.print("*");
}
System.out.println();
}
System.out.println("--------------------------");
for (int x = 5; x>0 ;x-- )
{
for (int y = 0;y
{
System.out.print("*");
}
System.out.println();
}
System.out.println("--------------------------");
for (int x = 5; x>0 ;x-- )
{
for (int y = 6;y >x ;y-- )
{
System.out.print("*");
}
System.out.println();
}
System.out.println("--------------------------");
for (int x = 1; x<6 ;x++ )
{
for (int y = 0;y
{
System.out.print("*");
}
System.out.println();
}
}
}
打印金字塔图形：
class ForForTest2
{
/*这是for嵌套的练习
*需求：打印金字塔图形
*形如： 我的分析x x+1
* 0 0+1
* * 1 1+1
* * * 2 2+1
* * * * 3 3+1
* * * * * 4 4+1
*/
public static void main(String[] args)
{
for (int x=0;x<5 ;x++ )
{
for (int y=x;y<4 ;y++ )
{
System.out.print(" ");
}
for (int z=0;z
{
System.out.print("*");
}
System.out.println();
}
}
}
动态输入菱形需求，并打印菱形
//封装菱形个数对象
class Print
{
private int heng;
private int shu;
public void set(int heng,int shu)
{
this.heng = heng;
this.shu= shu;
}
public int getHeng()
{
return heng;
}
public int getShu()
{
return shu;
}
}
class PrintLX
{
public static void sop(Object obj)
{
System.out.print(obj);
}
//打印菱形
public static void show()
{
Print p = new Print();
p.set(5,2);
int heng = p.getHeng();
int shu = p.getShu();
for(int s=0;s
{
for (int x = 0;x<5;x++ )
{
for (int y=x;y<4;y++ )
{
sop(" ");
}
for (int z=0;z
{
sop("*");
}
for (int h= 0;h
{
for (int t=x;t<4;t++ )
{
sop(" ");
}
for (int r=0;r
{
sop("*");
}
}
System.out.println();
}
for (int x = 3;x>=0;x-- )
{
for (int y=0;y<4-x;y++ )
{
sop(" ");
}
for (int y = x*2+1;y>0 ;y-- )
{
sop("*");
}
for (int h=0;h
{
for (int y=0;y<4-x;y++ )
{
sop(" ");
}
for (int y=x*2+1;y>0 ;y-- )
{
sop("*");
}
}
System.out.println();
}
}
}
public static void main(String[] args)
{
show();
}
}
8，函数
函数就是定义在类中的具有特定功能的一段独立小程序。函数也称为方法。
函数的格式：
修饰符返回值类型函数名(参数类型形式参数1，参数类型形式参数2，)
{执行语句;
return返回值;
}
为什么要定义函数：
对拥有同样的操作功能和代码实现封装，实现重复调用，即实现代码和功能的复用。
如何定义函数：
(1)明确结果，以明确函数的返回值类型；(2)明确参与运算的未知内容，以明确参数列表。
函数的重载：
在同一个类中，允许存在一个以上同名的函数，只要他们的参数类型或参数个数不同。
重载的特点：
与返回值无关，只看参数列表，重载函数之间可以重复调用。
重载的好处：
优化程序设计。
9，数组
同一类型数据的集合，是一种容器，固定长度。
数组的格式：
1)：元素类型[]数组名= new元素类型[数组长度];
2)：元素类型[]数组名= new元素类型[元素1,元素2,……,……,元素n];
或者元素类型[]数组名= {元素1,元素2,……,……,元素n };
注意：数组长度为integer.MAX_VALUE。
二维数组：
即一个数组的元素是一个数组。
二维数组的格式：
1)：形如int[ ] [ ] arr = new int[4] [5];
int[ ] [ ] arr = new int[4] [ ];
2)：形如int[ ] [ ] arr = {{1,2,3},{4,5,6},{7,8,9}};
二维数组的特殊写法：
int [ ] x y[ ],这时y是一个二维数组。
数组异常：
(1)空指针异常NullPointerException; (2)数组角标越界异常ArrayIndexOutOfBoundsException。
数组的常见操作：
(1)获取最值; (2)排序(选择、冒泡)；(3)查找元素角标。
数组的内存结构：
java中的内存分为5个部分：寄存器，本地方法区，方法区，栈内存，堆内存。
栈内存用于存储局部变量，当数据使用完，所占空间会被释放。
堆内存用于存储对象和数组，他们通过new建立的实例都存放在堆内存中。每个实体都有内存地址值，每个引用指向这个地址。当每一个实体不被任何引用指向时，堆内存中的垃圾回收机制会不定时的将之自动消清除。
数组结构内存图示：
数组示例1：给定一个数组，获取数组的最值。
class ArrayTest
{
/*
*这是数组的练习
*需求：给定一个数组，获取数组的最值。
*思路：定义一个临时变量存储比较临时最值。
*步骤：1，定义变量，初始化为数组中的任意一个元素。
2，通过循环语句对数组进行遍历，
3，在遍历过程中定义判断条件，把获得的最值赋值给变量。
定义一个功能来实现，提高复用性。
明确结果：数组中的最值。
明确参与的未知内容：一个数组int[] arr。
*/
public static void main(String[] args)
{
int[] arr={1,2,3,4,5,6,7,8,9,10};
//这是利用角标值为初始化变量值
int Max = getMax_1(arr);
int Min = getMin_1(arr);
//这是利用角标为初始化变量值
//int Max = getMax_2(arr);
//int Min = getMin_2(arr);
System.out.println("Max="+Max);
System.out.println("Min="+Min);
}
public static int getMax_1(int[] arr)
{
//这是获取max值
int max=arr[0];
for (int x=0 ;x
{
if (arr[x]>max)
{
max=arr[x];
}
}
return max;
}
public static int getMin_1(int[] arr)
{
int min=arr[0];
for (int x=0;x
{
if (arr[x]
{
min=arr[x];
}
}
return min;
}
public static int getMax_2(int[] arr)
{
int max=0;
for (int x=0;x
{
if (arr[x]>arr[max])
{
max=x;
}
}
return arr[max];
}
public static int getMin_2(int[] arr)
{
int min=0;
for (int x=0;x
{
if (arr[x]
{
min=x;
}
}
return arr[min];
}
}
数组示例2：数组的选择排序
class ArrayTest2
{
/*
*这是数组的选择排序的练习
*需求：给定一个数组，将数组中的元素排序
*思路：从第一个元素起开始与其角标后面的数组元素比较，将比较得到最小值放在当前角标位置。
当前角标加一，重复第一个元素的操作，获取比较最小值。
*步骤：1，使用嵌套for循环对数组进行遍历。
2，定义变量和判断条件，交换比较值
*/
public static void selectSort(int arr[])
{
/*
这是选择排序功能。
*/
for (int x = 0; x
{
for (int y = x+1; y
{
if(arr[x]>arr[y])
{
int temp= arr[x];
arr[x]=arr[y];
arr[y]=temp;
}
}
}
System.out.println();
}
public static void main(String[] args)
{
int[] arr={3,2,4,1};
//排序前打印
prinArray(arr);
//排序
selectSort(arr);
//排序后打印
prinArray(arr);
}
public static void prinArray(int[] arr)
{
/*
这是一个打印数组的遍历功能。
*/
System.out.print("[");
for (int x=0;x
{
if(x!=arr.length-1)
{
System.out.print(arr[x]+",");
}
else
{
System.out.print(arr[x]+"]");
}
}
}
}
数组示例3--数组的冒泡排序。
class ArrayTest3
{
/*
*这是数组的冒泡排序练习。
*思路：相邻两个数组元素比较，符合条件则换位。每一次比较的元素减1。
*步骤：1,使用for嵌套循环对数组遍历。
2，定义判断条件和变量，符合判断条件则交换元素位置。
*/
public static void bubbleSort(int[] arr)
{
for (int x = 0;x
{
for (int y = 0;y
{
if (arr[y]>arr[y+1])
{
int temp = arr[y];
arr[y]= arr[y+1];
arr[y+1]=temp;
}
}
}
System.out.println();
}
public static void main(String[] args)
{
int[] arr={6,5,4,3,2,1};
prinArray(arr);
bubbleSort(arr);
prinArray(arr);
}
public static void prinArray(int[] arr)
{
/*
这是一个打印数组的遍历功能。
*/
System.out.print("[");
for (int x=0;x
{
if(x!=arr.length-1)
{
System.out.print(arr[x]+",");
}
else
{
System.out.print(arr[x]+"]");
}
}
}
}
3609
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
