框架图
环境搭建
课程中常见dos命令：
path 环境变量的作用是指定命令搜索路径，在命令行下面执行命令如javac编译java程序时，它会到path变量所指定的路径中查找看是否能找到相应的命令 程序。我们需要把jdk安装目录下的bin目录增加到现有的path变量中，bin目录中包含经常要用到的可执行文件如javac/java /javadoc等，设好path变量后，就可以在任何目录下执行javac/java等工具了。
classpath环境变量的作用是指定类搜索路径，要使用已经编写好的类，JVM就是通过classpath来寻找类的。如果需要访问当前目录可以用“.”表示。
语法
关键字
Java语言中已经被赋予特定意义的一些单词，它们在程序上有着不同的用途，不可以把关键词作为类名、变量名、方法名、类型名、数组名、文件名等名字来用。
◆为了提高阅读性，应该具有特定的意义
Java中的名称规范：
包名：多单词组成时所有字母都小写。
xxxyyyzzz
类名接口名：多单词组成时，所有单词的首字母大写。
XxxYyyZzz
变量名和函数名：多单词组成时，第一个单词首字母小写，第二 个单词开始每个单词首字母大写。
xxxYyyZzz
常量名：所有字母都大写。多单词时每个单词用下划线连接。
XXX_YYY_ZZZ
数据类型
数据类型的转换就是把一种基本数据类型变量转变成另一种基本类型变量。
◆ 精度由低到高排列为：
低———————————————→高
byte short char int long float double
◆ 当把级别低的变量的值赋给级别高的变量时，系统自动完成数据类型的转换。
◆ 当把级别高的变量的值赋给级别低的变量时，必须使用显示类型转换运算。
◆ 高精度向低精度转换容易造成精度损失。
自动类型提升
byte b = 3;
int x = 4;
x = x + b;//b会自动提升为int类型进行运算。
强制类型转换
byte b = 3;
b = b + 4;//报错
b = (byte)(b+4);//强制类型转换，强制将b+4的结果转换为byte类型，再赋值给b。
算术运算符
赋值运算符
= , +=, -=, *=, /=, %=
示例：
int a,b,c; a=b=c =3;
int a = 3; a+=5;等同运算a=a+5;
-=, *=, /=, %=类推
short s = 3;
空位补0，被移除的高位丢弃，空缺位补0。
>>
被移位的二进制最高位是0，右移后，空缺位补0；
最高位是1，空缺位补1。
>>>
被移位二进制最高位无论是0或者是1，空缺位都用0补。
x ^ n ^ n = x，一个数异或另一个数两次，结果仍是这个数。主要用于加密。
不同二进制位进行^ 运算，结果是1。1^0=1 , 0^1=1
int n = 3,m = 8;
//1,通过第三方变量。
int temp;
temp = n;
n = m;
m = temp; //2,不用第三方变量。
11 = 3 + 8;
3 = 11 - 8;
8 = 11 - 3; n = n + m;
m = n - m;
n = n - m;//如果n和m的值非常大，容易超出int范围。 //3,使用异或
n = n ^ m;
m = n ^ m;//(n^m)^m
n = n ^ m;//n ^ (n ^ m)
练习把一个十进制数转成十六进制
class GetNumDemo {
public static void main(String[] args){
int num = 77;
//获取77的最低4位，通过&15；
int n1 = num & 15;
System.out.println(n1>9?(char)(n1-10+'A'):n1);//68 ，这里无法强转因为char与n1比较自动提升数据类型
//获取下一组四位，将77右移4位。
int temp = 77>>>4;
//对temp的值进行最低四位的获取，通过&15；
int n2 = temp & 15;
System.out.println(n2>9?(char)(n2-10+'A'):n2);//4
}
}
三元运算符
格式:(条件表达式)?表达式1：表达式2；
如果条件为true，运算后的结果是表达式1；
如果条件为false，运算后的结果是表达式2；
//获取两个数中大数。
int x=3,y=4,z;
z=(x>y)?x:y;
//z=4
判断结构语句
if语句三种格式
1.
if(条件表达式)
{
执行语句；
}
2.
if(条件表达式)
{
执行语句；
}
else
{
执行语句；
}
//if-eise语句与三元运算符的区别是三元运算符简化了代码但要有运算结果
3.
if(条件表达式)
{
执行语句；
}
else if (条件表达式)
{
执行语句；
}
……
else
{
执行语句；
}
选择结构语句
switch语句格式：
switch(表达式)
{
case 取值1:
执行语句；
break；
case 取值2:
执行语句；
break；
…...
default:
执行语句；
break；
}
switch语句特点：
b,case之间与default没有顺序。先执行第一个case，没有匹配的case执行default。
c,结束switch语句的两种情况：遇到break，执行到switch语句结束。
d,如果匹配的case或者default没有对应的break，那么程序会继续向下执行，运行可以执行的语句，直到遇到break或者switch结尾结束。
while语句格式：
while(条件表达式)
{
执行语句；
}
do while语句格式：
do
{
执行语句；
}
while(条件表达式);
while:先判断条件，只有条件满足才执行循环体。
do while: 先执行循环体，在判断条件，条件满足，再继续执行循环体。
简单一句话，do while无论条件是否满足，循环体至少执行一次。
for语句格式：
for(初始化表达式；循环条件表达式；循环后的操作表达式)
{
执行语句；
}
注：
a.for里面的连个表达式运行的顺序，初始化表达式只读一次,判断循环条件,为真就执行循环体，然后再执行循环后的操作表达式，接着继续判断循环条件, 重复找个过程，直到条件不满足为止。
b.while与for可以互换，区别在于for为了循环而定义的变量在for循环结束就是在内存中释放。而while循环使用的变量在循环结束后还可以继续使用。for的初始化动作在内部,while初始化动作在外部,变量在内存中的驻留时间不一样。while中的变量在下面的代码中仍然可以使用。如果变量只是为了循环存在，也就是需要定义增量，使用for比较合适，内存比较优化。
c.循环要注意哪些语句需要参与循环，那些语句不需要。
d.最简单无限循环格式：while(true){} , for(;;){},无限循环存在的原因是并不知道循环多少次，而是根据某些条件，来控制循环。
e.语句的结束，要么是“；”要么是“}”。例如，while(x<3);没有执行语句会不断的判断条件。
其他流程控制语句
break语句：应用于选择结构和循环结构。
continue语句：应用于循环结构。
注：
a,这两个语句离开应用范围，存在是没有意义的。
b,这个两个语句单独存在下面都不可以有语句，因为执行不到。
c,continue语句是结束本次循环继续下次循环。
d,标号的出现，可以让这两个语句作用于指定的范围。
求1-100所有奇数和和奇数的个数（累加和计数器）
class GetSum
{
public static void main(String[] args)
{
//1,定义变量用于存储不断变化的和。
int sum = 0;
//2，定义变量，记录住不断变化的被加的数。
int x = 1;
//3，定义计数器
int count=0;
//3，定义循环，重复加法的过程。
while(x<=100)
{
if (x%2==1){
sum +=x;
count++;}
else{
sum += 0;}
x++;
}
//改写三元运算符格式
/* while(x<=100)
{sum=(x%2==1)?sum+x:sum+0;
if（x%2==1）
count++
x++；}*/ //改写for形式
/*int sum = 0;
int count=0;
for (int x=1;x<=100 ;x++)
{
if (x%2==1)
{sum+=x;count++;
}
}*/
System.out.println("sum="+sum);
System.out.println("count="+count);
}
}
练习嵌套For循环打印矩形、平行四边形、三角形和菱形
/*
使用嵌套循环用“*”输出矩形、平行四边形、三角形和菱形
*/ public class Test_LoopDemo
{
public static void main(String[] args)
{
PrintRect();
System.out.println("----------------------");
PrintParallelogram();
System.out.println("----------------------");
PrintTriangle ();
System.out.println("-----------------------");
PrintRhombus ();
} // PrintRect输出矩ln形五行五列 public static void PrintRect (){
//外循环控制输出5行“*”
for (int i = 1; i <= 5; i++ ){
//内循环控制每行输出“*”
for (int j = 1; j <= 5; j++){
System.out.print ("*");
}
System.out.print ("\n");//换行打印
}
} //PrintParallelogram输出平行四边形 public static void PrintParallelogram (){
for (int i = 1; i <= 5; i++ ){
for (int k = i; k <= 5; k++){
System.out.print (" ");
}
for (int j = 1; j <= 5; j++){
System.out.print ("*");
}
System.out.print ("\n");
}
} //PrintTriangle输出三角形
public static void PrintTriangle (){
for (int i = 1; i <= 5; i++ ){
//控制输出空格
for (int k = i; k <= 5; k++){
System.out.print (" ");
}
//内循环控制每行输出“*”
for (int j = 1; j <= 2 * i - 1; j++){
System.out.print ("*");
}
System.out.print ("\n");//换行打印
}
} //PrintRhombus输出菱形
public static void PrintRhombus (){
//输出正三角
for (int i = 1; i <= 5; i++ ){
//控制输出空格
for (int k = i; k <= 5; k++){
System.out.print (" ");
} //内循环控制每行输出“*”
for (int j = 1; j <= 2 * i - 1; j++){
System.out.print ("*");
}
System.out.print ("\n");//换行打印
}
//输出倒三角
for (int i = 1; i <= 4; i++ ){
//控制输出空格
for (int k = i-1; k <= 2 * i - 1; k++){
System.out.print (" ");
}
//内循环控制每行输出“*”
for (int j = 7; j >= i *2 - 1; j--){
System.out.print ("*");
}
System.out.print ("\n");//换行打印
}
}
}
运行结果：
函数
函数也称为方法，是定义在类中的具有特定功能的一段独立小程序。
修饰符返回值类型函数名(参数类型形式 参数1, 参数类型形式 参数2,...)
{
执行语句;
return 返回值;
}
返回值类型：函数运行后的结果的数据类型。
参数类型：是形式参数的数据类型。
形式参数：是一个变量，用于存储调用函数时传递给函数的实际参数。
实际参数：传递给形式参数的具体数值。
return：用于结束函数。
返回值：该值会返回给调用者。
函数特点：
定义函数可以将功能代码进行封装
便于对该功能进行复用
同时提高了代码的复用性
函数只有被调用才会被执行
对于函数没有具体返回值的情况，返回值类型用关键字void表示，那么该函数中的return语句如果在最后一行可以省略不写。
注意：
函数中只能调用函数，不可以在函数内部定义函数。
定义函数时，函数的结果应该返回给调用者，交由调用者处理。
函数的应用
明确要定义的功能最后的结果是什么？明确函数的返回值类型
明确在定义该功能的过程中，是否需要未知内容参与运算？明确函数的参数列表（参数的类型和参数的个数）
函数的重载(overload)
在同一个类中，允许存在一个以上的同名函数，只要它们的参数个数或者参数类型不同即可。
重载的特点：
与返回值类型无关，只看参数列表。参数的顺序不同，参数列表也会不同。
重载的好处：
方便于阅读，优化了程序设计。
数组
数组是同一种类型数据的集合。其实数组就是一个“容器”。数组中的数据就是“元素”、
数组可以自动给数组中的元素从0开始编号，方便操作这些元素。
格式1：
元素类型[] 数组名= new 元素类型[元素个数或数组长度];
示例：int[] arr = new int[5];
格式2：
元素类型[] 数组名= new 元素类型[]{元素，元素，……};
int[] arr = new int[]{3,5,1,7};
int[] arr = {3,5,1,7};
Java程序在运行时，需要在内存中的分配空间（栈内存，堆内存，方法区，本地方法区，寄存器）。为了提高运算效率，有对空间进行了不同区域的划分，因为每一片区域都有特定的处理数据方式和内存管理方式。
栈内存
- 用于存储局部变量，当数据使用完，所占空间会自动释放。
堆内存
- 数组和对象，通过new建立的实例都存放在堆内存中。
- 每一个实体都有内存地址值
- 实体中的变量都有默认初始化值
- 实体不在被使用，会在不确定的时间内被垃圾回收器回收
- 方法区，本地方法区，寄存器
二维数组[][]
格式1：int[][] arr = new int[3][2];
定义了名称为arr的二维数组
二维数组中有3个一维数组
每一个一维数组中有2个元素
一维数组的名称分别为arr[0], arr[1], arr[2]
给第一个一维数组1脚标位赋值为78写法是：arr[0][1] = 78;
格式2：int[][] arr = new int[3][];
二维数组中有3个一维数组
每个一维数组都是默认初始化值null
可以对这个三个一维数组分别进行初始化
arr[0] = new int[3];
arr[1] = new int[1];
arr[2] = new int[2];
格式3：int[][] arr = {{3,8,2},{2,7},{9,0,1,6}};
定义一个名称为arr的二维数组
二维数组中的有三个一维数组
每一个一维数组中具体元素也都已初始化
第一个一维数组arr[0] = {3,8,2};
第二个一维数组arr[1] = {2,7};
第三个一维数组arr[2] = {9,0,1,6};
第三个一维数组的长度表示方式：arr[2].length;
int[] x; int x[];
int[][] y; int y[][]; int[] y[];
int[] x,y[];//x一维，y二维。
int[] x;
int[] y[];
a.
x[0] = y;//error
b.
y[0] = x;//yes
c.
y[0][0] = x;//error
d.
x[0][0] = y;//error
e.
y[0][0] = x[0];//yes
f.
x=y;//error
数组的应用----获取数组遍历数组
class GetArray
{
public static void main(String[] args)
{
//数组的操作：
//获取数组中的元素。通常会用到遍历。 int[] arr = {3,6,5,1,8,9,67}; //获取数组元素个数：数组名称.length =
System.out.println("length:"+arr.length); for(int x=0; x<arr.length; x++)
{ System.out.println("arr["+x+"]="+arr[x]+";");
} //打印的数组地址值
System.out.println(arr); }
}
数组的应用----获取数组最值
class Get1
{
public static void main(String[] args)
{
int[] arr = {3,6,5,1,8,9,67}
for(int x=0; x<arr.length; x++)
{
System.out.println("arr["+x+"]="+arr[x]+";");
} int max=getMax(arr);
int min=getMin(arr);
System.out.println("max="+max);
System.out.println("min="+min);
}
public static int getMax(int[] arr)
{
int max = 0; for(int x=1; x<arr.length; x++)
{
if(arr[x]>arr[max])
max = x;
}
return arr[max];
}
public static int getMin(int[] arr)
{
int min = 0;
for(int x=1; x<arr.length; x++)
{
if(arr[x]<arr[min])
min = x;
}
return arr[min];
}
}
数组的应用----排序
/*对给定数组进行排序。
{5,1,6,4,2,8,9}*/
import java.util.*;
class ArraySort
{
//选择排序。内循环结束一次，最值出现头角标位置上。
public static void selectSort(int[] arr)
{
for (int x=0; x<arr.length-1 ; x++)
{
for(int y=x+1; y<arr.length; y++)
{
if(arr[x]>arr[y])
{
int temp = arr[x];
arr[x] = arr[y];
arr[y]= temp;
}
}
}
}
//冒泡排序
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;
}
}
}
}
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 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]+"]");
}
}
}
数组的应用----查找
class GetArray
{
public static void main(String[] args)
{
int[] arr = {3,2,1,5,4,2,9};
int index = getIndex(arr,5);
System.out.println("index="+index);
}
public static int getIndex(int[] arr,int key)
{
for(int x=0; x<arr.length; x++)
{
if(arr[x]==key)
return x;
}
return -1;
}
}
//输出结果：index=3
数组的应用----折半查找（只适用于有序数组,实际使用Arrays.binarySearch）
public static int halfSearch_1(int[] arr,int key)
{
int min,max,mid;
min = 0;
max = arr.length-1;
mid = (max+min)/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 = (max+min)/2;
}
return mid;
} public static int halfSearch_2(int[] arr,int key)
{
int min = 0,max = arr.length-1,mid; 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;
}
十六进制转换对比当时位运算
2 public static void main(String[] args) {
3 toBin(6);
4 toHex(60);
5 }
6 /*
7 十进制-->十六进制。
8 */
9 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());
}
/*
十进制-->二进制
*/
public static void toBin(int num){
StringBuffer sb = new StringBuffer();
while(num>0){
//System.out.println(num%2);
sb.append(num%2);
num = num / 2;
}
System.out.println(sb.reverse());
}
}
查表法进制转换
2 public static void main(String[] args) {
3 //toBin(-6);
4 //toHex(-60);
5 //toBa(60);
6
7 // System.out.println(Integer.toBinaryString(6));
8 // System.out.println(Integer.toHexString(6));
9 }
/*
十进制-->二进制
*/
public static void toBin(int num){
trans(num,1,1);
}
/*
十进制-->八进制
*/
public static void toBa(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) {//需要转换的数字，需要与的基础数，需要右移的位数
if(num==0){
System.out.println(0);
return ;
}
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]);
}
return ;
}
}
---------------------- ASP.Net+Android+IO开发S、.Net培训、期待与您交流！ ----------------------