Java基础

1. 注释

1.1 注释的作用

1. 代码写的多的时候，我们就需要注释。放止遗忘，便于理解。

2. 注释并不会执行

3. 注释是一个非常好的习惯

4. 平时书写代码一定要注意规范

1.2 Java中的三种注释

1. 单行注释：// 开头

2. 多行注释：/* */

3. 文档注释：/** */

4. //单行注释
   //输出“Hello，World
   
   //多行注释
   /*123
   4143
   1423
   3213
    */
   
   //JavaDoc:文档注释    /**    */
   /**
    * @Description HelloWorld
    * @Author 狂神说
    */
   

5. 有趣的代码注释

2. 标识符和关键字

2.1 关键词

1. 不能用关键字代表变量

2. java的所有的组成部分都需要有名字。类名，变量名以及方法名统称为标识符

3. public class HelloWorld {//类名
       public static void main(String[] args) {//方法名
           System.out.println("Hello, World");
       }
   }
   String teacher = "秦疆";
   

2.2 标识符

1. 所有标识符都应以字母，美元符（$），或者下划线（_）开始

2. 首字母之后可以是数字，字母，美元，下划线的任意组合

3. 不能用关键字作为变量名或方法名

4. 标识符大小写敏感

3. 数据类型

3.1 基本数据类型

1. 强类型语言

   • 要求变量的使用要严格符合规定，所有变量都必须先定义后使用（安全性高，速度下降）

2. 弱类型语言

   • 没什么要求

public class Demo02 {
    public static void main(String[] args) {
        String a = "Hello";
        int num = 10;
        System.out.println(a);
        System.out.println(num);
    }
}

3. java数字类型两大类

   • 基本类型（primitive type）

     graph LR 基本数据类型-->数值类型 基本数据类型-->boolean布尔类型有ture和false 数值类型-->整数类型 数值类型-->浮点类型 数值类型-->字符类型char占两个字节 整数类型-->byte占1个字节范围 整数类型-->short占2个字节范围 整数类型-->int占4个字节范围 整数类型-->long占8个字节范围 浮点类型-->float占4个字节 浮点类型-->double占8个字节

   • 引用类型（reference type）

     graph LR 引用数据类型-->类 引用数据类型-->接口 引用数据类型-->数组

     public class Demo02 {
         public static void main(String[] args) {
             String a = "Hello";
             int num = 10;
           System.out.println(a);
             System.out.println(num);
     
     
             //整数
             int num1 = 10;  //最常用
             byte num2 = 20;
             short num3 = 30;
             long num4 = 40L;  //Long类型要在数字后面加个L
     
             //小数：浮点数
             float num5 = 50.1F;  //float类型要在数字后面加个F
             double num6 = 3.141592653589793238462643;
             
             //字符
             char name = ‘A‘;
             //字符串，String不是关键字，是类
             String namea = "谢超杰";
             
             //布尔值
             boolean flag = true;
             //boolean flag = falst;
         }
     }
     

3.2 数据类型扩展以及试题讲解

1. 整数扩展

   • 进制：二进制（0b） 十进制 八进制（0） 十六进制（0x）

2. 浮点数扩展

   • float
   • double
   • 最好避免使用浮点数进行比较

3. 字符扩展

   • unicode（万国码）

4. 转义字符

   • \n换行符
   • \t制表符

5. 布尔值扩展

public class Demo03 {
    public static void main(String[] args) {
        //整形扩展
        int i = 10;
        int i2 = 010;//八进制
        int i3 = 0x10;//十六进制
        int i4 = 0b10;//二进制
        System.out.println(i);//10
        System.out.println(i2);//8
        System.out.println(i3);//16
        System.out.println(i4);//2

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

        float d1 = 23232323233223f;
        float d2 = d1 + 1;
        System.out.println(d1==d2);//ture

        //字符扩展
        char c1 = ‘a‘;
        char c2 = ‘中‘;
        char c3 = ‘\u0061‘;
        System.out.println(c1);//a
        System.out.println((int)c1);//97
        System.out.println(c2);//中
        System.out.println((int)c2);//20013
        System.out.println(c3);//a

        //转义字符
        // \t 制表符
        // \n  换行
        //......
        System.out.println("Hello\nWorld");
        System.out.println("Hello\tWorld");
        
        //布尔值扩展
        boolean flag = true;
        if(flag = true){}//新手
        if (flag){}//老手
        //less is more  代码要精简易读
    }
}

