关键字、标识符
任何一门高级语言基础组成都一样，表现形式不一样。
1、关键字：赋予Java含义的单词，都是小写（紫色）
class Demo{
public static void main(String[] args){
}
}
2、标识符
- 表示某些东西的符号，有规则（26个英文字母的大小写，0-9，_ ，$组成）
- 数字不能开头,不可以使用关键字
比如类名：Demo就不能写成2Demo，Demo_1$test
常量、变量与运算符
常量
常量的分类：整数、小数、布尔常量（Boolean，只有两个值，关键字，true、false）、字符（数字0-9，字母，符号，‘a’要用单引号标示）、字符串（可放多个，“”空字符串，注意与null区分）、null（只有一个数值就是null）
- 整数常量：
二进制(0,1)、八进制(0-7)、十进制(0-9)、十六进制(0-9,A-F)
例如：23（十进制）、023（八进制）、0x23（十六）
数据的最小单位：字节
变量
class VarDemo{
public static void main(String[] args) {
//数据类型 变量名 = 初始化值；
byte b = 3; //定义变量，在内存中开辟一块区域，类型是byte，名称是b，里面存着3
/*b = 8; //使用变量，使里面存放的数据为8*/
short s = 2000;
int x = 12;
long k = 12343245L;//注意L
float f = 2.3f;
double d = 3.4;
char ch = '你';
boolean bl = true;
bl = false;
{
int u = 9;
System.out.println(u);
}
System.out.println(u);
System.out.println(bl);
}
}
内存中的一个存储区域；该区域有自己名称（变量名）和类型（数据类型，强类型：指定该类型只能放在该区域）；该区域的数据可以再同一类型范围内不断变化；可以不断的被重复使用；
什么时候使用变量：数据不确定时，不管你数据如何改变，我需要时，只要从这个区域找该数据就好
数据类型（8种常用数据类型，3种引用型数据）
- 基本类型：
- 数值型：
- 1、整数类型（byte-8bit，short-16bit，int-32bit，long-64bit）
注：第一位都是符号位，如byte是-128到127，而且不用记，用Java判断 - 2、浮点类型（float-4byte，double-8byte）
字符型：char，两个字节，装单个，可以存放一个中文，但放一个12不行
布尔型：不是数值型，不能做运算
- 1、整数类型（byte-8bit，short-16bit，int-32bit，long-64bit）
- 引用类型（指向的都是对象）：
类class
接口Interface
数组array
- 数值型：
- 变量范围：两个括号中间
u只在括号中有作用，离开括号就无效
自动类型转换 /强制类型转换
- 自动类型提升/转换
class VarDemo2{
public static void main(String[] args) {
int x = 3;//4byte
byte y = 5;//1byte
x = x + y;//两边不一致，数值型可以运算，会完成一个自动类型提升的动作，一致性以占用内存比较大的为主。
System.out.println("Hello World!");
}
}
- 强制转换
class VarDemo3{
public static void main(String[] args) {
/*这是自动提升
int x = 3;//4byte
byte y = 5;//1byte
x = x + y;
//两边不一致，数值型可以运算，
//会完成一个自动类型提升的动作，一致性以占用内存比较大的为主。
*/
byte b = 3;//这里b是1个8位
// b = b + 4;
//这里4是一个整数，默认是4个8位，
//运算时，b要提升，当运算完，4个8位的结果赋值不了1个8位的b
b = (byte)(b + 4);//强制转换,但会丢弃高的3个8位
System.out.println(b);
System.out.println('a'+1);
}
}
float与int做运算还是小数
char与int做运算后是int
byte b = 3;
b = 4 + 6;
System.out.println(b);
byte b =3;//这里一个b是8位
byte b1 = 4;
byte b2 = 6;
b = b1 + b2;
System.out.ptintln(b);
比较上面两种结果：
定义了b的类型是byte，在给b赋值常量（int）4后，会做一个将4（int） 转换为byte的动作。
第一种是常量，是固定的，可以检查判断是否在范围之内，不会报错。
第二种是变量，是不确定的，无法判断是否在范围内，假设b1=127。
变量是变化的，一变化很容易丢精度 ，无法判断是否在范围内，会报错。
byte b1 = 4;
byte b2 = 6;
int b = b1 + b2;
System.out.ptintln(b);
这样可以，因为不管两个变量如何改变，使用在x的范围内。
int x;
int x1 = Integer.MAX_VALUE;
int x2 = 2;
x = x1 + x2;
System.out.ptintln(x);
int不会报错，只保留32位，高位舍弃，舍弃代表最高位变成1，是负数，因为是默认类型。
运算符
算术运算符：
除法舍弃小数位，+，-，*，/，%（4%5=4，利用%2的特点0，1进行开关运算），
+（连接符，3+“21”=321，任何数加字符串，如：“5”）。
class OperateDemo {
public static void main(String[] args) {
int a=2,b;
// a++; //独立运算,a=a+1
// b = a++; //a=3,b=2,这里的a既有自增运算，又有赋值运算，所以a先保留自己的值，先做右边自己的自增运算，a=3，然后保留的值参与赋值运算，b=2
//右面的a++没算完，不能参与左面的赋值运算，所以要保留自己的值，对两面进行运算，左面赋值，右面做自己的自增
// b = ++a; //a=3,b=3,同理，这里是右面的a自增a=3，然后整体给b，b=3
b = a = a + 1;//a=3,b=3
/*
int i = 3;
i = i++;
过程如下
temp=i;
i=i+1;
i=temp;
*/
System.out.println("a="+a+","+"b="+b);//
}
}
- 赋值运算符
class OperateDemo2{
public static void main(String[] args){
int a=2,b;
//赋值运算符。 = += -= /= %=
// int a,b,c;
// a =b=c=4
// int a = 4;
// a+=2;//左右两边的和赋给左边
short s = 3;//short两个字节
s+=4;//不会报错，这是一次运算，两边加完以后，会判断，在范围内转换为short，在底层自动做转换
//s = s + 4;//会报错，变量未知，精度丢失，无法判断范围，这是两次运算，与上面唯一的不同是不做转换。
//s = (short)(s + 4)；
System.out.println("a="+a+","+"b="+b);//
}
}
只要是运算符，运算完都有结果
- 比较运算符
>,<,== 结果是true/false
| 运算符 | 运算 | 范例 | 结果 |
|---|---|---|---|
| ==/!= | 相等于/不等于 | 4==5/4！=5 | false/true |
| </> | 大于/小于 | 4<3/4>3 | false/true |
| <=/>= | 大于等于/小于等于 | 4<=5/4>=5 | true/false |
- 逻辑运算符(用于连接两个boolean类型的表达式)
&：与， true&true=true，int x=4 x>2&x<5 true
|：或，
：异或，相同为零，不同为一，truetrue=false；false^false=false
!：非运算，判断 ！true=false
&&：短路；遇零为零，后面不运算；与&结果一样
||：短路；遇一为一，后面不运算；与|结果一样 - 位运算符（用于二进制位运算的符号）
class OperateTest {
public static void main(String[] args) {
/* //最有效的方式算出3*8
System.out.println("3*8="+(3<<3));
*/
//对两个整数变量的值进行互换
int a = 3 , b = 5;
System.out.println("a="+a+","+"b="+b);
/*
int temp = a;
a = b;
b = temp;
*/
//这种方式不要用,若超出范围，会缺失精度
/*
a = a + b;
b = a - b;
a = a - b;
*/
a = a ^ b; //a = 3 ^ 5;
b = a ^ b; //b = (3^5)^5;
a = a ^ b; //a = (3^5)^3;(利用一个数异或同一个数两次，还是这个数)
System.out.println("a="+a+","+"b="+b);
//开发实际利用第一种，面试使用第三种
}
}
&：6&3=0--0,0010（遇零为零）=2
|：6|3=0--0,0111（遇一为一）=7
^：6^3=101=5；6^3^3=6（一个数异或同一个数两次，结果还是这个数），应用：加密
~：反码，~6=-7
<<：左移，3<<2=12，3左移两位，左移乘2
>>：右移，移的时候要保证符号位一样，移的时候补的都是1
>>>：无符号右移，不论原高位是什么，都用零补
运用：想要运算高效，首选位运算，位运算直接运算在二进制！！
- 三元运算符（唯一；if,else的简化）
格式 ：（条件表达式：真/假）？表达式1：表达式2；
若条件是真，则运算1；否则，运算2
应用：
class OperateDemo5 {
public static void main(String[] args) {
int x = 3,y;
y = (x>1)?100:200;
System.out.println("y="+y);
//获取两个整数中的较大的整数。
int a,b;
int max = a>b?a:b;
//获取三个整数中的较大的整数。
int o,p,q;
int temp = o>p?o:p;
int max2 = temp>q?temp:q
//int max2 = (o>p?o:p)>q?temp:q
}
}
函数
一，定义：定义在类中具有特定功能的一段独立小程序，也称作方法。
error：静态修饰的函数在调用别的函数式，该函数也要是静态的，解决办法就是给add函数加同样的修饰符static
二，定义函数的格式：
修饰符 返回值类型 函数名（参数类型 形式参数1,参数类型 形式参数2, …）
{
执行语句；
return 返回值；
}
在Java中，Java是强类型，对每一种数据都进行了严格明细的划分。
注：名称定义要有阅读性，如果名称在两个以上的单词时，第一个单词首字母小写，之后每个单词首字母都大写
参数有顺序，return能将函数值返回给调用者，还能结束函数。
函数中只能调用函数，不能在函数中定义函数。
特殊情况：功能没有返回值。
return后面直接用分号结束。
返回值类型怎么体现？因为没有具体的返回值，所以不可以写具体的返回值类型。
在Java中只能用一个关键字来表示，返回值类型用void表示。
eg：
注意：如果返回值类型是void，return;可以省略不写
写代码要提高代码的复用性，相同的东西第二次就开始要思考是不是被复用。
三，函数特点：
将功能封装；便于该功能复用。
定义函数时，函数值要返回给调用者，由调用者处理。
四，如何写函数
两个明确：明确一：这个功能的结果是什么？
明确二：这个功能实现的过程中是否有未知的内容参与运算?
错误：public static char grade(int x)
{
char y;
if(x>=90 && x<=100)
y='A';
if(x>=80 && x<90)
y='B';
if(x>=70 && x<80)
y='C';
if(x>=60 && x<70)
y='D';
if(x<60)
y='E';
return y;//报错！！！可能尚未初始化变量
}
分析：编译用于检查代码，只检查语法，上面的代码中语法错误，编译时不会管你的范围是否找全，最后一个if就算写成（x<60||x>100），也不行。虚拟机会看你的范围，因此，编译他始终认为你的范围没有找全。下为修改后：
五，函数的重载（overload）
重复载入 ；在同一个类中，允许存在一个以上的同名函数，只要他们的参数个数或者参数类型不同即可
1、同一个类
2、同名
3、不同参数类型or不同参数个数
4,、函数重载与返回值类型无关
5、Java是严谨性语言，如果函数调用出现不确定性，会编译失败
扫一扫
1588
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
