Day02 java基础

Java基础

多写代码，多写笔记，多写文章

多练交流，多练思维，多练技能

多分享知识，多提问怎么了，多思考为什么

• 为方便管理，建立一个空的项目，点击File->new->project，选择Empty Project
  

• 在建立的空项目里面，点File ->new->一个Module
  

• 选Java，一路next

  

• 点击File->Project Structure -> Project ->sdk选择1.8.0152 ->Project Language Level选择8

1.注释、标识符、关键字

• 单行注释

• 多行注释

• 文档注释

• Java区分大小写，例如Man和man是不一样的变量

2.数据类型

Java是强类型语言，要求变量的使用严格符合定义，所有变量都必须先定义后才能使用

• 基本类型（primitive type）：数值类型（整数类型、浮点类型、字符类型），boolean类型（占一位，其值只有true和false）

• 引用类型（reference type）：类，接口，数组
  

注意：浮点数，会产生精度缺失。最好完全避免使用浮点数进行比较

3.类型转换

低------------------------------------------------------------->高

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

public static void main(String[] args) {
        int i = 128;
//        强制转换：从高到低
        byte b = (byte) i;

        System.out.println(i);  //128
        System.out.println(b);  //-128  内存溢出

//        自动转换：从低到高
        double d = i;
        System.out.println(d);  //128.0

注意点：

1. 不能对布尔类型进行转换

2. 不能把对象类型转换为不相干的类型

3. 在把高容量转换到低容量的时候，强制转换

4. 转换的时候可能存在内存溢出，或者精度问题

   //        转换的时候可能存在内存溢出，或者精度问题
           System.out.println((int)23.7);  //23
           System.out.println((int)-45.666f);  //-45
   

4.变量、常量

• 变量

  分为：局部变量，实例变量，类变量

再次强调：Java是一种强类型语言，每个变量都必须声明其类型，每个变量都必须先定义后使用！

每个变量都有类型，类型可以是基本类型（整型、浮点型、布尔型、字符型），也可以是引用类型（类、数组、接口）

• 变量的作用域

  public class _3_1变量的作用域 {
  //    类变量：在类里面但在方法外面定义，加一个关键字static
      static double salary = 2500;
  //   实例变量：从属于对象，在类里面但在方法外面。若未初始化默认值为0，0.0
      String name;
      int age;
  
  //    main方法
      public static void main(String[] args) {
  //        局部变量：在方法里面，必须声明和初始化值
          int i = 10;
          System.out.println(i);
  
  //        实例变量：从属于类、从属于对象，就得这样使用
          _3_1变量的作用域 demo = new _3_1变量的作用域();
          System.out.println(demo.age);
          System.out.println(demo.name);
  
  //        类变量：用时就不用new了
          System.out.println(salary);
      }
  
  //    其他方法
      public void add(){}
  }
  
  

• 变量的命名规范

  • 所有变量、方法、类名：见名知意
  • 类成员变量：首字母小写和后面的单词首字母大写，如：lastName
  • 局部变量：首字母小写和后面的单词首字母大写
  • 常量：大写字母和下划线，如：MAX_VALUE
  • 类名：首字母大写和后面的单词首字母大写，如：Man，GoodMan
  • 方法名：首字母小写和后面的单词首字母大写，如runRun()

• 常量

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

  常量名一般使用大写字母

  格式：
  final 常量名 = 值;
  final double PI = 3.14;
  

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

5.运算符

• 算术运算符：+，-，*，/，%，++，–

• 赋值运算符：=

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

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

• 位运算符：&，|，^，~，>>，<<，>>>

• 条件运算符：？:

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

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

public class Demo02 {
    public static void main(String[] args) {
        long a = 123123123l;
        int b = 18;
        short c = 10;
        byte d = 8;
        float f = 1.2f;

//        println的最低输出类型为int类型
        System.out.println(a+b+c+d);//long类型
        System.out.println(a+b+c+d+f);//float类型
        System.out.println(b+c+d);//int类型
        System.out.println(b+c+d+f);//float类型
        System.out.println(c+d);//int类型
        System.out.println(c);//int类型
    }
}

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

        System.out.println(c%a);//1
        System.out.println(a>b);//false
        System.out.println(a<b);//true
        System.out.println(a==b);//falsee

    }
}

public class Demo04 {
    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,很多运算我们会使用一些工具类来操作
        double pow = Math.pow(2, 3);
        System.out.println(pow);//8.0
    }
}

public class Demo05 {
    public static void main(String[] args) {
//        逻辑运算符 与&& 或|| 非!
        boolean a = true;
        boolean b = false;

        System.out.println("a && b:"+(a&&b));//false
        System.out.println("a || b:"+(a||b));//true
        System.out.println("!(a && b):"+!(a&&b));//true
        
//        短路运算:比如&&，当从左往右判断，判断到一个运算为false时，后面不再判断直接返回false
        int c = 5;
        System.out.println("(c < 4)&&(c++):"+((c < 4)&&(c++<4)));//false
        System.out.println(c);//5
    }
}

public class Demo07 {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;

        a+=b;
        System.out.println(a);//30
        System.out.println(b);//20
        System.out.println(a+b);//50
        System.out.println(""+a+b);//3020
        System.out.println(a+b+"");//50
//        当println中最前面出现字符串类型时，它会把其他变量也转化为字符串类型，即算术运算不会运算了
//        字符串出现在最后面，不影响算术运算
    }
}

public class Demo08 {
    public static void main(String[] args) {
//        三元运算符 x?y:z
//        如果x为真则y，如果x为假则z

        int score = 80;
        String type = score < 60? "不及格":"及格";
        System.out.println(type);
    }
}

6.包机制

• 为了更好地组织类，Java提供了包机制，用于区别类名的命名空间（本质：文件夹）

• 建包
  

• 导包

  import 包名;

7.JavaDoc

• 代码的注解

package base;

/**
 * @Author:Sp
 * @Date:2021/1/14
 * @Description:base
 */
public class Doc {
    String name;

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

• 查看用javadoc命令写的文档（在index.html中）