Java(02)语法基础

一.数据类型

1.1.整形数据类型

类型	内存	范围
byte	8位	-128~127
short	16位	-32768~32767
int	32位
long	64位

1.2.浮点数据类型

类型	内存
float	32位
double	64位

1.3.字符类型

类型	内存
char	16位

char zhChar = '中';
//char 只能存放一个字符，超过一个字符就会产生编译错误
char enChar = 'a';

1.4.转义字符

字符	说明
\ddd	\123表示是一个八进制的数,ddd都是数字
\uxxxx	\u0053 表示4位十六进制的数据
\f	换页？
%	%%

1.5.布尔类型

boolean a = true;
boolean b = false;
// 但是，不能直接使用0 1 进行赋值

1.6.引用数据类型

1.数组

2.类

3.接口

二.变量与常量

2.1.标识符

给类，变量，方法命名

组成部分可以有字母，下划线，美元符号($)，数字。还有所有ASCII码在十六进制０ｘｅ０前的字符

第一个字符不能是数字

1.包package(文件名)

全小写名称，中间可以由点分隔开

2.类class

首字母大写

3.接口名interface

首字母大写

4.方法method

首字母大写，中间的单词首字母大写

5.变量

两个单词组成，第二个单词也要大写

6.常量constant

基本数据类型	都大写 #define PRICE 30
对象类型	大小写混合
多个单词构成	下划线隔开

2.2.关键字

2.3.常量与final

1.常量已经被赋值了，不能再更改

final int i = 5;
//i在第4行已经被赋值过了，所以这里会出现编译错误
i = 10; 

2.常量没有赋值，可以第一次进行赋值

final int i;

i = 10; //i在第4行，只是被声明，但是没有被赋值，所以在这里可以进行第一次赋值

i = 11; //i在第6行已经被赋值过了，所以这里会出现编译错误

3.常量的命名

final double MATH_PI = 3.14;

2.4.运算符

1.赋值运算符

=	
+=
-=
*=
/=
%=
&=
|=
^=
<<=
>>=
>>>=	

int i = 1;
i+=++i;//i = i + i;
//右边等号第一个是原来的i=1
//i = 1 + 2;
System.out.println(i);

2.算术运算符

int i = 10;
int j = 5;
int a = i + j;
int b = i - j;
int c = i * j;
int d = i / j;

int i = 5;
int j = 2;
System.out.println(i%j); //输出为1

3.自增自减运算符

int i = 5;
System.out.println(i++); //输出5
System.out.println(i);   //输出6

int j = 5;
System.out.println(++j); //输出6
System.out.println(j);   //输出6

4.比较运算符

> 大于
>= 大于或等于
< 小于
<= 小于或等于
== 是否相等
!= 是否不等

5.逻辑运算符

1.与

//长路与  无论第一个表达式的值是true或者false,第二个的值，都会被运算
int i = 2;
System.out.println( i== 1 & i++ ==2  ); //无论如何i++都会被执行，所以i的值变成了3
System.out.println(i);

//短路与 只要第一个表达式的值是false的，第二个表达式的值，就不需要进行运算了
int j = 2;
 //因为j==1返回false,所以右边的j++就没有执行了，所以j的值，还是2
System.out.println( j== 1 && j++ ==2  ); 
System.out.println(j);     

2.或

//长路或  无论第一个表达式的值是true或者false,第二个的值，都会被运算
int i = 2;
System.out.println( i== 1 | i++ ==2  ); //无论如何i++都会被执行，所以i的值变成了3
System.out.println(i);

//短路或 只要第一个表达式的值是true的，第二个表达式的值，就不需要进行运算了
int j = 2;
//因为j==2返回true,所以右边的j++就没有执行了，所以j的值，还是2
System.out.println( j== 2 || j++ ==2  );  
System.out.println(j);     

3.取反

boolean b = true;

System.out.println(b); //输出true
System.out.println(!b);//输出false

4.异或

boolean a = true;
boolean b = false;

System.out.println(a^b); //不同返回真
System.out.println(a^!b); //相同返回假

6.位运算符

1.二进制表达

int i = 5;
 // 5的二进制的表达101
String b = (Integer.toBinaryString(i));
System.out.println(i+" 的二进制表达是: "+b);

