Java基础语法

本文介绍了Java编程语言的基础概念,包括注释的使用、标识符规则、数据类型(基本类型和引用类型)、类型转换注意事项、变量和常量、运算符、包机制以及JavaDoc的用途。
摘要由CSDN通过智能技术生成

Java基础语法

  • 注释、标识符、关键字
  • 数据类型
  • 类型转换
  • 变量、常量
  • 运算符
  • 包机制、JavaDoc

注释

  • 平时我们编写代码,在代码量比较少的时候,我们还可以看懂自己写的,但是当项目结构一旦复杂起来,我们就需要用到注释了

  • 注释并不会被执行,是给我们写代码的人看的

  • 书写注释是一个非常好的习惯

  • 平时写代码一定要注意规范

  • Java中的注释有三种:

    • 单行注释
    • 多行注释
    • 文档注释

标识符

  • 关键字

    image-20240404103258567

  • Java所有的组成部分都需要名字。类名、变量名以及方法名都被称为标识符 。

标识符注意点

  • 所有的标识符都应该以字母(A-Z或者a-z),美元符($)、或者下划线(_)开始
  • 首字符之后都可以是字母(A-Z或者a-z),美元符($)、下划线(_)或者数字的任何字符组合。
  • 不能使用关键字作为变量名或方法名。
  • 标识符是大小写敏感
  • 合法标识符举例:age、$salary、_value、__1_value
  • 非法标识符举例:123abc、-salary、#abc
  • 可以使用中文命名,但是一般不建议这样去使用,也不建议使用拼音,很Low

数据类型

  • 强类型语言

    • 要求变量的使用要严格符合规定,所有变量都必须先定义后才能使用
  • 弱类型语言

  • Java的数据类型分为两大类

    • 基本类型(primitive type)

    • 引用类型(reference type)

      基本数据类型
      数值类型
      整数类型
      byte占1个字节,范围:-128-127
      short占2个字节,范围:-32768-32767
      int占4个字节,范围:-2147483648-2147483647
      long占8个字节范围:-9223372036854775808-9223372036854775807
      浮点类型
      float占4个字节
      double占8个字节
      字符类型char占2个字节
      boolean类型

什么是字节

  • 位(bit):是计算机内部数据存储的最小单位,11001100是一个八位二进制数。
  • 字节(byte):是计算机中数据处理的基本单位,习惯上用大写B来表示
  • 1B(byte,字节)=8bit(位)
  • 字符:是指计算机中使用的字母、数字、字和符号
  • 1bit表示1位,
  • 1Byte表示一个字节1B=8b。
  • 1024KB=1KB
  • 1024KB=1M
  • 1024M=1G

整数拓展

进制 二进制0b 十进制 八进制0 十六进制0x

float 有限 离散 舍入误差 大约 接近不等于

最好完全避免使用浮点数进行比较

字符拓展

char c1 = 'a';

char c2 = '中';

System.out.println(c1);

System.out.println((int)c1);//强制转换

System.out.println(c2);
System.out.println((int)c2);//强制转换

//所有的字体本质还是数字

转义字符

\t 制表符

\n 换行

布尔值拓展

boolean flag = true;
if(flag==true){}	//新手
if(flag){}			//老手
//Less is	More!	代码要精简易读

类型转换

  • 由于Java是最强类型语言,所以要进行有些运算的时候,需要用到类型转化。

    public class Demo05{
        public static void main(String[] args) {
            int i = 128;
            byte b = (byte)i;//内存溢出
            
            //强制转换	(类型)变量名		高--低
            //自动转换		低--高
            
            System.out.println(i);
            System.out.println(b);
            
            /*
            注意点:
            1.不能对布尔值进行转换
            2.不能把对象类型转换为不相干的类型
            3.在把高容量转换到低容量的时候,强制转换
            4.转换的时候可能存在内存溢出,或者精度问题!
            */
            System.out.println("==================");
            System.out.println((int)23.7);			//23
            System.out.println((int)-45.89f);		//-45
            
            char c = 'a';
            int d = c+1;
            System.out.println(d);
            
        }
    }
    
