java基本语法
一、注释
注释：解释说明，代码块
注释jvm不会进行解释
在java中注释共有3中方式：
①单行注释 //
②多行注释 /…/
③ 文档型注释（java独有 javadoc） /** */
/*
sfsdfsfsdf
sdfsdfsdf
sdfsdfsdfsfd
*/
public class HelloWorld{ //aasads
/*
这个一个main方法
main方法代表程序的入口
我们main称为主方法，入口方法，主函数，入口函数
*/
public static void main(String[] args){
//系统输出打印
//System.out.println("中国");
/*System.out.println("美国");
System.out.println("德国");
System.out.println("美国");
System.out.println("德国");
System.out.println("美国");*/
System.out.println("德国"); //lskdfslkdfjs
}
}
二、标识符
什么是标识符？
凡是可以自己起名字的地方，都叫标识符(类名、变量名、方法名)
规则
① a-z A-Z 0-9 $ _ 组成
②不能以数字开头
③不能使用关键字，但可以包含
④长度无限制，但不能有空格
⑤严格区分大小写
规范
类名：多单词组成时，首字母大写
变量名和方法名：多单词组成时，首字母小写，从第二个单词开始首字母大写
包名：全小写用.分割
常量名：全大写多单词组成时，用_ 连接 PAGE_SIZE
public class Demo{
public void mehtod(){}
public void getAge(){}
public void liuYing(){}
public static void main(String[] args){
int age = 10;
int AageB90$_ = 20;
int a_public = 20;
int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa = 10;
int Age = 10;
}
}
三、变量
内存中的一块存储区域
该区域有自己的类型和名称
声明变量公式：数据类型 变量名 = 初始值;
变量必须声明在{}中
先声明(在内存中开辟空间)后使用（从内存中获取变量值）
从位置上划分：在类的内部，方法的外部定义的变量叫成员变量。在方法的内部定义的变量叫局部变量
public class abc{
int b = 10;//成员变量
public static void main(String[] args){
System.out.println("abc");
int a = 10;//声明 局部变量
a = 20;//使用
System.out.println(a);//使用
//System.out.println(b);
}
}
//int c = 10;
数据类型
基本数据类型
数值型
整数型 byte short int long
浮点型 float double
字符型 char
布尔型 boolean
引用数据类型
类(String)、接口、数组
基本数据类型与引用数据类型的区别？
基本数据类型把值存储在栈内存中，引用数据类型把值存储在堆内存中，栈内存是指向堆内存的地址（栈内存是堆内存的引用）
public class Demo1{
public static void main(String[] args){
byte a = 10;
short b = 20;
int c = 30;
long d = 40;
float e = 10.1f;//必须加f或F
double f = 10.1;
//可以存储一个字母或一个数字或一个汉字
char m1 = 'a';
char m2 = '1';
char m3 = '在';
boolean b1 = true;
boolean b2 = false;
String str = "abcdefg";//字符串
System.out.println(a);
System.out.println(b);
System.out.println(c);
System.out.println(d);
System.out.println(e);
System.out.println(f);
System.out.println(m1);
System.out.println(m2);
System.out.println(m3);
System.out.println(b1);
System.out.println(b2);
System.out.println(str);
}
}
3.1整数类型
public class Demo1{
public static void main(String[] args){
//在java程序中出现的整数常量默认类型就是int
//变量赋值时一定类型匹配时才能正确赋值
byte a = -128;//常量---不可变 也有自己的类型 int byte赋值时，有一个隐式转换过程
short b = 20;//-32768~32767
int c = 30;//****************** -2147483648~2147483647
long d = 40L;//加一个l或L，区分40是int类型还是long类型
//类型匹配时，才能赋值正确
//c = 10.1;//int double
}
}
3.2 浮点类型
public class Demo2{
public static void main(String[] args)
{
float a = 10.1f;//f或F 来声明当前10.1位float类型
double b = 10.1; /***** 在当前程序中出现的小数默认类型就是double
}
}
3.3 字符类型和布尔类型
char a = 's';//单引号是字符类型，字符类型可以存储一个中文（Unicode） utf-8
boolean g = true;//不能使用0或1代替，使用范围非常广泛。分支，循环都需要boolean 方法
boolean h = false;
3.4 数据类型的转换
自动的过程
小的数据类型和大的数据类型计算时，小的数据类型会自动的转换成大的数据类型，然后在计算
byte short char 特殊，在计算时，首先会转换成int，然后在计算 char（ASCII码）
强制
大的数据类型变成小的数据类型，需要强制转换
(数据类型)变量|值
public class Demo3{
public static void main(String[] args){
byte u = 10;
short k = 100;
int a = 10;
char p = 'a';//97
long h = 100L;
double b = 20.2;
// 当变量间进行计算时，类型也必须要匹配
//自动类型转换---小的数据类型和大的数据类型计算时，小的数据类型自动转换成大的数据类型然后在计算
double c = a + b;//int + double ---> double + double = double
System.out.println(c);
long m = a +h;//long + int---> long + long = long;
System.out.println(m);
int s = u + a;//byte + int ---> int + int = int
System.out.println(s);
int j = u + 10;//byte + int ---> int + int = int
System.out.println(j);
//byte short char 在进行计算时，首先会转换成int然后在计算 隐式
int t = u + u;//byte + byte ---> int + int = int
System.out.println(t);
int y = u + k ;// byte + short -->int + int = int
System.out.println(y);
int z = p + 10;//char + int ---> int + int = int
System.out.println(z);
//大的数据类型变成小的数据类型需要强制转换
//强制转换可能会造成精度降低或溢出
byte n = (byte)(u + u);// byte +byte --> int + int = (byte)int
System.out.println(n);
int q = (int)b;
System.out.println(q);
System.out.println((char)97);
}
}
3.5 字符串计算
字符串只有一种计算方式+
字符串+数据类型=字符串 “abc”+10+10.2=abc10
数据类型+字符串=字符串 10+“10”=1010
四、运算符
4.1 算术运算符
+正号
-负号
±*/ %(取模|取余)
++ –
public class Demo4{
public static void main(String[] args){
int a = 10;
int b = -a;
System.out.println("b="+b);
b = (a + 100 + 89 - 89 - 67) * 200;
System.out.println("b="+b);
//整数除只保留整数，而舍弃小数
System.out.println(a / 3);// int / int = int
System.out.println(10.0 / 3);// double / int ---> double / double = double
//对负数取模，负号忽略
//被除数是负数，负号保留
System.out.println(-a % 4);// int % int = int
//++ 自身加1 自增
//++ 在前，先计算后赋值
//++ 在后，先赋值后计算
b = a++;// a=a+1 ; b = a b = a ; a = a + 1
System.out.println(b);
System.out.println(a);
//-- 自身减1 自减
//-- 在前，先计算后赋值
//-- 在后，先赋值后计算
b = a--;
System.out.println(b);
System.out.println(a);
}
}
4.2 赋值运算符
先计算=后边，然后把值付给左边
=
+=、=+、*= 、/=、%=
public class Demo5{
public static void main(String[] args){
int a = 10;
a += 10;//a = int(a + 10);
a -= 10;//a = int(a - 10);
a *= 10;//a = int(a * 10);
byte b = 10;
b += 10;//b = (byte)(b + 10);
//b = b + 10;
System.out.println(b);
}
}
4.3 比较运算符
结果都是boolean值，要么true要么false
== 比较左边和右边是否相等,如果相等返回true，否则返回false
!= 比较左边和右边是否不等，不等返回true，相等返回false
< > >= <=
instanceof 面向对象时在讲
public class Demo6{
public static void main(String[] args){
int a = 97;
int b = 10;
char m1 = 'a';
char m2 = 'a';
boolean c = a == 'a';//int == char --> int == int
c = m1 != m2;
System.out.println(c);
System.out.println(a != b);
}
}
4.4 逻辑运算符
结果都是boolean值，要么true要么false
逻辑运算符可以连接多个布尔表达式
与运算，两边都是true时结果为true，其他情况结果为false
&&（双与 and）如果左边为false，直接返回结果false，右边不参与计算
&（单与 and）两边都计算，然后返回结果
或运算，两边都是false时，结果为false，其他情况结果为true
||（双或 or）左边为true直接返回结果true，右边不参与计算
|（单或 or）两边都计算，然后返回结果
!(布尔表达式) 非 取反 !true=false !false=true
^(异或) 相同为false，不同为true
public class Demo7{
public static void main(String[] args){
int a = 10;
boolean c = 10 > 9 & 10 < 20 & a <= 100;//true && true && true = true
System.out.println(c);
System.out.println(10 == a & a > 20);//true && false = false
System.out.println(a < 1 & a == 10);//false && true = false
System.out.println(false & false);//false && false= false
System.out.println(10 == a || a > 20);//true || false = true
System.out.println(a < 1 || a == 10);//false || true = true
System.out.println(false || false);//false || false= false
System.out.println(true || true);//true || true= true
System.out.println(true ^ true);
System.out.println(true ^ false);
System.out.println(false ^ true);
System.out.println(false ^ false);
}
}
4.5 三元运算符（三目运算符）
(布尔表达式)？表达式1：表达式2
public class Demo8{
public static void main(String[] args){
int a = (10 < 9)?100:200;//if(){}else{}
System.out.println(a);
}
}
五、分支语句
有选择的执行代码
5.1 if(布尔表达式){语句…} [else{语句…}]
if–如果
else–否则
if(){}
if(){}else{}
if(){}else if(){}else if(){}…[else{}]
int a = 18;
if(a == 7){
System.out.println("七");
}else if(a == 8){
System.out.println("八");
}else if(a == 9){
System.out.println("九");
}else if(a == 10){
System.out.println("十");
}else{
System.out.println("other");
}
System.out.println();
import java.util.Scanner;
public class Demo4
{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
int score = sc.nextInt();//int score = 989796
if(score == 100){
System.out.println("BMW");
}else if(score > 80 && score <= 99){
System.out.println("iphone");
}else if(score >= 60 && score <= 80){
System.out.println("book");
}
int num1 = sc.nextInt();
int num2 = sc.nextInt();
int num3 = sc.nextInt();
if(num1 > num2 && num2 > num3){
System.out.println(num3+","+num2+","+num1);
}else if(num2 > num1 && num1 > num3){
System.out.println(num3+","+num1+","+num1);
}
int h = 181;
int m = 10000001;
char s = 'p';//帅 p 不帅 q
if(h > 180 && m >= 10000000 && s == 'p'){
System.out.println("我一定要嫁给他!!");
}else if(h > 180 || m >= 10000000 || s == 'p'){
System.out.println("嫁吧，比上不足，比下有余");
}else{
System.out.println("不嫁！");
}
}
}
5.2 switch
switch(变量){
case 常量:
语句…
[break;] 当case为true时，执行语句，执行完后如果没有break将继续向下执行语句，此时与case无关
}
变量都可以是什么类型？
int byte short char String enum
public static void main(String[] args){
char a = 'e';
switch(a){
case 'a':
case 'b':
case 'c':
case 'd':
case 'e':
System.out.println((char)(a-32));
break;
default:
System.out.println("other");
break;
}
}
int score = 98;
switch(score/60){
case 0:
System.out.println("不合格");
break;
case 1:
System.out.println("合格");
break;
}
六、循环
重复（反复）执行某块代码
6.1 for
for(表达式1；表达式2；表达式3){语句4}
执行顺序1、表达式1 2、表达式2是否true如果true执行{语句} 3、表达式3 243 243 243
//循环开始的位置 表达式1 局部变量
//布尔表达式 表达式2 循环结束的位置
// 执行大括号中的语句
// 计算器 表达式3
// 表达式2
for(int i = 1; i <= 1000; i++){
//要循环执行的业务
System.out.println("hello world!!");
}
//1-100 200-300
for(int i = 1; i <= 100; i++){
System.out.println(i);
}
//求 1+2+3+4+5...+100=?
// 1+2=3 3+3=6 6+4=10 10+5=15 15+6=21
int sum = 1;
for(int i = 2; i <= 100; i++){
sum += i;//sum = sum + i;
}
System.out.println(sum);
//求1~100偶数之和
sum = 0;
for(int i = 0; i <= 100; i+=2){
/*if(i % 2 == 0){
sum += i;
}*/
sum += i;
}
// 打印 100~1
for(int i = 100; i >= 1; i--){
System.out.println(i);
}
System.out.println(sum);
//求1~100 7的倍数之和，和个数
int count = 0;
sum = 0;
for(int i = 0; i <= 100; i+=7){
sum += i;
count++;
}
System.out.println(count);
System.out.println(sum);
for(int i = 1; i <= 150; i++){
System.out.print(i);
if(i % 3 == 0){
System.out.print(" foo");
}
if(i % 5 == 0){
System.out.print(" biz");
}
if(i % 7 == 0){
System.out.print(" baz");
}
System.out.println();
}
for(int i = 100; i <= 999; i++){
int a = i / 100;
int b = i / 10 % 10;
int c = i % 10;
if(a*a*a + b*b*b + c*c*c == i){
System.out.println(i);
}
}
6.2 while
while（布尔表达式）{语句}
//while(布尔表达式){}
int i = 0;
while(i < 10){
System.out.println("hello");
i++;
}
i = 1;
while(i <= 100){
System.out.println(i);
i++;
}
int sum = 0;
i = 1;
while(i <= 100){
sum += i;
i++;
}
System.out.println(sum);
while（a > 10 && a < 20){
System.out.println();
}
6.3 do while
do{语句}while(布尔表达式);
//最少会执行一次
//先执行do中的语句，然后在判断条件是否正确
int i = 1;
do{
System.out.println("hello");
i++;
}while(i > 10);//i == 2
6.4 break
break只能出现在两个地方，一、switch 二、循环
break之后不能有任何语句,永远不会被执行到结束当前循环
for(int i = 1; i < 100; i++){
if(i == 10){
System.out.println("over");
break;//结束循环
//break只能出现在两个地方，一、switch 二、循环
//break之后不能有任何语句,永远不会被执行到
}
System.out.println("i="+i);
}
6.5 continue
//cointinue之后不能有任何语句
//continue只能出现在循环中
for(int i = 1; i < 50; i++){
if(i == 10){
System.out.println("over");
continue;//跳过这次循环 结束这次循环
//cointinue之后不能有任何语句
//continue只能出现在循环中
//break结束循环
//break只能出现在两个地方，一、switch 二、循环
//break之后不能有任何语句,永远不会被执行到
}
System.out.println("i="+i);
}
6.6 死循环（无限循环）
while(true){
System.out.println(123);
}
for(;;){
System.out.println(123);
}
do{}while(true);
6.7 嵌套循环
找到内层循环和外层循环的规律
//99乘法表
/*
1*1=1
2*1=2 2*2=4
3*1=3 3*2=6 3*3=6
4*1=4 4*2=8 4*3=12 4*4=16
5*1=5 5*2=10 5*3=15 5*4=20 5*5=25
*/
for(int i = 1; i <= 9; i++){
for(int j = 1;j <= i; j++){
System.out.print(i+"*"+j+"="+i*j+" ");
}
System.out.println();
}
//100—200之间的所有质数
//除了1和它本身不能被其他自然数整除的数叫素数
// 107 107/2 107/3 107/4.....107/106 素数
//108 108/2 不是素数
//外层循环100-200
for(int i = 100; i <= 200; i++){
//每一个数判断是否是素数
//从2开始做除法，只能这个数-1
boolean a = true;
for(int j = 2; j < i; j++){
//判断是否能被j整除
if(i % j == 0){
a = false;
break;
}
}
if(a){
System.out.println(i);
}
}
for(int i = 1; i <= 6; i++){
for(int j = 1; j <= i; j++){
System.out.print("#");
}
System.out.println();
}
for(int i = 1; i <= 7; i++){
if (i % 2 != 0)
{
for(int j = 1; j <= i; j++){
System.out.print("*");
}
System.out.println();
}
}
for(int i = 5; i >= 1; i--){
if(i % 2 != 0){
for(int j = i; j >= 1; j--){
System.out.print("*");
}
System.out.println();
}
}
for(int i = 1; i <= 5; i++){
for(int k = 4; k >= i; k--){
System.out.print(" ");
}
for(int j = 1; j <= i; j++){
if(j == 1 || j == i){
System.out.print("* ");
}else{
System.out.print(" ");
}
}
System.out.println();
}
for(int i = 4; i >= 1; i--){
for(int k = 1; k <= 5-i; k++){
System.out.print(" ");
}
for(int j = 1; j <= i; j++){
if(j == 1 || j == i){
System.out.print("* ");
}else{
System.out.print(" ");
}
}
System.out.println();
}
七、数组（引用数据类型）
一维数组
什么是数组？
多个相同数据类型数据的一个集合，实现对这些数据的统一管理
7.1数组动态初始化
公式：数据类型[] 变量名 = new 数据类型[长度]; 数据的动态初始化 数组长度不能发生变化
int[] scores = new int[5];
//下标可以是一个整数，也可以是一个整数表达式(在长度范围内)
scores[0] = 90;//赋值 数组的下标赋值 数组[下标] 数组[索引]
scores[1] = 91;
scores[2] = 92;
scores[3] = 93;
scores[4] = 94;
// scores[5] = 95;
System.out.println(scores[0]);//取值，数组的下标取值
System.out.println(scores[1]);
System.out.println(scores);
String str1 = "a";
String str2 = "b";
String str3 = "c";
String str4 = "d";
String str5 = "e";
String[] strs = new String[5];
strs[0] = "a";
strs[1] = "b";
strs[2] = "c";
System.out.println(strs[0]);
System.out.println(strs[1]);
System.out.println(strs[3]);//可以取得没有赋值的单元格
double[] dous = new double[3];
System.out.println(dous[1]);
boolean[] booles = new boolean[2];
booles[0] = true;
System.out.println(booles);
System.out.println(booles[1]);
char[] chars = new char[3];
System.out.println("----"+chars[0]+"----");
//数组有默认值
// byte short int long = 0
// float double = 0.0
// boolean = false
// char = 空 空格
// 所有的引用数据类型的数组 null
//循环操作数组，需要一个属性length 获取数组的长度
//数组名.length
System.out.println(chars.length);
System.out.println(booles.length);
for(int i = 0; i < chars.length; i++) {
System.out.println("====:"+chars[i]+"-----");
}
for(int i = 0; i < scores.length; i++) {
System.out.println(scores[i]);
}
//数组最大的意义是操作数据
int sum = 0;
int max = -1;
int min = Integer.MAX_VALUE;
for(int i = 0; i < scores.length; i++) {
sum += scores[i];
if(scores[i] > max) {
max = scores[i];
}
if(scores[i] < min) {
min = scores[i];
}
}
System.out.println("sum="+sum);
System.out.println(sum / scores.length);
System.out.println(max);
System.out.println(min);
7.2数组的静态初始化
公式：数据类型[] 变量名 = new 数据类型[]{赋值…};
//数组的静态初始化
//声明方式不一致，使用方式一致
//公式：数据类型[] 变量名 = new 数据类型[]{赋值........};
int a[] = new int[] {1,2,3,4,5};
System.out.println(a);
//静态初始化，简写形式
int[] b = {10,20,30};
System.out.println(b[0]);
System.out.println(b.length);
String[] ss = {"aa","bb","cc"};
System.out.println(ss[1]);
String g = "";
for(int i = 0; i < ss.length; i++) {
g = g + ss[i];
}
System.out.println(g);
//冒泡排序
for(int i = 0; i < a.length; i++) {
for(int j = 0; j < a.length - i - 1; j++) {
if(a[j+1] > a[j]) {
int temp = a[j];
a[j] = a[j+1];
a[j+1] = temp;
}
}
}
System.out.println();
for(int i = 0; i < a.length; i++) {
System.out.print(a[i]+",");
}
System.out.println();
for(int i = b.length-1; i >= 0; i--) {
System.out.println(b[i]);
}
7.3 数组默认值
byte short int long 0
float double 0.0
char 空格
boolean false
引用数据类型 null
7.4 引用数据类型数组
//数据类型【】 变量名 = new 数据类型【长度】
//引用数据类型的数据比基本数据类型的数据多了一个引用
MyDate[] myDates = new MyDate[3];
myDates[0] = new MyDate(1999,12,12);
System.out.println(myDates);
myDates[1] = new MyDate(2020,11,11);
myDates[2] = new MyDate(2021,10,10);
System.out.println(myDates[0]);
// int a = score[1];
MyDate m1 = myDates[0];
System.out.println(m1.year);
System.out.println(m1.month);
System.out.println(m1.day);
MyDate m2= myDates[1];
System.out.println(m2.year);
System.out.println(m2.month);
System.out.println(m2.day);
7.5 二维数组
数组的数组称为二维数组
二维数组也有默认值。
7.5.1 动态初始化
公式：数据类型【】【】 变量名 = new 数据类型【长度】【长度】；
//规则的表格
int[][] a = new int[5][5];
a[0][0] = 10;
a[2][3] = 20;
a[3][1] = 30;
a[4][4] = 100;
System.out.println(a[0][0]);
System.out.println(a[4][4]);
//length
System.out.println(a.length);
System.out.println(a[0].length);
for(int i = 0; i < a.length; i++) {
for(int j = 0; j < a[i].length; j++) {
System.out.print(a[i][j]+",");
}
System.out.println();
}
//声明一个不规则的表格(每一行的列数不相等)
//但必须指定行数，列数可以后指定
int[][] b = new int[3][];
b[0] = new int[2];
b[0][0] = 10;
b[1] = new int[5];
b[1][4] = 20;
System.out.println(b[0][0]);
System.out.println(b[1][4]);
System.out.println(b[2]);
7.5.2 静态初始化
公式：数据类型【】【】 变量名 = new 数据类型【】【】{{数据。。}，{数据。。}}；
//静态初始化
String[][] strs = {{"a","b"},{"111","222","333"}};
for(int i = 0; i < strs.length; i++) {
for(int j = 0; j < strs[i].length; j++) {
System.out.print(strs[i][j]+",");
}
System.out.println();
}
二维数组引用数据类型
//引用数据类型的二维数组
MyDate[][] ms = new MyDate[3][1];
ms[0][0] = new MyDate(1999,10,10);
System.out.println(ms);
System.out.println(ms[0]);
System.out.println(ms[0][0]);
//引用数据类型的二维数组
MyDate[][] ms = new MyDate[3][1];
ms[0][0] = new MyDate(1999,10,10);
System.out.println(ms);
System.out.println(ms[0]);
System.out.println(ms[0][0]);
int[] p = {1,2,3,4,5};
int[] p1 = p;
p1[2] = 100;
System.out.println(p[2]);