2.位或

int i  =5;
int j = 6;

System.out.println(Integer.toBinaryString(i)); //5的二进制是101

System.out.println(Integer.toBinaryString(j)); //6的二进制是110
//所以 5|6 对每一位进行或运算，得到 111->7
System.out.println(i|j); 

3.位与

int i  =5;
int j = 6;

System.out.println(Integer.toBinaryString(i)); //5的二进制是101

System.out.println(Integer.toBinaryString(j)); //6的二进制是110

System.out.println(i&j); //所以 5&6 对每一位进行与运算，得到 100->4

4.异或

int i  =5;
int j = 6;
System.out.println(Integer.toBinaryString(i)); //5的二进制是 101
System.out.println(Integer.toBinaryString(j)); //6的二进制是110
System.out.println(i^j); //所以 5^6 对每一位进行或运算，得到 011->3

System.out.println(i^0);
System.out.println(i^i);

5.取非

 byte i  =5;
//5的二进制是00000101,所以取非即为11111010,即为-6
System.out.println(Integer.toBinaryString(i)); 

System.out.println(~i);

6.左移右移

byte i  =6;

//6的二进制是110
System.out.println(Integer.toBinaryString(i));
//6向左移1位后，变成1100，对应的10进制是12
System.out.println(i<<1);
//6向右移1位后，变成11，对应的10进制是3
System.out.println(i>>1);

1.带符号右移 >>

• 对于正数， 带符号右移 >> 会把所有的位右移，并在最前面补0
• 对于负数， 带符号右移 >> 会把所有的位右移，并在最前面补1

2.无符号右移>>>

• 如果是一个负数，那么对应的二进制的第一位是1
• 无符号右移>>会把第一位的1也向右移动，导致移动后，第一位变成0
• 这样就会使得负数在无符号右移后，得到一个正数

7.三元运算符

int k = i < j ? 99 : 88;

// 相当于
if (i < j) {
	k = 99;
} else {
	k = 88;
}

8.优先级

2.5.数据类型转换

1.精度顺序

byte<short<int<long<float<double

2.隐式转换

int x = 50;
float  y = x;//将x的值赋给y，但y是float类型的  

3.显式转换

char c = 'A';
short s = 80;
//虽然short和char都是16位的，长度是一样的
//但是彼此之间，依然需要进行强制转换
c = (char) s;
//直接进行转换，会出现编译错误
s = c;

int a = (int)45.3;

2.6.变量

不允许使用未初始化的变量

float  num1 = 1f;
double num2 = 1.23;
boolean flag = true;
char myChar = 'K';
String str = "bye";

2.7.字面值

1.整数

根据进制，可以直接赋值

long val = 26L; //以L结尾的字面值表示long型
int decVal = 26; //默认就是int型
int hexVal = 0x1a; //16进制
int oxVal = 032; //8进制
int binVal = 0b11010; //2进制
System.out.println(binVal);
//26

2.浮点数

 float f1 = 123.4F;// 以F结尾的字面值表示float类型
double d1 = 123.4;// 默认就是double类型
double d2 = 1.234e2;// 科学计数法表示double

3.字符与字符串

String name = "盖伦";
char a= 'c';

//以下是转义字符
char tab = '\t'; //制表符
char carriageReturn = '\r'; //回车
char newLine = '\n'; //换行
char doubleQuote = '\"'; //双引号
char singleQuote = '\''; //单引号
char backslash = '\\'; //反斜杠

2.8.作用域

1.参数

 public void method1(int i){ //参数i的作用域即方法method1
        System.out.println(i);
    }

2.局部变量

public void method1() {
        int i  = 5;  //其作用范围是从声明的第4行，到其所处于的块结束12行位置
        System.out.println(i);
        {            //子块
            System.out.println(i); //可以访问i
            int j = 6;
            System.out.println(j); //可以访问j
        }
		//下面该语句是错误得
        System.out.println(j); //不能访问j,因为其作用域到第10行就结束了
    }

三.数组

3.1.创建与声明

1.声明

int[] a;

2.创建

如果变量代表一个数组，比如a,我们把a叫做引用。

//声明一个引用
int[] a;
//创建一个长度是5的数组，并且使用引用a指向该数组
a = new int[5];

