java基础语法

基础操作

// Java基础规范

/*
执行步骤
1.找到Java文件目录
2.在文件目录输入cmd
3.在cmd中输入 “javac 文件名.java” （java源文件,table键快速补齐文件名）
4.确定后生成可执行文件（字节码文件）  
5.输入 “java 文件名执行”
6.编码错误，快捷键 ctrl+shift+c 转换为GBK编码

#注意事项#
1.对源文件修改后要重新进行编译运行
2.java严格区分大小写，每个语句用；结束，大括号成对出现
3.一个源文件中最多只能有一个public类，其他类不限制
4.若有public类，则文件名和类名必须一致
5.文件中每一个类编译后都会生成一个 .class 可执行文件（字节码）
6.每个类中都可以有main方法
7.print不输出换行, println打印完自动换行
*/

/**
 * @author 小明
 * @version 1.0
 */
public class Hellow{
	// 文件名和类名要一致
	public static void main(String[] args){
		System.out.println("Hello,world");
	}
}

class Dog{
	public static void main(String[] args) {
		System.out.println("Hellow,小狗狗");
	}
}


//Java转义字符
/*
1. \t 制表位，对齐，(补全空格，一个tab，字符串长度向上补全至八的倍数)
2. \n 换行符，读取时换行
3. \\ 输出一个\ (“\”用来输出语法相关的字符,一一对应，如\\\\会输出\\)
4. \" 输出一个" , \' 输出一个'
5. \r 回车，若不换行会覆盖前面的字符
*/

class Test{
	public static void main(String[] args){
		System.out.println("书名\t作者\t价格\t销量\n三国\t罗贯中\t111\t222");
	}
}


/*
#注释方法#
1.行注释使用 //, 多行注释,注释方法同C++
2.文档注释
3.生成对应文档注释代码：javadoc -d 文档路径 -aa -bb 源文件名
如 javadoc -d D:\项目\JavaStudy\doc -author -version Hellow.java
aa bb如下：
・@author：作者。
・@version：版本。
・@docroot：表示产生文档的根路径。
・@deprecated：不推荐使用的方法。
・@param：方法的参数类型。
・@return：方法的返回类型。
・@see：用于指定参考的内容。
・@exception：抛出的异常。
・@throws：抛出的异常，和exception同义
*/ 

/**
 * @author 小明
 * @version 1.0
 */

class Test1{
	public static void main(String[] args){
		System.out.println("Hello,world");
	}
}  

/*
相对路径：从当前目录开始定位，形成一个路径
绝对路径：从最高级目录开始定位，形成一个路径
\ 下一级目录
..\ 上一级目录

#常用dos指令#
盘符切换 E:
查看当前目录下所有的文件 dir
进入同级的其他目录 cd  videos
进入不同级的其他目录 cd /d music
返回上一级 cd ..
创建文件夹 md test
删除文件夹 rd test
创建文件 cd>test.txt
删除文件 del test.txt
清楚屏幕 cls
退出终端 exit
查看电脑ip地址 ipconfig
获取网站的ip地址 ping www.baidu.com
打开计算器 calc
打开画图工具 mspaint
打开记事本 notepad
*/

基础数据类型

/*
#Java基本数据类型#
1.整数型 byte(1字节), short(2字节), int(4字节), long(8字节)
2.浮点型 float(4字节), double(8字节)
3.字符型 char(2字节)
4.布尔型 boolean(1字节), true或false
5.1字节为2的8次方,第一位为符号位,剩余位表数的大小

#使用规范#
1.低字节可以变高字节，但高字节变低字节会损失精度，整数可变小数，小数不能变整数
2.强制类型转换：（数据类型）被转换数据, 会造成精度降低或溢出
3.浮点型默认为double，若声明float，要在常量后加 f或F
4.在浮点型涉及到除法运算时，结果为小数时，他是一个无限接近该值得小数
  就算可以除尽，结果后也有很多位
5.对于字符型，每个字符都有对应的ASC11码，可以通过强制类型转换互换,
  并且可以和整数相互运算Unicode码可以表示汉字，且包含ASC11码
6.boolean使用同C++，但不可以使用01表示true false
7.有多种类型数据混合计算时,系统自动把所有数据转换容量大的数据类型再进行计算
  转换规则：char->int->long->float->double; (向后可以自动转换，向前则必须强转)
  		   byte,short不能和char相互转换，相互运算时同意变成int
           byte->short->int->long->float->double
8.所有数据类型加上空字符串都会变为String类型, String转一般数据类型通过 .parse 方法

#Java引用数据类型#
类 接口 数组
*/

