java基础语法

2021/4/10 12:28:01

编程Tag： string 基础 Java int 语法 out system public println

本文主要是介绍java基础语法，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

注释

注释是写给读代码的人看的，给代码做一个标注
注释不会被执行
书写注释是一个非常好的习惯
平时写代码一定要注意规范注释
Java中的注释有三种
- 单行注释：只能注释一行
- 多行注释：可以注释一段文字
- 文档注释：和JavaDoc联合使用

/**
 * 文章注释
 * @Description HelloWorld
 * @Author 小智编程
 */
public class HelloWorld {
    public static void main(String[] args) {

        //输出hello，world（单行注释）
        System.out.println("hello,world!");
    }
}
        /*
        多行
        注释
        */

标识符 & 关键字

Java所有的组成部分都需要名字。类名、变量名、以及方法名都被称为标识符
- 注意点
  - 所有的标识符都应该以字母（A_Z或az），美元符$、或下划线_开始
  - 首字符之后可以是字母（A_Z或az），美元符 $ 、下划线 _ 或数字的任何字符组合
  - 不能使用关键字作为变量名或方法名
  - 标识符是大小写敏感的
  - 合法标识符：age、$salary、_value、__1_value
  - 非法标识符：123abc、-salay、#abc
- 可以使用中文命名，但是一般不建议这样去使用，也不建议使用拼音，很Low
关键字

数据类型

强类型语言
- 要求变量的使用要严格符合规定，所有变量都必须先定义后才能使用
- 弱类型语言
- Java的数据类型分为两大类
  - 基本数据类型（primitive type）
    - 数值类型
      - 整数类型
        
        byte 占1个字节范围：-128~127(-2的7次方)
        
        short 占2个字节范围：-32768~32767(-2的15次方)
        
        int 占4个字节范围：-2147483648~2147483647(-2的31次方)
        
        long 占8个字节范围：-9223372036854775808~9223372036854775807(-2的63次方)
      - 浮点类型
        
        float 占4个字节
        
        double 占8个字节
      - 字符类型 char 占两个字符
    - boolean类型占一个字符其值只有true和false
  - 引用数据类型（reference type）
    - 类
    - 接口
    - 数组

public class DingYiBianLiang {
    public static void main(String[] args) {
        //八大基本类型
        //整数
        int num1=10; //常用
        byte num2=20;
        short num3=30;
        long num4=30L;//Long类型要在数字后面加个L

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

        //字符
        char name='张';
        //字符串，String不是关键字、类
        String namea="小智";

        //布尔值：是非
        boolean flag=true;
        boolean flag2=false;
    }
}

字节

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

数据类型扩展及面试题讲解

import java.math.BigDecimal;

