3. Java基础

3、Java基础【基于IDEA】

3.1、快捷键

• psvm 创建主方法
• sout 打印
• ctrl+d 复制当前行到下一行
• alt+ender 创建局部变量，类；

3.2、注释，标识符，关键字

• 注释
  • 平时我们编写代码，在代码量比较少的时候，我们还可以看懂自己写的，但是当项目结构一旦复杂起来，我们就需要用到注释了。
  • 注释并不会被执行，是给我们写代码的人看的
  • 书写注释是一个非常好的习惯
• Java中的注释有三种:
  • //单行注释
  • /* 多行注释 */
  • /** 文 档注释 */
• 标识符
  • 所有的标识符都应该以字母(A-Z或者a-z),美元符（$)、或者下划线（ _ ）开始
  • 首字符之后可以是字母(A-Z或者a-z),美元符（$)、下划线（ _ ）或数字的任何字符组合
  • 不能使用关键字作为变量名或方法名。
  • 标识符是大小写敏感的
    
    合法标识符举例: age、$salary._value、__1_value
  • 非法标识符举例:123abc、-salary、#abc
  • 可以使用中文命名，但是一般不建议这样去使用，也不建议使用拼音，很Low

3.3、数据类型

• 强类型语言

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

• 弱类型语言

  • JavaScript...

• Java的数据类型分为两大类

  • 基本类型(primitive type)

• 引用类型(reference type)

  • 类
  • 接口
  • 数组

• 什么是字节

  • 位(bit):是计算机内部数据储存的最小单位，11001100是一个八位二进制数。
  • 字节(byte):是计算机中数据处理的基本单位，习惯上用大写B来表示,
  • 1B (byte,字节) = 8bit(位)
  • 字符:是指计算机中使用的字母、数字、字和符号
  • 1bit表示1位，
  • 1Byte表示一个字节1B=8b。
  • 1024B=1KB
  • 1024KB=1M
  • 1024M=1G

• 八种数据类型

  public class Demo02 {
      public static void main(String[] args) {
          //八点数据类型
          //整数
          int name1=10;  //最常用
          byte name2 =20;
          short name3=30;
          long name4=10000L;  //long类型在后面加L
          //小数，浮点数
          float name5=50.1F;//float类型在后面加F
          double name6=3.1415926535897;
          //字符
          char name7 = '中';
          //String 字符串 不是关键字是类
          String name8="何浩祥";
          //布尔值：是否
          boolean name9=true;
          boolean name=false;
      }
  }
  

• 数据类型拓展

  public class Demo03 {
      public static void main(String[] args) {
          //进制： 二进制  十进制  八进制  十六进制
          int i1=10;
          int i2=010;
          int i3= 0X10;
          System.out.println(i1);
          System.out.println(i2);
          System.out.println(i3);
          System.out.println("====================================");
          //fLoat有限  离散  舍入误差  大约接近但不等于
          //银行使用 数学工具类  BiqDecimal
          char m='a';
          char n='何';
          System.out.println((int)m);
          System.out.println((int)n);
          //所有的字符本质还是数字
          //编码Unicode表:(97= a 65 =A) 2字节  0-65536
          //u0000-uffff
          char x='\u0061';
          System.out.println(x);
          //转义字符
          //  \n  换行
          //  \t 制表符 tab
          //boolean值扩展
          boolean flag=true;
          if(flag==true){}//新手
          if(flag){}    //老手
          //代码要简单易读  less is more！
      }
  }
  

3.4、类型转换

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

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

• 强制类型转换

• 自动类型转换

• 举例

  public class Demo04 {
      public static void main(String[] args) {
          int i =128;
          byte b = (byte)i;//内存溢出
          //强制转换  (类型)变量名   高---低
          //自动转换   低---高
          System.out.println(i);
          System.out.println(b);
          /*
          * 注意
          * 1.不能对布尔值进行转换
          * 2. 不能把对象类型转换为不相干的类型
          * 在转换中可能出现内存溢出或者精度问题
          * */
          System.out.println("=================");
          System.out.println((int)2.12);
          System.out.println((int)-9.99);
          System.out.println("==================");
          char c ='a';
          int d =1+c;
          System.out.println(d);
          System.out.println((char)d);
      }
  }
  

• 注意溢出问题

  public class Demo05 {
      public static void main(String[] args) {
          //操作数比较大的时候注意溢出问题
          //jdk7新特性，数字可以用下划线分割
          int money =10_0000_0000;
          int year =20;
          int total =money*year;
          System.out.println(total);//计算的时候已经溢出了
          long total1 =money*year; //转换之前已经出现问题
          System.out.println(total1);
          long total2 =money*(long)year;
          System.out.println(total2);
      }
  }
  

3.5、变量，常量

