Java语法合集，适合小白，本人手码不易，有错误麻烦指出

于 2022-09-06 14:55:43 发布
阅读量114 收藏
点赞数 1
文章标签： java jvm 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_62201130/article/details/126725288
版权

java语法合集

注释

  • 单行注释
//两个斜杠为单行注释
  • 多行注释
/* 斜杠加星为多行注释 */
  • 文档注释
/**
这个为文档注释
*/

标识符

  • 所有标识符都应该以字母，美元符号($)，下划线(_)开始
  • 首字母之后可以加上数字等任何字符组合
  • 不能使用关键字作业变量名或方法名
  • 标识符是大小写敏感
  • 可以用中文命名，但不建议

变量

基本数据类型
//整数
int num1=10;  //常用
byte num2=20;
short num3=30;
long num4=40L;  //Long类型要在数字后面加L

/*整数拓展
进制：
二进制0b
八进制0
十六进制0x  在使用时直接加在数字前面
int i1=10;  十进制
int i2=010;  八进制
int i3=0x10;  十六进制

*/

//浮点型
float num5=50.1F;  //folat类型要在数字后面加F
double num6=3.1415926;

/*浮点数拓展
float s1=0.1f;
double s2=0.1;
s1不等于s2
最好不要用浮点数来比较，因为浮点数表示数值有限的数，而且他数字是离散的，它存在舍入误差，接近但不等于；
所以如果银行使用数学工具类BigDecimal定义
*/

//字符
char name1='A';
string name2="css";
System.out.println((int)name1);  //强制转换成数字

/*字符拓展
可以将字符甚至中文强制转换成数字
因为所有字符本质还是数字
因为存在Unicode编码问题，其中甚至包括中文字符，Unicode占用两个字节；   

转义字符
制表符(tab)：/t
换行：/n
...
*/


//布尔型
boolean flag=true;
//boolean flag=false;

/*
布尔值拓展


*/

类型转换

  • 强制类型转换 从高类型到低类型
  • 自动类型转换 从低类型到高类型

强制类型转换：

int i=128;
byte b=(byte)i;    //内存溢出，结果会出现未知值

自动类型转换

int i=128;
double a=(double)i;     //输出128.0

类型转换注意事项：

  • 不能对布尔值进行转换
  • 不能把对象类型转换成不相干的类型
  • 转换的时候可能存在内存溢出，或者精度问题(常见的就是float转换int时舍弃小数点后面的小数)

变量

类变量：和实例变量一样，写在main外,

public class demo {
    int age;
    String name;
    static double cate =525;	//类变量前面要写static
    public static void main(String[] args) {
       demo DEMO = new demo();	//使用类变量不需要写new demo();
        System.out.println(DEMO.name);
        System.out.println(DEMO.age);
        System.out.println(cate);   
    }
}

局部变量：作用域在main方法中

实例变量：作用域在类里面，没写在main中，从属于类中，可以放到main中使用

public class demo {
    int age;
    String name;     //String第一个字母是大写
    public static void main(String[] args) {
       demo DEMO = new demo();		//实例变量必须写这句
        System.out.println(DEMO.name);
        System.out.println(DEMO.age);
    }
}

//如果实例变量未初始化，直接输出一般默认为0；
//布尔值：默认是false；
//除了基本类型，其余的默认值都是null；

常量

public class demo {
    static final double PI=55;      //用final定义常量，前面加static是为了让常量能够在main中使用
    								//但static和final无先后顺序,都是修饰符
    								//为了便于识别，常量一般用大写字母表示
    public static void main(String[] args) {
        System.out.println(PI);
        
    }
}

运算符

  • 算术运算符：“+”，“-”，“*”，“/”,“%”,“++”,“–”

  • 关系运算符：“>”，“<”,“>=”,“<=”,“==”,!=instanceof

  • 逻辑运算符：“&&”，“||”，“！”

  • 位运算符：“&”，“|”，“^”,“~”,“>>”,“<<”,“>>>”

  • 条件运算符：？：

  • 拓展赋值运算符：+=，-+，*=，/=