int[] b = new int[5]; //声明的同时，指向一个数组

3.数组默认值

1.基本数据类型

默认为0

2.char

默认是空白字符

3.boolean

默认是false

4.访问

int[] a;
a = new int[5];

a[0]= 1;  //下标0，代表数组里的第一个数
a[1]= 2;
a[2]= 3;
a[3]= 4;
a[4]= 5;

5.数组长度

int[] a;
a = new int[5];

System.out.println(a.length); //打印数组的长度

3.2.初始化

1.分配空间同时赋值

//写法一： 分配空间同时赋值
int[] a = new int[]{100,102,444,836,3236};

2.实例化

//写法二： 省略了new int[],效果一样
int[] b = {100,102,444,836,3236};

3.3.排序

1.排序

 int a [] = new int[]{18,62,68,82,65,9};
//排序前，先把内容打印出来
for (int i = 0; i < a.length; i++) {
	System.out.print(a[i] + " ");
}
System.out.println(" ");
//选择法排序

//第一步： 把第一位和其他所有位进行比较
//如果发现其他位置的数据比第一位小，就进行交换

for (int i = 1; i < a.length; i++) {
	if(a[i]<a[0]){  
		int temp = a[0];
		a[0] = a[i];
		a[i] = temp;
	}
}
//把内容打印出来
//可以发现，最小的一个数，到了最前面
for (int i = 0; i < a.length; i++) {
	System.out.print(a[i] + " ");
}
System.out.println(" ");

//第二步： 把第二位的和剩下的所有位进行比较
for (int i = 2; i < a.length; i++) {
	if(a[i]<a[1]){  
		int temp = a[1];
		a[1] = a[i];
		a[i] = temp;
	}
}
//把内容打印出来
//可以发现，倒数第二小的数，到了第二个位置
for (int i = 0; i < a.length; i++) {
	System.out.print(a[i] + " ");
}
System.out.println(" ");       

//可以发现一个规律
//移动的位置是从0 逐渐增加的
//所以可以在外面套一层循环

for (int j = 0; j < a.length-1; j++) {
	for (int i = j+1; i < a.length; i++) {
		if(a[i]<a[j]){  
			int temp = a[j];
			a[j] = a[i];
			a[i] = temp;
		}
	}
}

//把内容打印出来
for (int i = 0; i < a.length; i++) {
	System.out.print(a[i] + " ");
}
System.out.println(" ");   

2.冒泡

int a [] = new int[]{18,62,68,82,65,9};
//排序前，先把内容打印出来
for (int i = 0; i < a.length; i++) {
	System.out.print(a[i] + " ");
}
System.out.println(" ");
//冒泡法排序

//第一步：从第一位开始，把相邻两位进行比较
//如果发现前面的比后面的大，就把大的数据交换在后面

for (int i = 0; i < a.length-1; i++) {
	if(a[i]>a[i+1]){  
		int temp = a[i];
		a[i] = a[i+1];
		a[i+1] = temp;
	}
}
//把内容打印出来
//可以发现，最大的到了最后面
for (int i = 0; i < a.length; i++) {
	System.out.print(a[i] + " ");
}
System.out.println(" ");

//第二步： 再来一次，只不过不用比较最后一位
for (int i = 0; i < a.length-2; i++) {
	if(a[i]>a[i+1]){  
		int temp = a[i];
		a[i] = a[i+1];
		a[i+1] = temp;
	}
}
//把内容打印出来
//可以发现，倒数第二大的到了倒数第二个位置
for (int i = 0; i < a.length; i++) {
	System.out.print(a[i] + " ");
}
System.out.println(" ");       

//可以发现一个规律
//后边界在收缩
//所以可以在外面套一层循环

for (int j = 0; j < a.length; j++) {
	for (int i = 0; i < a.length-j-1; i++) {
		if(a[i]>a[i+1]){  
			int temp = a[i];
			a[i] = a[i+1];
			a[i+1] = temp;
		}
	}
}

//把内容打印出来
for (int i = 0; i < a.length; i++) {
	System.out.print(a[i] + " ");
}
System.out.println(" ");   

3.4.操作

1.增强型for