• 变量

  • 变量是什么:就是可以变化的量!

  • Java是一种强类型语言，每个变量都必须声明其类型。

  • Java变量是程序中最基本的存储单元，其要素包括变量名，变量类型和作用域。

    //数据类型 变量名 =值

    public class Demo06 {
        public static void main(String[] args) {
            int a =1;
            double pi=3.14;
            String hhx="何浩祥";
            char x ='X';
        }
    }
    

• 注意事项:

  • 每个变量都有类型，类型可以是基本类型，也可以是引用类型。变量名必须是合法的标识符。
  • 变量声明是一条完整的语句，因此每一个声明都必须以分号结束；

• 变量作用域

  • 类变量

  • 实例变量

  • 局部变量

    public class Demo07 {
        //类变量  static
        static int salary= 20000;
        //实例变量 ：从属于对象,如果不自行初始化，值为这个类型的默认值；  0 0.0
        //布尔类型默认值是false
        //其余基本类型默认值为null
        String name;
        int age;
        public static void main(String[] args) {
            //局部变量必须声明和初始化
            int i =10;
            System.out.println(i);
            //变量类型 变量名字= new Demo07();
            Demo07 demo08 = new Demo07();
            System.out.println(demo08.age);
            System.out.println(demo08.name);
        }
        public  void add(){
            //类变量
            System.out.println(salary);
        }
    }
    

• 常量

  • 常量(Constant):初始化(initialize)后不能再改变值!不会变动的值。

  • 所谓常量可以理解成一种特殊的变量，它的值被设定后，在程序运行过程中不允许被改变。
    
    final 常量名 = 值;
    
    final double PI=3.14;

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

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

• 变量命名规范

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

3.6、运算符

• Java语言支持如下运算符:

  • 算术运算符:+， -，，l， %，++， --

  • *赋值运算符=

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

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

  • 位运算符:&，|，^，~，>>，<<，>>>(了解!! ! )

  • 条件运算符?∶

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

  package operator;
  public class Demo01 {
      public static void main(String[] args) {
          int a =10;
          int b =20;
          int c =30;
          int d =40;
          System.out.println(a+b);
          System.out.println(a-b);
          System.out.println(a*b);
          System.out.println(a/(double)b);
          long a =21312312312L;
          int b=11;
          short c=10;
          byte d =2;
          double e=2.21;
          System.out.println(a+b+c+d);//long
          System.out.println(b+c+d);//int
          System.out.println(c+d);//int
          System.out.println(a+b+c+d+e);//double
          //关系运算符返回结果 正确  错误  布尔值
          int a =10;
          int b =20;
          int c =21;
          System.out.println(c%a); //c%a=2...1
          System.out.println(a>b);
          System.out.println(a<b);
          System.out.println(a==b);
          System.out.println(a!=b);
          //++,-- 自增，自减  一元运算
          int a =3;
          int b =a++;  //执行完这个代码后，先赋值再自增
          //a=a+1;
          int c =++a; //执行这个代码后，先自增再赋值
          //a=a+1
          System.out.println(a);
          System.out.println(b);
          System.out.println(c);
          //幂运算 2^3 2*2*2=8 Java中很多运算会使用工具类来操作
          double pow = Math.pow(2, 3);
          System.out.println(pow);
          //逻辑运算符
          //与（and）  或(or)  非（取反）
          boolean a =true;
          boolean b =false;
          System.out.println("a&&b:"+(b&&a));  //逻辑与运算：两个变量都为真结果才为真
          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);
          System.out.println(c);
          //位运算符
              public static void main(String[] args) {
          /*
          A=0011 1100
          B=0000 1101
          A&B=0000 1100
          A|B=0011 0001
          ~B=1111 0010
            2*8=16
            位运算效率极高，由底层直接执行
            << *2
            >> /2
              0000 0000 0001  1
              0000 0000 0010  2
              0000 0000 0100  4
              0000 0000 1000  8
           */
          System.out.println(2<<3);
         //偷懒的运算符
             int a =10;
          int b =20;
          a+=b; //a=a+b
          System.out.println(a);
          a=10;
          a-=b; //a=a-b
          System.out.println(a);
          //字符串连接符 + ，String
          System.out.println(""+a+b);
          System.out.println(a+b+"");
          //三元运算符
          //x ? y : z x是否为真，如果为真返回x,如果不为真返回false
          int score =90;
          String type =  score >60? "及格":"不及格";
          System.out.println(type);
      }
  }
  

3.7、包机制，JavaDoc

一、包机制

• 为了更好地组织类，Java提供了包机制，用于区别类名的命名空间。
• 包语句的语法格式为:
  • package pkg1[. pkg2[. pkg3...]];
• 一般利用公司域名倒置作为包名;
• 为了能够使用某一个包的成员，我们需要在Java程序中明确导入该包。使用"import”语句可完成此功能
  • import package1[.package2...].(classname|*);

二、JavaDoc

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

• 参数信息

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