public class Demo06 {
    public static void main(String[] args){
        //操作比较大的数的时候,注意溢出问题
        //JDK7新特性,数字之间可以用下划线分割
        int money = 10_0000_0000;
        int years = 20;
        int total1 = money*years;//-1474836480,计算的时候溢出了
        long total2 = money*years;//默认是int,转换之前已经存在问题了
        long total3 = money*((long)years);//先把一个数转换为Long
        System.out.println(total3);
    }
}

变量

  • 变量是什么:就是可以变化的量!

  • Java是一种强类型语言,每个变量都必须声明其类型。

  • Java变量是程序中最基本的存储单元,其要素包括变量名,变量类型和作用域

    type varName [=value] [{,varName[=value]}];
    //数据类型	变量名 = 值;可以使用逗号隔开来声明多个同类型变量。
    
  • 注意事项:

    • 每个变量都有类型,类型可以是基本类型,也可以是引用类型。
    • 变量名必须是合法的标识符。
    • 变量声明是一条完整的语句,因此每一个声明都必须以分号结束

变量作用域

  • 类变量

  • 实例变量

  • 局部变量

    public class Variable{
        static int allClicks=0;			//类变量
        String str="hello world";		//实列变量
        
        public void method(){
            int i = 0;					//局部变量
        }
    }
    
    public class Demo08 {
        //属性:变量
        static double salary = 2500;
        //实例变量:从属于对象;如果不自行初始化,这个类型的默认值  0  0.0
        //布尔值:默认是false
        //除了基本类型,其余的默认值都是null;
        String name;
        int age;
    
        //main方法
        public static void main(String[] args) {
    
            //局部变量;必须声明和初始化值
            int i = 10;
            System.out.println(i);
    
            //变量类型  变量名字 = new Demo08();
            Demo08 demo08 = new Demo08();
            System.out.println(demo08.age);
            System.out.println(demo08.name);
    
            //类变量   static
            System.out.println(salary);
        }
    
        //其他方法
        public void add(){
    
        }
    }
    

常量

  • 常量:初始化(initialize)后不能再改变值!不会变动的值。
  • 所谓常量可以理解成一种特殊的变量,它的值被设定后,在程序运行过程中不允许被改变

变量的命名规范

  • 所有变量、方法、类名:见名知意
    • 类成员变量:首字母小写和驼峰原则:monthSalary除了第一个单词以外,后面单词首字母大写 lastname lastName
  • 局部变量:首字母小写和驼峰原则
  • 常量:大写字母和下划线:MAX_VALUE
  • 类名:首字母大写和驼峰原则:Man,GoodMan
  • 方法名:首字母小写和驼峰原则:run(),runRun()