class Test{
	public static void main(String[] args){
		float a1 = 1.1f;
		double a2 = 2.2;
		double a3 = 1.5f;
	//  科学计数法 e5 为10的5次方, e-5 为10的-5次方,e E 都可以
		System.out.println(5.12e2);
		System.out.println(5.12E-2);
	//  涉及浮点数的除法
		double b1 = 2.7;
		double b2 = 8.1 / 3; //2.69999999
		System.out.println("b1="+b1);
		System.out.println("b2="+b2);
	//  字符与其ASC11码
		char c1 = 99;
		char c2 = 'b';
		char c3 = '海';
		System.out.println("99对应字符为：" + c1); // c
		System.out.println("b对应数字为：" + (int)c2);  // 98
		System.out.println("海对应数字为：" + (int)c3); // 28023(Unicode编码)
		System.out.println("b+2对应的ASC码为：" + ('b'+2));  // 100
		System.out.println("b+2对应的字符为：" + (char)('b'+2)); // d
	//  不同数据类型相互运算
		int n1 = 10;
		double ans1 = n1 + 1.23;  // 都变成double
		System.out.println("10 + 1.23=" + ans1); 
		byte n2 = 1;
		short n3 = 5;
		char n4 = 'a';
		int ans2 = n2 + n3 +n4;  // 全部转为整数进行运算
		System.out.println("1 + 5 + \'a\'=" + ans2);
	//  强制类型转换
		int ans3 = (int)(1.1 + 2.2 + 3.3); // ans3 = 7
		System.out.println(ans3);
	//  String相关类型转换
		int d1 = 10;
		double d2 = 1.123456;
		// 其他->String
		String s1 = d1 + ""; 
		String s2 = d2 + "";
		System.out.println(s1);
		// String->其他
		String s3 = "12345";
		int k1 = Integer.parseInt(s3); 
		double k2 = Double.parseDouble(s3);
		boolean k3 = Boolean.parseBoolean("true");
		char k4 = charAt(0); // k4 = '1'
		System.out.println(k1);
 	}
}

/*
#+号的使用#
1.若两边是数值型，则作加法运算
2.若两边有一边是字符串，则作拼接运算
*/

运算符

算术运算符

关系运算符

逻辑运算符

运算符优先级

// 运算符
/*

#注意事项#
1.i++和++i单独使用是都等于 i=i+1, 但++i是先自增再取值, i++是先取值在自增
2.关系运算符使用同C++, <、>、<=、>=、!=、==
3.逻辑运算符： 
	短路："&& || !"="与,或,非"(若前半部分已经确定结果，则不会进行后半部分的判断);
	逻辑：单字符 & |; 结果与上面相同，但无论是否确定结果都会判断后半部分
  	^ =异或(相同false,不同true)
4.赋值运算符：
	+=, -=, *=, /=, %=
5.三元运算符：
	条件表达式?表达式1:表达式2, 若条件为true执行表达式1, false执行表达式2
6.标识符(变量名):
	不能用数字开头，不能使用关键字，不能包含空格

*/

import java.util.Scanner;
public class Test{
	public static void main(String[] args){
		System.out.println(10.2 / 4); // 2.25
		System.out.println(8.1 / 3);  // 2.6999999997
	//  i++ 和 ++i
		int a1 = 10;
		int a2 = 10;
		System.out.println("1++=" + a1++);  // 输出10
		System.out.println("++1=" + ++a2);  // 输出11
	//  || 和 | 的区别
		int b1 = 5;
		int b2 = 5;
		if(b1 == 6 && b2++ == 5){ // 不执行b2++
		}
		System.out.println("b2=" + b2);  // b2=5
		if(b1 == 6 & b2++ == 5){  // 执行b2++
		}
		System.out.println("b2=" + b2);  // b2=6
	//  三元运算符
		int c1 = 3;
		int c2 = 8;
		int c3 = c1 > c2 ? c1 : c2;
		System.out.println("c3=" + c3);
	//  接收键盘输入
	/*
		1.导入java.util.Scanner
		2.创建Scanner对象
		3.使用创建的对象调用 .nextInt()
	*/
		Scanner myScanner = new Scanner(System.in);
		System.out.println("请输入名字：");
		String name = myScanner.next();
		System.out.println("请输入年龄：");
		int age = myScanner.nextInt();
		System.out.println("请输入工资：");
		Double sal = myScanner.nextDouble();
		System.out.println("信息为：姓名 " + name 
			+ " 年龄 " + age +" 工资 " + sal);
	}
}

