狂神.java基础学习

一、注释、标识符、关键字

注释

书写注释是一个非常好的习惯 BAT

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

Java中的注释有三种：

• 单行注释

• 多行注释

• 文档注释

  public class HelloWorld {
      public static void main(String[] args) {
          System.out.println("Hello,World!");
      }
  }
  
  
  //单行注释
  //只能注释一行文字
  //输出一个HelloWorld！
  
  //多行注释
  /*
     可以注释一段文字
     可以注释一段文字
     可以注释一段文字
      可以注释一段文字
   */
  
  //JavaDoc:文档注释
  /**
   * @Desceiption HelloWorld
   * @Author  作者
   */
  
  
  //有趣的代码注释
  /***
   *                    _ooOoo_
   *                   o8888888o
   *                   88" . "88
   *                   (| -_- |)
   *                    O\ = /O
   *                ____/`---'\____
   *              .   ' \\| |// `.
   *               / \\||| : |||// \
   *             / _||||| -:- |||||- \
   *               | | \\\ - /// | |
   *             | \_| ''\---/'' | |
   *              \ .-\__ `-` ___/-. /
   *           ___`. .' /--.--\ `. . __
   *        ."" '< `.___\_<|>_/___.' >'"".
   *       | | : `- \`.;`\ _ /`;.`/ - ` : | |
   *         \ \ `-. \_ __\ /__ _/ .-` / /
   * ======`-.____`-.___\_____/___.-`____.-'======
   *                    `=---='
   *
   * .............................................
   *          佛祖保佑             永无BUG
   */
  

  标识符

  关键字

  

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

  标识符注意的点：

  1. 所有的标识符都应该以字母（A——Z或者a——z），美元符（$）、或者下划线（_）开始。
  2. 首字母之后可以是字母（A——Z或者a——z），美元符（$）、或者下划线（_）或者数字的任何字符组合。
  3. 不能使用关键字作为变量名或者方法名。
  4. 标识符是大小写敏感的、
  5. 合法标识符举例：age、$salary、_value、__1_value
  6. 非法标识符举例：123abc、-salary、#abc
  7. 可以使用中文命名，但是一般不建议这样去使用，也不建议是用拼音，很low。

  public class Demo01 {
      public static void main(String[] args) {
  
          String 英雄联盟 = "英勇青铜";
         // String 英雄联盟 = "最强王者";
          System.out.println(英雄联盟);
  
          //大小写十分敏感
          String man = "qinjiang";
          String Man = "qinjiang";
  
          String Ahello = "qinjiang";
          String ahello = "qinjiang";
          String $hello = "qinjiang";
          String _hello = "qinjiang";
  
          String _1 = "qinjiang";
  
          //String 1hello = "qinjiang";
          //String #hello = "qinjiang";
          //String *hello = "qinjiang";
      }
  }
  

二、数据类型

强类型语言：要求变量的使用严格符合规定，所有变量都必须先定义才能使用安全性较高，但速度较慢。

弱类型语言：安全性较低，但速度较快。

Java的数据类型分为两大类

• 基本类型(primitive type)

• 引用类型(reference type)

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=30L;//Long类型要在数字后面加个L

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

        //字符
        char name ='国';
        //字符串，String不是关键字，类
        //String namea = "秦疆";

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

什么是字节

• 位（bit）:是计算机 内部数据 储存的最小单位，11001100是一个八位二进制数。

• 字节（byte）：是计算机中 数据处理 的基本单位，习惯上用大写B来表示。

• 1B（byte,字节） = 8bit（位）

• 字符：是指计算机中使用的字母、数字、字和符号

• 1bit表示1位

• 1Byte表示一个字节 1B=8b

• 1024B=1KB

• 1024KB=1M

• 1024M=1G

数据类型扩展及面试问题

public class Demo04 {
    public static void main(String[] args) {
        //整数拓展；    进制    二进制0b    十进制     八进制0    十六进制0x

        int i = 10;
        int i2 = 010;   //八进制0
        int i3 = 0x10;   //十六进制0x   0——9   A——F 16
        System.out.println(i);
        System.out.println(i2);
        System.out.println(i3);
        System.out.println("=======================================================");


        //浮点数拓展
        //float    有限  离散   舍入误差  大约   接近但不等于
        //double
        //最好完全避免浮点数进行比较
        //最好完全避免浮点数进行比较
        //最好完全避免浮点数进行比较
        float f = 0.1f;    //0.1
        double d = 1.0 / 10;  // 0.1

        System.out.println(f == d);  //false

        float d1 = 23232323231f;
        float d2 = d1 + 1;

        System.out.println(d1 == d2);//true
        System.out.println("=============================================");


        //字符拓展
        char c1 = 'a';
        char c2 = '中';
        System.out.println(c1);
        System.out.println((int)c1);//强制换行
        System.out.println(c2);
        System.out.println((int)c2);//强制换行

        //所有的字符本质还是数字
        //编码 Unicode 2字节   65536 Excel    2^16=65536

        //U0000--UFFFF

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

        //转义字符
        // \t   制表符
        // ......
        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);

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



        //布尔值拓展
        boolean flag = true;
        if (flag==true){}//新手
        if (flag){}//老手
        //less is more 代码要精简易读

    }
}

三、类型转换

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

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

强制类型转换

自动类型转换