int values [] = new int[]{18,62,68,82,65,9};
//常规遍历
for (int i = 0; i < values.length; i++) {
	int each = values[i];
	System.out.println(each);
}

//增强型for循环遍历
for (int each : values) {
	System.out.println(each);
}

2.复制数据

int a [] = new int[]{18,62,68,82,65,9};

int b[] = new int[3];//分配了长度是3的空间，但是没有赋值

//通过数组赋值把，a数组的前3位赋值到b数组

//方法一： for循环

for (int i = 0; i < b.length; i++) {
	b[i] = a[i];
}

//方法二: System.arraycopy(src, srcPos, dest, destPos, length)
//src: 源数组
//srcPos: 从源数组复制数据的起始位置
//dest: 目标数组
//destPos: 复制到目标数组的启始位置
//length: 复制的长度       
System.arraycopy(a, 0, b, 0, 3);

//把内容打印出来
for (int i = 0; i < b.length; i++) {
	System.out.print(b[i] + " ");
}

3.5.创建对象数组

public Point[] createArray(){
	Point[] p;
	p = new Point[10];
	for(int i = 0; i < p.length; i ++ )    {
		p[i] = new Point(i,i+1);
	}
	return p;
}

3.6.多维数组

1.注意

1. 二维数组必须指定行数，列数可指定，也可不指定。
2. 可以为每行设置为空间大小不同的数组。

2.二维数组初始化

//初始化二维数组，
int[][] a = new int[2][3]; //有两个一维数组，每个一维数组的长度是3
a[1][2] = 5;  //可以直接访问一维数组，因为已经分配了空间

//只分配了二维数组
int[][] b = new int[2][]; //有两个一维数组，每个一维数组的长度暂未分配
b[0]  =new int[3]; //必须事先分配长度，才可以访问
b[0][2] = 5;

//指定内容的同时，分配空间
int[][] c = new int[][]{
	   {1,2,4},
	   {4,5},
	   {6,7,8,9}
};

3.数组拷贝System.arraycopy()

//        public static void arraycopy(Object src,int srcPos,Object dest,int destPos,int length)
//        src:源数组；
//        srcPos:源数组要复制的起始位置；
//        dest:目的数组；
//        destPos:目的数组放置的起始位置；
//        length:复制的长度。
//        注意：src and dest都必须是同类型或者可以进行转换类型的数组．
// original array
int elements[] = { 1, 2, 3, 4, 5, 6 };
// new larger array
int hold [] = new int [elements.length];
// copy all of the elements array to the hold
// array, starting with the 0th index
System.arraycopy( elements,0,hold,0,elements.length);
for (int i = 0; i < hold.length; i++){
	System.out.print(hold[i]);
}

3.7.常用方法

1.数组复制

int a[] = new int[] { 18, 62, 68, 82, 65, 9 };
 
// copyOfRange(int[] original, int from, int to)
// 第一个参数表示源数组
// 第二个参数表示开始位置(取得到)
// 第三个参数表示结束位置(取不到)
int[] b = Arrays.copyOfRange(a, 0, 3);

for (int i = 0; i < b.length; i++) {
	System.out.print(b[i] + " ");
}

2.转换为字符串

int a[] = new int[] { 18, 62, 68, 82, 65, 9 };
String content = Arrays.toString(a);
System.out.println(content);

3.排序

int a[] = new int[] { 18, 62, 68, 82, 65, 9 };
System.out.println("排序之前 :");
System.out.println(Arrays.toString(a));
Arrays.sort(a);
System.out.println("排序之后:");
System.out.println(Arrays.toString(a));

4.搜索

int a[] = new int[] { 18, 62, 68, 82, 65, 9 };
 
Arrays.sort(a);

System.out.println(Arrays.toString(a));
//使用binarySearch之前，必须先使用sort进行排序
System.out.println("数字 62出现的位置:"+Arrays.binarySearch(a, 62));

5.判断是否相同

int a[] = new int[] { 18, 62, 68, 82, 65, 9 };
int b[] = new int[] { 18, 62, 68, 82, 65, 8 };

System.out.println(Arrays.equals(a, b));

6.填充

使用同一个值，填充整个数组

int a[] = new int[10];
  
Arrays.fill(a, 5);

System.out.println(Arrays.toString(a));