3.3 数据类型转换

• byte,short,char-->int-->long-->float-->double

1. 自动类型转换 低------高

2. 强制类型转换 高------低

   注意点

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

public class 类型转换 {
    public static void main(String[] args) {
        int a = 10;
        byte b = (byte)a;
        System.out.println(b);//10

        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);//98
        System.out.println((char)d);//b

        //溢出问题
        //JDK7新特性：数字之间可以用下划线分割
        int money = 10_0000_0000;
        int years = 10;
        int total1 = money*years;
        long total2 = money*years;
        System.out.println(total1);//1410065408
        System.out.println(total2);//1410065408    默认是int类型，转换之前已经存在问题了，解决方案如下：
        long total3 = money*((long)years);
        System.out.println(total3);//10000000000
    }
}

4. 变量、常量、作用域

4.1 变量

• 变量就是可以变化的量
• java是强类型语言，每个变量都必须声明其类型
• Java变量是程序中最基本的储存单元，其要素包括变量名，变量类型和作用域
• 每个变量都有类型，类型可以是基本类型，也可以是引用类型
• 变量名必须是合法的标识符
• 变量声明是一条完整的语句，因此每一个声明都必须以；结束
• 数据类型 变量名 = 值； 可以用逗号隔开来声明多个同类型变量

4.2 变量作用域

1. 类变量

2. 实例变量

3. 局部变量

   public class 变量 {
   
       //实例变量：从属于对象；如果不自行初始化，结果是这个类型的默认值  0  0.0  false  除了基本类型其余的都是null；
       String name;
       int age;
   
       //类变量 static
       static double salary = 2500;
   
       //main方法
       public static void main(String[] args) {
           int a = 1,b = 2,c = 3;//基本类型,注意程序可读性，最好写成三行
           String name = "xiechaojie";//引用类型
           char x = ‘X‘;
           double pi = 3.14;
           //局部变量（在{}内的）：必须声明和初始化值
           int i = 10;
           System.out.println(i);
   
           //变量类型   变量名字 = new 变量();
           变量 v = new 变量();
           System.out.println(v.age);
           System.out.println(v.name);
   
           //类变量  static
           System.out.println(salary);
           
       }
   }
   

4.3 常量（constant）

1. 初始化之后不能在改变的值，不会变动的值

2. 定义：final 常量名 = 值；

   ? final double PI = 3.14；

3. 常量名一般用大写字符

   public class 常量 {
   
       final static double PI = 3.14;//static,修饰符，不存在先后顺序
   
       public static void main(String[] args) {
           System.out.println(PI);
   
       }
   }
   

4.4 变量的命名规范

• 所有变量，方法，类名：见名知意
• 类成员变量：首字母小写和驼峰原则，除第一个单词外，后面的单词首字母大写。如：lastName
• 局部变量：首字母小写和驼峰原则
• 常量：大写字母和下划线：MAX_VALUE
• 类名：首字母大写和驼峰原则：Man，GoodMan（类名就是在str下创建的class）
• 方法名：首字母小写和驼峰原则：run（），runRun（）

5. 运算符

5.1 基本运算符

• 算数运算符：+ - * % ++ -- /

  public class Dome01 {
      public static void main(String[] args) {
          //crl + D 复制当前行到下一行
          int a = 10;
          int b = 20;
          int c = 25;
          int d = 25;
          System.out.println(a+b);//30
          System.out.println(a-b);//-10
          System.out.println(a*b);//200
          System.out.println(a/(double)b);//0.5
      }
  }
  

• 赋值运算符：=

  public class Dome02 {
      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);//123123123123264L
          System.out.println(b+c+d);//142
          System.out.println(c+d);//18
      }
  }
  