public class Demo1 {
    public static void main(String[] args) {
        //整数拓展  进制  二进制0b   十进制 八进制0    十六进制0x
        int a=10;
        int b=010;
        int c=0x10;
        int d=0b10;//0~9 A~F 16
        System.out.println(a);//结果为10
        System.out.println(b);//结果为8
        System.out.println(c);//结果为16
        System.out.println(d);//结果为2

        System.out.println("============================");

        //浮点数拓展?    银行业务如何实现？钱
        //BigDecimal  数学工具类

        //float   有限  离散  舍入差 大约  接近但不等于
        //double
        //最好完全避免使用浮点数进行比较
        float e=0.1f;
        double f=1.0/10;
        System.out.println(e==f);//false

        float g1=23132245689f;
        float g2=g1+1;
        System.out.println(g1==g2);//true

        System.out.println("============================");

        //字符拓展
        char h1='中';
        char h2='a';
        System.out.println(h1);
        System.out.println((int) h1);//强制转换     97
        System.out.println(h2);
        System.out.println((int) h2);//强制转换     22269
        //所有的字符本质还是数字
        //编码    Unicode：97=a 两个字节    65536   Excel-2的16次=65536

        //U000~UFFF
        char c3='\u0061';
        System.out.println(c3);//a

        System.out.println("============================");

        //转义字符
        //  \t  制表符
        //  \n  换行
        //...

        System.out.println("hello\nworld");

        System.out.println("============================");

        String sa=new String("hello world");
        String sb=new String("hello world");
        System.out.println(sa == sb);//false
        String sc="hello world";
        String sd="hello world";
        System.out.println(sc == sd);//true
        //对象    从内存分析

        System.out.println("============================");

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

类型转换

由于Java是强类型语言，所以要进行有些运算的时候，需要用到类型转换

低-------------------------------------------------高
byte、short、char->int->long->float->double

运算中，不同类型的数据先转化为同一类型，然后进行运算
强制类型转换

自动类型转换

lic class leixingzhuanhuan {
    public static void main(String[] args) {
        //强制转换  （类型）变量名     高->低
        int i=128;
        byte b=(byte) i;//内存溢出
        System.out.println(i);//128
        System.out.println(b);//-128

        System.out.println("============================");

        //自动转换       低->高
        int i2=128;
        double b2=i2;//内存溢出
        System.out.println(i2);//128
        System.out.println(b2);//128.0

        System.out.println("============================");

        System.out.println((int) 23.7);
        System.out.println((int) -45.89f);

        System.out.println("============================");

        //操作比较大的数时，注意溢出问题
        //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(total1);
        System.out.println(total2);
        System.out.println(total3);
    }

注意点：

不能对布尔值进行转换
不能把对象类型转换为不相干的类型
在把高容量转换到低容量的时候，强制转换
转换的时候可能存在内存溢出，或精度问题

变量、常量、作用域

变量

变量：就是可以变化的量
Java是一种强类型语言，每个变量都必须声明其类型
Java变量是程序中最基本的存储单元，其要素包含变量名，变量类型和作用域
注意事项
- 每个变量都有类型，类型可以是基本类型，也可以是引用类型
- 变量名必须是合法的标识符
- 变量声明是一条完整的语句，因此每一个声明都必须以分号结束
- 要注意程序的可读性

变量作用域

类变量
实例变量

局部变量

public class Bianliang {
    //类变量：前面加static，从属于这个类，随着类一起出现和消失
    static double salary=2500;
    //属性：变量
    //实例变量：从属于对象；如果不自行初始化，会使用这个类型的默认值
    //布尔值默认值为false  基本数据类型为0或0.0
    // 除基本类型，其余默认值都为null
    String name;
    int age;

    //main方法
    public static void main(String[] args) {
        //局部变量：必须声明和初始化值
        int i=10;
        System.out.println(i);//10

        //变量类型  变量名字=new Bianliang（）；
        Bianliang bianliang = new Bianliang();
        System.out.println(bianliang.name);//null
        System.out.println(bianliang.age);//0

        //类变量   static
        System.out.println(salary);//2500.0
    }
}

变量的命名规范

所有变量、方法、类名：见名知意
类成员变量：首字母小写和驼峰原则：monthSalary
局部变量：首字母小写和驼峰原则
常量：大写字母和下划线：MAX_VALUE
类名：首字母大写和驼峰原则：Man、GoodMan
方法名：首字母小写和驼峰原则：run()、runRun()

常量

常量（Constant）：初始化（initialize）后不能改变值！不会变动的值

所谓常量可以理解为一种特殊的变量，它的值被设定后，在程序运行过程中不允许被改变

public class Changliang {

    //修饰符不存在前后顺序
    static final double PI=3.14;
    final static double PI2=3.14;

    public static void main(String[] args) {
        //final 常量名=值;
		final double PI=3.14;
        System.out.println(PI);
        System.out.println(PI2);
    }
}

常量名一般使用大写字符

运算符

Java语言支持的运算符
- 算术运算符 +、-、*、/、%、++、--
- 赋值运算符 =
- 关系运算符 <、>、<=、>=、==、!=、instanceof
- 逻辑运算符 &&、||、！
- 位运算符 &、|、^、~、>>、<<、>>>
- 条件运算符？：
- 扩展赋值运算符 +=、-=、*=、/=

基本运算符

package operator;

public class Demo1 {
    public static void main(String[] args) {
        //二元运算符
        int a=10;
        int b=20;
        int c=30;
        int d=40;
        System.out.println(a + b);//30
        System.out.println(a - b);//-10
        System.out.println(a * b);//200
        System.out.println(a / b);//0
        System.out.println(a /(double)b);//0.5
    }
}


package operator;

public class Demo2 {
    public static void main(String[] args) {
        long a=123123123123123123L;
        int b=123;
        short c=10;
        byte d=8;
        double e=0.12;

        System.out.println(a + b + c + d);//long
        System.out.println(b + c + d);//int
        System.out.println(c + d);//int
        System.out.println(d + e);//double

        //如果有long类型结果也为long类型，如果有double类型结果也为double，其他都为int
    }
}


package operator;

public class Demo3 {
    public static void main(String[] args) {
        //关系运算符返回的结果：正确’错误  布尔值
        //if
        int a=10;
        int b=20;
        int c=21;

        System.out.println(a<b);
        System.out.println(a>b);
        System.out.println(a==b);
        System.out.println(a!=b);
        System.out.println(c%a);//取余，又称为模运算
    }
}

自增自减运算符、初识Math类（幂运算）

package operator;

public class Demo4 {
    public static void main(String[] args) {
        //++、--  自增、自减  一元运算符
        int a=3;
        System.out.println(a);//3
        int b=a++;
        System.out.println(b);//3   先赋值再加加
        System.out.println(a);//4
        int c=++a;
        System.out.println(c);//5   先加加再赋值
        System.out.println(a);//5
        int d=a--;
        System.out.println(d);//5   先赋值再减减
        System.out.println(a);//4
        int e=--a;
        System.out.println(e);//3   先减减再赋值
        System.out.println(a);//3


        int z=12;
        int x=12;
        System.out.println(z+++(++x));//25

        int v=12;
        int q=12;
        System.out.println((v++)+(++q));//25

        int w=12;
        int t=12;
        // System.out.println((w++)+++t);//报红错误

        //幂运算   2^3=2*2*2=8     很多运输算会使用一些工具类操作
        double pow = Math.pow(2, 3);
        System.out.println(pow);//8.0
    }
}

逻辑运算符、位运算符

package operator;

public class Demo5 {
    public static void main(String[] args) {
        //与 或   非（取反）
        boolean a=true;
        boolean b=false;

        System.out.println("a&&b:"+(a&&b));//逻辑与运算：两个变量都为真，结果才为真
        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);//false
        System.out.println (c);//5
        //当&&为false时，&&后的数不被执行

    }
}


package operator;

public class Demo6 {
    public static void main(String[] args) {
        /*
        A=0011 1100
        B=0000 1101
        A&B = 0000 1100 每一位分别进行比较，都为1则为1，否则为0
        A|B = 0011 1101 每一位分别进行比较，一个为1则为1，否则为0
        A^B = 0011 0001 每一位分别进行比较，相同则为0，不同为1
        ~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

        深究需了解计算机的组成原理
         */
        System.out.println(2 << 3);//16
    }
}

三元运算符及小结

package operator;

//三元运算符
public class Demo8 {
    public static void main(String[] args) {
        //X?y:z
        // 如果X==true，结果为Y，否则为z
        int score=80;
        String type = score<60?"不及格":"及格";
        //if
        System.out.println(type);
    }
}

包机制

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

包语句的语法格式为：

package pkg1[.pakg2[.pakg3...]];
//必须放到首句

一般利用公司域名倒置作为包名
为了能够使用某一包的成员，我们需要在Java程序中明确导入该包。使用"import"语句可完成此功能
```
import pkg1[.pakg2...].(classname|*);
```
包的本质就是一个文件夹

JavaDoc生成文档

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

如何使用IDEA生成JavaDoc文档？

package operator;

/**
 * @Aouthor xiaozhi
 * @version 1.0
 * @since 1.8
 */
public class Doc {
    String name;

    /**
     * @Author xiaozhi
     * @param name
     * @return
     * @throws Exception
     */
    public String test(String name)throws Exception{
        return name;
    }
}

这篇关于java基础语法的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！