public class Demo05 {
    public static void main(String[] args) {
        int i = 128;
        byte b = (byte)i; //内存溢出
        double u = i;

        //强制转换  （类型）变量名    高-->低
        //转换由低到高可以自动完成
        System.out.println(i);
        System.out.println(b);
        System.out.println(u);

        /*
        1.不能对布尔值进行转换
        2.不能把对象类型转换成不相干的类型
        3.再把高容量转换成低容量的时候，强制转换
        4.转换的时候可能会出现内存溢出，或者精度问题
        */

        System.out.println("=========================================");
        System.out.println((int)23.7);  //23
        System.out.println((int)-45.89f);  //-45

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

        char c='a';
        int d=c+1;
        System.out.println(d);//98
        System.out.println((char)d);//b
    }
}

public class Demo06 {
    public static void main(String[] args) {
        //操作比较大的数的时候，注意溢出的问题
        //JKD7新特性，数字之间可以用下划线分割
        int money = 10_0000_0000;
        int years = 20;
        int total = money*years; //-1474836480,计算的时候溢出了
        long total2 = money*years; //默认是int，转换之前已经存在问题了？

        long total3 = money*(long)years;//先把一个数转换为Long
        System.out.println(total);
        System.out.println(total2);
        System.out.println(total3);

        //Long类型后面写L或l都可以。


    }
}

四、变量、常量

变量

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

public class Demo07 {
    public static void main(String[] args) {
        //int a,b,c;
        //int a=1,b=2,c=3;   //注意程序可读性，不建议这样写，建议逐个定义
        String name = "qinjiang";
        char x = 'X';
        double pi = 3.14;

    }
}

变量作用域

• 类变量
• 实例变量
• 局部变量

public class Demo08 {


    //类变量   static
    static double salary = 2500;

    //属性：变量

    //实例变量：从属于对象；
    //如果不自行初始化，这个类型的默认值 0.0.0
    //布尔值：默认是false
    //除了基本类型，其余的默认值都是null
    String name;
    int age;

    //main方法



    public static void main(String[] args) {

        //局部变量：必须声明和初始化值，只在此方法中可以使用

        int i = 10;

        System.out.println(i);


        //变量类型   变量名字 = new Demo08
        Demo08 demo08 = new Demo08();
        System.out.println(demo08.age);//0
        System.out.println(demo08.name);//null

        System.out.println(salary);//2500
    }
}

常量

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

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

常量名一般使用大写字符。

public class Demo09 {

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

    }
}

变量的命名规范

• 所有的变量、方法、类名：见名知意
• 类成员变量：首字母小写和驼峰原则：monthSalary 除了第一个单词以外，后面的单词首字母大写 lastname lastName
• 局部变量：首字母小写和驼峰原则
• 常量：大写字母和下划线：MAX_VALUE
• 类名：首字母大写和驼峰原则：Man，GoodMan
• 方法名：首字母小写和驼峰原则：run(),runRun()

五、运算符

Java语言支持如下运算符：

package operator;

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);//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 Demo02 {
    public static void main(String[] args) {
        long a=123123123123L;
        int b=123;
        short c= 10;
        byte d=8;

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

​ 在运算过程中，当变量类型中有Long类型时，输出结果为Long类型，若为short或者byte比ing等级低的变量，则均输出Int类型。同样的，如果其中含有double类型变量，则输出double类型变量

package operator;

public class Demo03 {
    public static void main(String[] args) {
        //关系运算符返回的结果：  正确，错误   布尔值

        int a = 10;
        int b = 20;
        int c = 21;

        //取余，模运算
        System.out.println(c%a);//c/a   1
        System.out.println(a>b);//false
        System.out.println(a<b);//true
        System.out.println(a==b);//false
        System.out.println(a!=b);//true
    }
}

自增自减运算符

package operator;

public class Demo04 {
    public static void main(String[] args) {
        //自增 ++，自减 --      一元运算符
        int a=3;

        int b = a++;
        //a++ ,先赋值，再自增
        int c = ++a;
        //++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);//8
    }
}

逻辑运算符、位运算符

package operator;

public class Demo05 {
    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,并没有变成6


    }
}

package operator;

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

        /*
        A=0011 1100
        B=0000 1101

        A&B=0000 1100
        (只有当两个数字都为1时，才输出1，否则输出0)
        A|B=0011 1101
        （只有当两个数字都为0时，才输出0，否则输出1）
        A^B=00110001
        （只有当两个数字相同时，输出为0，否则输出1）
        ~B=1111 0010
        （将B的值全部相反）

        效率极高
        <<   (向左移动)   相当于*2
        >>   (向右移动)   相当于/2

        0000 0000     0
        0000 0001     1
        0000 0010     2
        0000 0011     3
        0000 0100     4
        0000 1000     8
        0001 0000     16

        */
        System.out.println(2<<3);
        //向左移动三位，输出为16
    }
}

条件运算符

package operator;

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

      a+=b;
      a-=b;

        System.out.println(a);
        //字符连接符
        System.out.println(""+a+b);//1020
        System.out.println(a+b+"");//30

    }
}

package operator;

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

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

（）里面的优先级最大

六、包机制、JavaDoc

包机制

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

• 包语句的语法格式为

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

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

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

  import package1[.package2…].(classmate|*);

例如：com.kuang.base.;

推荐《阿里巴巴Java开发手册》

JavaDoc

• JavaDos命令是用来生成自己API文档的

• 参数信息

  • @author 作者名
  • @version 版本号
  • @since 指明需要最早使用的JDK版本
  • @param 参数名
  • @return 返回值情况
  • @throws 异常抛出情况

package base;

/**
 * @author 王 程
 * @version 1.0
 * @since 1.8
 */
public class Doc {
    String name;

    /**
     * @author wang
     * @param name
     * @return
     * @throws Exception
     */
    public String text(String name) throws Exception{
        return name;

        //javadoc 参数 java文档
        //面向百度编程
    }
}

控制台生成Doc文件