• 关系运算符：> < >= <= != instanceof

  public class Dome03 {
      public static void main(String[] args) {
          //关系运算符返回的结果：  正确，错误    布尔值
          int a =10;
          int b =20;
          int c =21;
  
          System.out.println(a>b);//falst
          System.out.println(a<b);//ture
          System.out.println(a==b);//falst
          System.out.println(a!=b);//ture
          System.out.println(c%b);1
      }
  }
  

• 逻辑运算符：&& || !

• 位运算符：& | ^ ~（取反） >>（右移） << （左移） >>>

• 条件运算符：？ ：

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

5.2 自增自减运算符、初识Math

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

        int a = 3;//++    --   自增自减一元运算符
        int b = a++;//先赋值再自增
        int c = ++a;//先自增再赋值

        System.out.println(a);//5
        System.out.println(b);//3
        System.out.println(c);//5

        //幂运算  2^3  2*2*2 = 8  很多运算，我们会使用一些工具类来做
        double pow = Math.pow(2,3);
        System.out.println(pow);
    }
}

5.3 逻辑运算符，位运算符

• 逻辑运算符

  public class Dome05 {
      public static void main(String[] args) {
          boolean a = true;
          boolean b = false;
  
          System.out.println("a && b"+(a && b));//a &&bfalse
          System.out.println("a || b"+(a || b));//a || btrue
          System.out.println("!(a && b)"+!(a && b));//!(a && b)true
  
          //短路运算
          int c = 5;
          boolean d = (c<4) && (c++<4);
          System.out.println(d);//false
          System.out.println(c);//5
      }
  }
  

• 位运算符

  public class Dome06 {
      public static void main(String[] args) {
          /*
          A = 0011 1100
          B = 0000 1101
          A & B = 0000 1100
          A | B = 0011 1101
          A ^ B = 0011 0001 (位置相同位0，不相同为1)
          ~B(取反) = 1111 0010
  
          2 * 8 = 16     2*2*2*2 = 16
          <<   *2
          >>   /2
  
         0000 0000        0
         0000 0010        2
         0000 0100        4
         0000 1000        8
         0001 0000        16
         所以2左移三位是16
           */
          System.out.println(2<<3);
      }
  }
  

5.4 三元运算符及小结

• 三元运算符

  public class Dome08 {
      public static void main(String[] args) {
          //x ? y : z
          //如果x==true，则结果为y，否则结果为z
  
          int score= 80;
          String type = score<60 ? "不及格" : "及格";
          System.out.println(type);
      }
  }
  

• 字符串连接

  public class Dome07 {
      public static void main(String[] args) {
          int a = 10;
          int b = 20;
  
          a+=b;//a=a+b
          a-=b;//b=b-a
  
          //字符串连接符   +  
          System.out.println(""+a+b);//1020(拼接)
      }
  }
  

6. 包机制、JavaDoc生成文档

6.1 包机制

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

• 包机制的语法格式为：

  package pkg1[. pkg2. pkg3...]];

• 包的本质就是文件夹

• 一般利用公司域名导致作为包名；com.baidu.www(com是第一级，baidu是第二级，www是第三级)

• 为了能够使用某一个包的成员，我们需要在Java程序中明确导入该包。使用“import”语句可完成此功能。*导入包下所有的类。

• 看阿里巴巴开发手册，无规矩不成方圆，无规范不能协作。

6.2JavaDoc生成文档

1. JavaDoc命令是用来生成自己的API文档的

2. 参数信息

   • @author 作者名

   • @versin 版本号

   • @since 指明需要最早使用的jdk版本

   • @param 参数名

   • @return 返回值情况

   • @throws 异常抛出情况

     package com.xie.operator;
     
     //类的注释
     /**
      * @author XieChaojie
      * @version 1.0
      * @since 1.8
      */
     public class Doc {
         String name;
     
         //文档的注释
         /**
          * @author XieChaojie
          * @param name
          * @return
          * @throws Exception
          */
         public String test(String name) throws Exception{
             return name;
             
             //通过命令行  javadoc  java文件名  可以查找文档
         }
     }
     

3. 用IDEA生成javadoc文档

   

Java基础

原文：https://www.cnblogs.com/xie-lumos/p/15054055.html