算数运算符和关系运算符：

package operator;

public class Day01 {
    public static void main(String[] args) {

        int a=10;   //快捷键按ctrl+d是复制到下一行；
        int b=20;
        int c=25;
        int d=25;
        
        System.out.println(a+b);
        System.out.println(a-b);
        System.out.println(a*b);                
        System.out.println(a/(double)b);  //必须得把一个转换成double,不然两个整型无法相除
                                         //两个不同类型数运算，结果数类型服从优先级高得类型
       

public class Day01 {
    public static void main(String[] args) {

        int a=10;   //快捷键按ctrl+d是复制到下一行；
        int b=a++;  //先把a的值赋值给b，在自身加加
        int c=++a;  //先自身加加，再将值赋给b+

        double d=Math.pow(2,3);		//幂运算，很多运算都会使用一些工具类来操作
        System.out.println(b);
        System.out.println(c);
        System.out.println(d);
    }
}

逻辑运算符和位运算符

package operator;

public class Day01 {
    public static void main(String[] args) {
        boolean a=true;
        boolean b=false;
        boolean d=a||b;
        System.out.println("a && b"+(a&&b));    //逻辑与运算，服从短路运算，前面为假的话后面不会在判断
        System.out.println("a || b"+(a||b));    //逻辑或运算，出现双引要加+号是为了输出后面的值。
        System.out.println("!(a && b)"+!(a&&b));//逻辑非运算
        System.out.println(d);

        /*
        A = 0011  1100
        B = 0000  1101
        
        A & B = 0000 1100   //与运算
        A | B = 0011 1101   //或运算
        A ^ B = 0011 0001   //异或 
        ~B = 1111 0010      //取反
        */
        
        
        
    }
}

package operator;

public class Day01 {
    public static void main(String[] args) {
        
        /*
        在底层算法很喜欢用位运算，因为位运算效率极高
        <<   左移一位相当于乘二
        >>   右移一位相当于除二
        */
        System.out.println(2<<3);   //结果16

    }
}

拓展运算符：含有面试题

package operator;

public class Day01 {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;    
        System.out.println(""+a+b);   //结果是1020，因为这里表示字符串连接符，后面没有括号，a和b拼接在一起变成字符串，如果要转换成整数要括号起来
        System.out.println(a+b+"");   //结果是30，因为这里是进行整数运算，没有转换成字符串
        a+=b;

    }
}


三元运算符：
    //x ? y :z
    //如果x==true,则结果为y，否则为z
    
    package operator;

public class Day01 {
    public static void main(String[] args) {

        int score = 50;
        String type = score <60 ?"不及格":"及格";
        System.out.println(type);
    }
}

包机制

  • 一般利用公司域名倒置作为包名
  • 为了能够使用某包里的成员，我们需要导入该包语法：
package operator;
import java.util.Date;  //使用import语句导入，从最外层文件夹往内层写，如果将Date改为*，则可以导入util里的所有包
public class Day01 {
    static Object Date;
    public static void main(String[] args) {
        Date
       
}

JAVADOS

参数信息：

@author 作者名
@version 版本号
@since 指明需要最早使用的jdk版本
@param 参数名
@return 返回值情况
@throws 异常抛出情况
    
    package Base;
public class Doc {
    String name;

    /**
     *
     * @param name
     * @return
     * @throws Exception
     */
    public String test(String name) throws Exception{     //敲这段代码可以自动生成上面的文档注释，并且这样生成的文档注          return name;                                     //释可以保存进api文档。
        

    }
}

使用命令行窗口生成api文档

进入要导出的java代码的文件夹的预命令窗口，敲下面那句：

javadoc -encoding UTF-8 -charset UTF-8 Doc.java //标黑的是要导出的文件，前面是标注格式

用户交互Scanner

通过scanner实现程序和人的交互

