【Java基础 一】---基础语法

##概述
我们需要了解一些基础的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);       //斐波那契数列
		}

	}

©️2020 CSDN 皮肤主题: 游动-白 设计师: 上身试试 返回首页
实付0元
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值