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

注意点：

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...]];
  //必须放到首句
  

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

  

• 为了能够使用某一包的成员，我们需要在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基础语法

原文：https://www.cnblogs.com/zhilei980719/p/14639700.html