  • 基本语法：Scanner s = new Scanner(system.in);
  • 通过Scanner类的next()与nextLine()方法获取输入的字符串，在读取前我们一般会使用hasNext()与hasLine()判断是否还有输入的数据。

一些函数：

scanner.next() ，表示键盘输入字符串，以空格为结束符

scanner.nextLine(),记录键盘输入的字符串，以回车为结束符

scanner.nextDouble(),记录键盘输入的数字，以回车为结束符

scanner.hasNext(),判断有没有输入字符串

scanner.hasNextLine(),判断键盘有没有输入字符串

scanner.hasNextDouble(),判断键盘有没有输入数字

使用完io流类方法，结束后要关闭，scanner.close()

package scanner;

import java.util.Scanner;

public class Demo1 {
    public static void main(String[] args) {
        //创建一个扫描器对象，用于接收键盘的数据
        Scanner scanner = new Scanner(System.in);
        System.out.println("使用next方式接受");

        //判断用户有没有输入字符串
        if(scanner.hasNext()){
            //使用next方式接受
            String str=scanner.next();  //这段代码一旦执行，程序会等待用户输入，按完回车输出，next(）以空格为结束符，所以有空格后面
                                        //会直接省略0

            System.out.println("输入内容为："+str);

        }
        //凡是输入io流类函数用完一定要关了
        scanner.close();
    }
}

package scanner;

import java.util.Scanner;


public class Demo2 {
    public static void main(String[] args) {
        //从键盘接收数据
        Scanner scanner = new Scanner(System.in);
        System.out.println("使用nextLine方式接受：");
        if (scanner.hasNextLine()){    //判断键盘是否有输入
            String str = scanner.nextLine();    //nextLine()可以容许空格，以回车作为结束
            System.out.println("输出的内容："+str);
        }
        scanner.close();  //io流类用完关闭
    }
}


package scanner;


import java.util.Scanner;

public class Demo5 {
    //我们可以输入多个数字，并求其和与平均数，每输入一个数字用回车确定，通过输入非数字来结束输入并输出执行结果
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        //和
        double sum = 0;
        //计算输入多少数字
        int m = 0;

        //通过循环判断是否还有输入，并且在里面每一次求和统计

        while(scanner.hasNextDouble()){       //判断有没有数字输入
            double x =scanner.nextDouble();   //将键盘输入的数赋值给x
            //统计输入个数
            m = m+1;

            sum = sum+x;
            System.out.println("你输入了"+m+"个数，sum和是"+sum);

        }

        System.out.println(m+"个数和为"+sum);
        System.out.println(m+"个数的平均值是"+(sum/m));

        scanner.close();
    }
}

选择结构

//equals:判断字符串s和括号里字符串是否相等
if(s.equals(“Hello”))

  • if单选择结构

语法：

if(布尔表达式){

   //如果布尔表达式为ture将执行的语句；

}

       //equals:判断字符串s和括号里字符串是否相等
        if(s.equals("Hello")){
            
        }
  • if双选择结构
if(布尔表达式){
    //如果布尔值为真执行
}else{
    //如果布尔表达式为假执行
}

*******************************************

package struct;

import java.util.Scanner;

public class Demo3 {
    public static void main(String[] args) {
       Scanner scanner = new Scanner(System.in);

        System.out.println("请输入成绩：");
        int score = scanner.nextInt();
       if(score>60) {
           System.out.println("恭喜你及格!");
       }else{
           System.out.println("不及格！！！");
       }
       scanner.close();
    }
}
  • if多选择结构
if(布尔表达式1){
    //如果布尔表达式1为真执行
}else if(布尔表达式2){
    //如果布尔表达式2为真执行
}else if(布尔表达式3){
    //如果布尔表达式3为真执行
}else{
    //如果以上布尔表达式都不为真执行代码
}

/*
如果if语句中出现else if,则必须有else
*/
*************************************************************

package struct;

import java.util.Scanner;

public class Demo4 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        System.out.println("请输入成绩：");
        int score = scanner.nextInt();
        if (score == 100){
            System.out.println("恭喜满分！！！");
        }else if (90< score&& score<100){
            System.out.println("just soso");
        }else if (80< score && score < 90){
            System.out.println("小辣鸡");
        }else{
            System.out.println("回家种田吧！！！");
        }
        scanner.close();
    }
}
  • 嵌套的if结构