程序控制语句

// 顺序控制(同C++)
/*
1.双分支 if, else
2.多分支 if, else if, else (可以没有else)
3.switch(参数){case 常量: case语句;break; 
    最后 default:语句;break;}(参数等于常量就执行该case语句,case全不行执行default)
    case穿透: 若case后没有break,则执行完本case语句后会直接去执行下一个case语句,直到break或default
	参数和常量应类型相同，或者可以自动转化的数据类型(不能为小数)
4.for循环:
	for(循环变量初始化; 循环条件; 循环变量迭代){ 循环语句 }
5.while循环:
	while(循环条件) { 循环体 }
	do{ 循环体 }while(循环条件);   先执行在判断
6.break 结束所在的循环, continue: 结束本次循环, return: 结束方法，跳出程序
*/


import java.util.Scanner;
public class Test{
	public static void main(String[] args){
		// 多分支语句(if else)
		Scanner myScanner = new Scanner(System.in);
		System.out.println("请选择老婆(1.神里绫华,2.长野原宵宫,3.没得选):");
		int wife = myScanner.nextInt();
		if(wife == 1){
			System.out.println("MyWife:刀剑报业,明工怀宝");
		}
		else if(wife == 2){
			System.out.println("MyWife:烟花易逝,人情长存");
		}
		else{
			System.out.println("爷:没得选择,皆为吾翼");
		}
		// 多分支语句(switch)
		System.out.println("请输入1~4一个数字:");
		int a = myScanner.nextInt();
		switch(a){
			case 1:
				System.out.println("输入的是一");
				break;
			case 2:
				System.out.println("输入的是二");
				break;
			case 3:
			case 4: // 使用穿透原则可以让多个语句相同的case执行同一条语句
				System.out.println("输入的是三或四");
				break;
			default:
				System.out.println("输入错误");
		}
		// for循环练习 99乘法表
		for(int i = 1; i <= 9; i++){
			for(int j = 1; j <= i; j++){
				System.out.print(i + "*" + j + "=" + i*j + "\t");
			}
			System.out.println();
		}
	}
}

数组

// 数组

/*
#数组使用#
1.静态初始化: int A[]={ 数据元素 };
2.动态初始化: int A[]=new int[110];  或者int A[]; A=new int[110];
3.二维数组：又多个一维数组构成, 每个一维数组长度可相同可不同
	静态初始化: int B[][] = {{}, {}, {}};
	动态初始化: int B[][] = new int[10][10]; 或者int B[][]; B=new int[10][10];
	在列数不确定时: int B[][] = new int[10][] 
	B.length 为数组的行数, B[i].length 为第i行的长度

#注意事项#
1.数组下标从0开始
2.数组创建后不赋值默认为0, boolean默认false
3.数组赋值为引用传递, 传的是地址, 改变一个两个都会改变
*/

public class Test{
	public static void main(String[] args){
		// 计算母鸡的平均体重
		double kun[] = {3.5, 2.3, 1.1, 5.6, 2.5};
		double kunsum = 0.0;
		for(int i = 0; i < kun.length; i++){
			kunsum += kun[i];
		}
		System.out.println("kunkun的平均体重为:" + kunsum/kun.length);

		// 引用传递
		int A1[] = {1, 2, 3};
		int A2[] = A1;
		A1[0] = 10;  // 改变A1值得同时, A2也发生改变
		for(int i = 0; i < 3; i++){
			System.out.print(A2[i] + " ");
		}
		System.out.println();

		// 列数改变的二维数组   {{1}, {1,2}, {1,2,3}}
		int B[][] = new int[3][]; // 先只开辟行空间, 此时每行都为null
		for(int i = 0; i < B.length; i++){
			B[i] = new int[i + 1];  // 在为每行开辟空间
			for(int j = 0; j < B[i].length; j++){
				B[i][j] = i+1;
			}
		}
		for(int i = 0; i < B.length; i++){
			for(int j = 0; j < B[i].length; j++){
				System.out.print(B[i][j] + " ");
			}
			System.out.println();
		}

		//
	}
}