java基础语法

2021/4/10 12:28:01

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

注释

  • 注释是写给读代码的人看的,给代码做一个标注
  • 注释不会被执行
  • 书写注释是一个非常好的习惯
  • 平时写代码一定要注意规范注释
  • Java中的注释有三种
    • 单行注释:只能注释一行
    • 多行注释:可以注释一段文字
    • 文档注释:和JavaDoc联合使用
/**
 * 文章注释
 * @Description HelloWorld
 * @Author 小智编程
 */
public class HelloWorld {
    public static void main(String[] args) {

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

标识符 & 关键字

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

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

    image

数据类型

  • 强类型语言

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

    • 弱类型语言

    • 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);
        }
    

注意点:

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

变量、常量、作用域

变量

  • 变量:就是可以变化的量
  • 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...]];
    //必须放到首句
    
  • 一般利用公司域名倒置作为包名

    image

  • 为了能够使用某一包的成员,我们需要在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;
        }
    }
    

image



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


扫一扫关注最新编程教程