if(布尔表达式1){
    //如果布尔表达式1为真执行
    if(布尔表达式1){
    //如果布尔表达式1为真执行
	}
}
  • switch多选择结构
/*
判断switch与case变量是否相同，每个值称为一个分支，switch支持字符串类型
*/
switch(expression)
    case value:
		//语句
		break;
	case value:
		//语句
		break;
	case value:
		//语句
		break;
	default://可选是否要这句
	//语句


****************************************************

package struct;

import java.util.Scanner;

public class Demo5 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入成绩！！！");

        String grade = scanner.next();
        switch (grade){
            case "a":
                System.out.println("优秀");
                break;
            case "b":
                System.out.println("一般");
                break;
            case "c":
                System.out.println("别读了！！！");
                break;
            default:
                System.out.println("完蛋了！！！");

        }
        scanner.close();
    }


}

注：字符的本质还是数字，代码编译后成class文件（字节流文件），我们必须通过编译软件例idea来反编译才看得懂。

循环结构

while循环
while(布尔表达式){
    //循环结构
}
do while

do while和while相似，但是do while循环至少会执行一次

while先判断后执行，do while是先执行后判断

do {
    //代码段
}while(布尔表达式);

========================================

//输出一加到一百的和
package struct;

public class Dowhiledemo {
    public static void main(String[] args) {
        int i = 1;
        int j = 0;

        do{
            j=j+i;
            i=i+1;
        }while(i<=100);

        System.out.println(j);
    }


}
for循环

for循环执行的次数实在执行前就确定的

for(初始化；布尔表达式；更新){
    //代码语句；
}



===========================================
    
实现一道一百奇数和和偶数和    
    package struct;

public class fordemo1 {

    public static void main(String[] args) {

        int i = 0;
        int j = 1;
        int o = 0;
        int p = 0;
        for(;i<=100;i=i+2){
            o = o+i;
        }
        for(;j<=100;j=j+2){
            p=j+p;
        }
        System.out.println("一到一百奇数和为："+p);
        System.out.println("一到一百偶数和为："+o);
    }
}

===========================================
//输出一道一千之间能被五整除的数，并且每行输出三个
  
package struct;

public class fordemo2 {

    public static void main(String[] args) {
        int j=0;
        for(int i=0;i<=1000;i++){
            if(i%5==0){
                j++;
                System.out.print(i+" ");     //使用print输出结果不会换行
                if(j%3==0){                  //使用println输出每个结果都会换行   
                    System.out.print('\n');
                }
            }
        }

    }


}


==================================================================
    
//输出九九乘法表    
package struct;

public class fordemo3 {
    public static void main(String[] args) {

        int i = 1;
        int j = 1;

        for(;i<10;i++){
            for(;j<=i;j++) {
                System.out.print(j + "*" + i + "=" + i * j+" ");
            }
            System.out.println("");
            j=1;
        }
    }
}c

注：使用print每次输出结果不会换行，println输出结果会换行，所以要换行可以println(" ");

注：按100.for+回车即可生成：for(int i=0;i<100;i++)

增强型for循环

注主要用于数组和集合

语法：

for(声明语句：表达式){
    //代码句子
}
声明语句：声明新的局部变量，该变量的类型必须和数组元素的类型匹配，其作用域限定的循环语句块，其值与此时数组元素的值相等
表达式：表达式是要访问的数组名，或者是返回值为数组的方法
    
    
    
============================================
    package struct;

public class Fordemo05 {
    public static void main(String[] args) {
        int[] numbers = {10,20,30,40,50};    //定义数组
        
        //遍历数组的元素
        for (int x:numbers){      //将numbers数组中每一个数赋值给x
            System.out.println(x);
        }
    }
}

break和continue

break定义：

用于强行退出循环，不执行循环中剩余部分

continue定义：

用在循环语句中，用于终止某次循环过程，跳过循环还未执行的语句，接着进行下一次循环

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值