运算符

  • Java语言支持如下运算符:优先级()

    • 算数运算符:+,-,*,/,%,++,–
    • 赋值运算符=
    • 关系运算符:>,<,>=,<=,==,!= instanceof
    • 逻辑运算符:&&,||,!
    • 位运算符:&,|,^,~,>>,<<,>>>
    • 条件运算符 ?:
    • 扩展赋值运算符:+=,-=,*=,/=
    package operator;
    
    public class Demo01 {
        public static void main(String[] args) {
            //二元运算符
            //Ctrl + D : 复制当前行到下一行
            int a =10;
            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);
    
        }
    }
    
    
    package operator;
    
    public class Demo02 {
        public static void main(String[] args) {
            long a = 123123123123123L;
            int b = 123;
            short c = 10;
            byte d = 8;
    
            System.out.println(a+b+c+d);//Long
            System.out.println(b+c+d);//Int
            System.out.println(c+d);//Int
        }
    }
    
    
    package operator;
    
    public class Demo03 {
        public static void main(String[] args) {
            //关系运算符返回的结果:正确,错误    布尔值
    
            int a = 10;
            int b = 20;
            int c = 21;
    
            //取余,模运算
            System.out.println(c%a);
    
            System.out.println(a>b);
            System.out.println(a<b);
            System.out.println(a==b);
            System.out.println(a!=b);
    
        }
    }
    
    package operator;
    
    public class Demo04 {
        public static void main(String[] args) {
            //++    --      自增,自减  一元运算
            int a = 3;
    
            int b = a++;
            //a++   a = a + 1;
            System.out.println(a);
            //a++   a = a + 1;
            int c = ++a;//++a   a = a + 1;
    
            System.out.println(a);
            System.out.println(b);
            System.out.println(c);
    
            //幂运算 2^3   2*2*2 = 8   很多运算,我们会使用一些工具类来操作!
            double pow = Math.pow(3,2);
            System.out.println(pow);
        }
    }
    
    
    package operator;
    
    //逻辑运算符
    public class Demo05 {
        public static void main(String[] args) {
            //与(and)     或(or)      非(取反)
            boolean a = true;
            boolean b = false;
    
            System.out.println("a && b:"+(a&&b));//逻辑与运算:两个变量都为真,结果才为true
            System.out.println("a || b:"+(a||b));//逻辑或运算:两个变量有一个为真,则结果才为true
            System.out.println("a || b:"+(a||b));//如果是真,则变为假,如果是假则变为真
            System.out.println("!(a && b) :"+!(a&&b));
    
            //短路运算
            int c = 5;
            boolean d = (c<4)&&(c++<4);
            System.out.println(d);
            System.out.println(c);
        }
    }
    
    package operator;
    
    public class Demo06 {
        public static void main(String[] args){
            /*
            A = 0011 1100
            B = 0000 1101
    
            A&B 0000 1100
            A|B 0011 1101
            A^B 0011 0001
            ~B  1111 0010
    
            2*8 = 16   2*2*2*2
            //效率极高!!!
            <<(左移)  *2
            >>(右移)  /2
    
            0000 0000   0
            0000 0001   1
            0000 0010   2
            0000 0011   3
            0000 0100   4
            0000 1000   8
            0001 0000   16
    
             */
    
            System.out.println(2<<3);
        }
    }
    
    package operator;
    
    public class Demo07 {
        public static void main(String[] args){
            int a = 10;
            int b = 20;
    
            a+=b; //a = a+b
            a-=b; //a = a-b
    
            System.out.println(a);
    
            //字符串连接符  + ,String
            System.out.println(a+b);
            System.out.println(""+a+b);
            System.out.println(a+b+"");
        }
    }
    
    package operator;
    
    public class Demo08 {
        public static void main(String[] args){
            // x ? y : z
            // 如果x==true,则结果为y,否则结果为z
    
            int score = 50;
            String type = score < 60 ?"不及格":"及格"; //必须掌握
            System.out.println(type);
        }
    }
    

包机制

  • 为了更好地组织类,Java提供了包机制,用于区别类名的命名空间。

  • 包语句的语法格式为:

    package pkg1[.pkg[.pkg3...]];

  • 一般利用公司域名倒置作为包名

  • 为了能够使用某一个包的成员,我们需要在Java程序中明确导入该包。使用"import"语句完成此功能

import package1[.package2...](classname|*);

  • public com.kuang.base.*;导入这个包下所有的类==.*==

JavaDoc

  • javadoc命令是用来生成自己API文档的
  • 参数信息
    • @author作者名
    • @version版本号
    • @since指明需要最早使用的jdk版本
    • @param参数名
    • @return返回值情况
    • @throws异常抛出情况
package base;

/**
 * @outhor Kuangshen
 * @version 1.0
 * @since 1.8
 */
public class Doc {

    String name;

    /**
     *
     * @param name
     * @return
     * @throws Exception
     */

    public String test(String name) throws  Exception{
        return name;
    // 通过命令行  javadoc 参数 Java文件
    //学会查找使用IDEA生产JavaDoc文档!
    }
}

c命令是用来生成自己API文档的

  • 参数信息
    • @author作者名
    • @version版本号
    • @since指明需要最早使用的jdk版本
    • @param参数名
    • @return返回值情况
    • @throws异常抛出情况
package base;

/**
 * @outhor Kuangshen
 * @version 1.0
 * @since 1.8
 */
public class Doc {

    String name;

    /**
     *
     * @param name
     * @return
     * @throws Exception
     */

    public String test(String name) throws  Exception{
        return name;
    // 通过命令行  javadoc 参数 Java文件
    //学会查找使用IDEA生产JavaDoc文档!
    }
}
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值