##概述
我们需要了解一些基础的java语法来进行java的学习，这里我做了一些小小的总结，具体涉及以下内容：标识符，关键字，常量，变量，基本数据类型的转换，引用数据类型，程序的格式，运算符，语句，方法，递归。是通过看视频，看书了解的，现在拿出来与大家分享。这部分的学习大概从2015年10月开始。
##标识符
1，标识符就是一切可以起名字的地方：包名，类名，方法名。
2，标识符命名规则
1，必须 以___，字母，KaTeX parse error: Expected group after '_' at position 19: …者是数字组成。 2，必须 以_̲__，字母，符号为开头
3，不能与关键字同名
4，对大小写敏感，长度没有限制
5，见名知意，最好用英文表述
##关键字
1，记住：void关键字表示该方法没有返回值
2，记住：一个类里只允许一个public修饰符的类的存在，其它可以有多个
3，记住：关键字全部都是英文小写字母
##常量
1，常见常量类型
1. 整形常量：int ，long
2. 浮点型常量：float，double
3. 字符常量（char）：‘a’
4. 字符串常量（string）：“abcdefg”
5. 逻辑常量（boolean）：布尔类型，true ，false
2，常量还可以表示值不可以改变的变量，例如final关键字
##变量
1，变量要素：变量名，值，作用域
2，先声明再赋值 double d1,d2,d3=0.123 (注意：这里只有d3=0.123)，一定要先声明再赋值，局部变量必须赋初始值，否则无法编译，成员变量只需声明。
**3，程序执行过程：**程序首先存在于硬盘上------然后被装载到内存区-------内存会找到main方法---------内存里分四部分：代码区，静态变量和字符串常量，存放局部变量的栈，堆：所有new出来的东西
栈里的局部变量从堆里new出一个空间，所以引用数据类型有两块儿内存空间
**4：局部变量：**在方法体里面声明的变量，成员变量：在类体里面，方法体外边声明的变量，注意方法的参数属于局部变量
**5：按照方法的作用域划分变量：**凡是在大括号里声明的变量，出了大括号就没人认识它了，在这个大括号里边的都认识它。
6，按照数据类型划分变量
靠内存的大小和内存的排列来区分数据类型
2进制转10，10进制转2，2若要想转8或16则先转为10
所有的数据类型在所有的操作系统上占的位数都一样，所以可以跨平台。
注意：java语言整型默认为int型，声明long型常量时候需要后边加’L’或者‘l’，但即使超出了int的表述范围，也不用担心，不会报错但会导致数值计算错误。
java语言默认浮点型常量为double型，如果要声明一个常量float型，则需要在后边加f或者F， 直接转不过去，直接转会导致溢出现象float在小数点后7位，double在小数点后15位大概
7，变量部分代码解析
public class testvar {
//int j;
static int j; // 成员变量，可以作用于整个类
public void m() { // 虽然在main方法里也有i，但没关系，作用域都是本方法
int i = 0;
System.out.println(i);
}
public static void main(String[] args) {
int i=0 ;
int t=i+5; //这里局部变量i必须先被赋初始值，否则不能编译。
int k=j+5; //成员变量可以不用赋初始值，系统会默认分配
System.out.println(k);
//testvar tt=new testvar(); //非静态方法，需要先new出一个对象来，然后再调用
System.out.println(i);
//System.out.println(tt.j);
System.out.println(j); //只有成员变量定义为static，才可以直接打印
System.out.println("tianmaolin" + 123); // 这个属于常量的概念，直接可以打印相对应的常量值，不用定义声明赋值。
boolean b = false;
if (b) {
int c = 0;
System.out.println("b is true");
}
// System.out.println(c); //打印不出来，出了c的作用域了，根本就找不到c
long longNum1 = 8888888888888L;
**注意：**成员变量和全局变量是有区别的，成员变量并不能随意在各个方法中使用，如果想直接使用，成员变量与方法之前必须加static关键字，此时该成员变量或成员方法即相当于全局的概念，如果不加static，那么必须先new该类出一个实例，然后再调用变量和方法
成员变量会默认初始化，局部变量不会。
##基本数据类型的转换
1，布尔类型和其他类型变量不可以互相转换
2，容量小的类型可以自动转换为容量大的数据类型，byte，short，char不能互相转换，在做运算之前会自动转换为int类型。容量大的转换为容量小的需要强制转化。
特殊情况：赋值的时候：只要int类型的数没有超出（byte，short，char）的表述范围，可以直接byte a=23，而long则需要long l=1232323L
3，多种混合计算时，自动将所有数据类型转换为容量最大的一种数据类型。
4 代码测试
public static void main(String[] args) {
boolean b=true;
System.out.println(b);
byte b1=67; //byte类型直接后边赋值即可，int类型可以自动赋值到byte上，只要不超过127，但是float f=0.1就不行，必须加f，虽然没超出范围。总结起来就是整型之间虽然不是int但是只要没超过int范围就没必要加强制转换或者是末尾加l，但是浮点型的不行，一定得加强制转换或者是末尾加f。
byte b2=99;
byte b3= (byte)(b1+b2); //在计算之前（byte，short，char会自动转换为int，所以需要强制转换为byte）
System.out.println(b3); //如果直接超过127 ，不会有溢出错误，直接砍掉多余位数
char c1='t';
int b4=b3+c1;
System.out.println(b4); //char,byte,short不可以互相转，但是可以进行混合运算
int i1=123;
int i2=456;
double d1=(i1+i2)*1.2; //系统将会自动把int型的转为double型的计算，因为浮点型的1.2是默认double型的，混合运算中又要取最大范围
System.out.println(d1);
float f1=(float)d1; //因为d1是double型的，所以要强制转换为float型的。
System.out.println(f1);
double d2=1e200;
float f2=(float)d2;
System.out.println(f2); //因为d2超出了float能承受的范围，所以会溢出
float f3=12.344343f; //后边必须加f
long l1=1234l;
long l2=3455l;
float f4=f3+l1+l2;
System.out.println(f4); //混合运算自动都变为float型的
long l3=(long)f4;
System.out.println(l3); //强行把浮点数类型的转化为整型的会导致没有小数位，不是四舍五入，而是彻底没有小数部分。
}
5，代码纠错
public static void main(String[] args) {
int i=1,j=12; //对i，j赋初始值
float f1=(float)0.1; //0.1f与这里的写法是有区别的，0.1f表示内存分配就分配了4个字节，而这种写法意思是8字节的double类型然后强制转换
float f2=123; //123默认是int类型的，可以自动转为float
long l1 = 12345678,l2=8888888888L; //l1这里没有超出int的范围，所以不用加l，而l2显然超过啦，所以必须加l
double d1 = 2e20,d2=124; //int类型自动转为double
byte b1 = 1,b2 = 2,b3 = 127; //只要没超过int的表述范围，赋值不需要加强制转化
j = j+10;
i = i/10;
i=(int)(i*0.1); //这里虽然与上边相同的计算结果，过程不一样，首先计算后为double，必须加强制转化
System.out.println(i); //i是int型，10是int型，所以计算结果为0，也必须是int型
i = (int)(i*0.1); //i是int型的，乘0.1后变为double型，必须强制转化为int型
char c1='a',c2=125;
byte b = (byte)(b1-b2);
char c = (char)(c1+c2-1); //混合运算，统统转为int，运算结束后再转为char型的
float f3 = f1+f2;
float f4 = (float)(f1+f2*0.1);
double d = d1*i+j;
float f = (float)(d1*5+d2);
}
##引用数据类型
除了基本数据类型，都是引用类型，引用类型占两块内存，一块为空值，定义一个引用类型，什么都不放另一块为引用类型new出来的 。放堆里边进行动态内存分配，不用的时候就会被垃圾回收机制回收。
同一类中的不同对象，共享该类方法，有不同的成员变量存储空间。
##程序的格式
package generaltest;
public class normal { // 1，大括号之间对齐 ，2遇到"{"缩进以表明是本代码块儿里的内容
int j = 111;
// 3，程序块儿之间要加空格
public static void main(String[] args) {
System.out.println("HW"); System.out.println("mmmm"); // 4,并排语句之间加空格
System.out.println("KKK");
int i = 8; //5,赋值语句符号两边要各有一个空格
}
public void m() { //6,左"{"前边最好有空格
System.out.println("LLLL");
}
}
##运算符
i++:相当于先运算么，再给i加1. ++i；相当于先加1再运算
a^b（异或）:相异为true
&和&&的重要区别：&&在计算机中只需得出第一个表达式为假，第二个操作数不需要再计算了，而&必须将两个操作数都算完才可以
重要：+两边只要有一个字符串，那么系统会将令一个自动转换为字符串
当进行打印时，无论何种数据类型，都转化为字符串类型进行打印
运算符优先级问题
三目条件运算符
x一定为boolean类型的表达式
##语句
if中只有一句语句可以省略掉“{”但是不要省略任何大括号！！！！！
条件语句测试程序
public class choose {
public static void main(String[] args) {
int i = 7;
if (i < 20) {
System.out.println("free");
} else if (i < 40) {
System.out.println("normal:100yuan");
} else if (i < 60) {
System.out.println("free");
} else {
System.out.println("ok,you are right");
}
switch (i) { //java中的switch只能探测int型的数据
case 3:
System.out.println(33);
break; //每个break必须要打，如果没有，就会发生case穿透问题，直接连同下一个case内容都打印出来
case 4:
case 7:
case 12: //多个case可以合并到一起，是或的关系
System.out.println(44);
break;
case 5:
System.out.println(55);
break;
default: //default可以省略，但最好不要省略，破坏了程序的健壮性
System.out.println("error");
break;
}
}
这个流程图把for循环讲的太好了，简直完美！！！
public static void main(String[] args) {
for(int i=1;i<=99;i+=2) {
result+=i;
}
System.out.println(result);
}
1+3+5……+99;
选中部分代码按tab可以集体向右
同时按中shift+tab可以向左缩进
循环代码解析
第一个是测试循环
第二个是通过循环的方式打印斐波那契数列
public static void main(String[] args) {
int result = 0;
for (int i = 1; i <= 99; i += 2) {
result += i;
}
System.out.println(result);
int x = 0;
while (x < 10) {
System.out.println(x);
x++;
} //while....是先判断条件然后执行语句
x = 0; //注意这里不能int x=8,因为同一个作用域内，同一变量不能被声明两次
do { //do...while是先执行一次再判断条件
x++;
System.out.println(x);
} while (x < 10); //注意后边的分号！！
int stop=4;
for(int i=1;i<=10;i++){
if(i==stop) break; //注意if语句后边不要加分号！！！！
System.out.println("i="+i); //终止整个语句块儿的循环，跳出循环语句
}
int skip=3;
for(int i=1;i<=10;i++){
if(i==skip) continue; //终止本次值的循环，直接跳到下一次
System.out.println("i="+i);
}
System.out.println(fabonacciloop(-3)); //用循环的方式解决斐波那契数列问题
}
public static long fabonacciloop(int index) {
if (index<1) {
System.out.println("erro");
return -1;
}
if (index == 1 || index == 2) {
return 1;
} else {
long f1 = 1L;
long f2 = 1L;
long f = 0L;
for (int i = 3; i <= index; i++) {
f = f1 + f2;
f1 = f2;
f2 = f; //循环，变量互换赋值
}
return f;
}
}
循环测试小例子
第一个是每隔5个为一行打印出100内能被3整除的数
第二个是打印出100–200之间所有的质数
public class testloop {
public static void main(String[] args) {
int num = 0;
for (int i = 0; i < 100; i++) { //0~100之内能被3整除的数
if (i % 3 == 0) {
System.out.println(i);
num++;
}
if(num==5){
break; //如果计数达到5个可以被3整除，则终止计数
}
}
System.out.println("=======================我是分割线===================");
for (int i = 101; i < 200; i+=2) {
boolean f=true;
for (int j = 2; j < i; j++) {
if (i%j==0) {
f=false; //如果不是质数，设f为false，然后终止本次循环
break; //注意，这里只是把内层循环终止了
}
}
if(!f){ //如果不是质数，执行跳过，没跳过的都是质数，打印出来
continue;
}
System.out.println(i);
}
}
##方法
public class testmethod {
public static void main(String[] args) { //主车间，进行组装的地方
m();
m2(2); //这里传入的4， 相当于实参，实际传入的参数
m3('3', 4);
m4(4, 6); //有返回值，但是并没有被打印出来
/*int i = m4(4, 6);
System.out.println(i);*/ //把该返回值传给i，然后打印出该返回值
}
public static void m() { //该分车间不返回任何值，只是顺序执行
//return; //直接return会报错，因为没有任何语句得到执行
System.out.println("ok");
System.out.println("hello");
}
public static void m2(int i) { //形式参数i，必须传入一个值且必须为int类型的
if(i > 3)
return;
System.out.println(i);
}
public static void m3(int i, int j) { //该分车间可以有两个
System.out.println(i + j);
}
public static int m4(int i, int j) { //该分车间具有返回值
return i > j ? i : j;
}
##递归
public class recurison { // 类只能有一个public，方法不限
public static void main(String[] args) {
System.out.println(method(3));
System.out.println(fibonacci(5));
}
public static int method(int n) {
if (n == 1) {
return 1;
} else {
return n * method(n - 1); // 递归，n的阶乘
}
}
public static int fibonacci(int n) {
if (n == 1 || n == 2) {
return 1;
} else {
return fibonacci(n - 1) + fibonacci(n - 2); //斐波那契数列
}
}
京公网安备 11010502036488号