Java基础知识

一、注释

  1. 单行注释使用 //

  2. 多行注释使用 /*

  3. JavaDoc文档注释 /**

    public class HelloWorld {
        public static void main(String[] args) {
            //单行注释
            //输出一个Hello,World!
            System.out.println("Hello,World!");
            /*
            多行注释
            哈哈哈哈
             */
            //JavaDoc文档注释 /**
            /**
             * @deprecated com.Suncx.www.com.Suncx.base.HelloWorld
             * @author Suncx
             */
            //有趣的代码注释,百度搜索
        }
    }
    

二、标识符和关键字

  • 2.1 关键字
    在这里插入图片描述

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

  • 2.2 标识符注意点:

    • 应该以字母、美元符、或者下划线开始
    • 首字符之后可以是字母、美元符、下划线、数字的任意组合
    • 标识符是大小写敏感的
    • 可以使用中文命名但不建议
    public class Demo01 {
        public static void main(String[] args) {
            String Ahello = "Suncx";
            String hello = "Suncx";
            String Hello = "Suncx"; //大小写敏感
            String $hello = "Suncx";
            String _hello = "Suncx";
            String 名字 = "孙";
            System.out.println(名字);
    
            //String class = "Suncx;
            //String 1 = "Suncx";
        }
    }
    

三、数据类型

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

Java数据类型: 基本类型(八大基本类型)、引用类型(类、接口、数组)


  • 3.1 基本类型

    public class Demo02 {
        public static void main(String[] args) {
            String a = "hello";
    
            //八大基本数据类型
            //整数
            int num = 10; //最常用
            byte num1 = 20; //范围-128-127
            short num2 = 30;
            long num4 = 30L; //long类型要在数字后加一个L
    
            //小数:浮点数
            float num5 = 50.1F; //float类型要在数字后加一个F
            double num6 = 3.1415926;
    
            //字符
            char name = '秦';
            char name1 = 'A';
            //字符串,String不是关键字,是一个类
            //String name2 = "Suncx";
    
            //布尔值
            boolean flag = true;
            boolean flag1 = false;
    
        }
    }
    
  • 3.2 数据类型拓展

    • 3.2.1 整数拓展

      public class Demo03 {
          public static void main(String[] args) {
              //整数扩展:   进制    二进制0b    十进制 八进制 十六进制
              int i = 10;
              int i2 = 010; //八进制0
              int i3 = 0x10; //十六进制0x
              int i4 = 0b10;
      
              System.out.println(i);  //10
              System.out.println(i2); //8
              System.out.println(i3); //16
              System.out.println(i4); //2
          }
      }
      
    • 3.2.2 浮点数拓展

      //浮点数拓展 银行业务怎么表示钱
      //BigDecimal 数学工具
      //======================================
      //float 有限 离散 舍入误差 大约 接近但不等于
      //double
      //最好避免使用浮点数进行比较
      public class Demo03 {
          public static void main(String[] args) {
              float f = 0.1f;
              double d = 1.0/10;
      
              System.out.println(f==d); //false
              float d1 = 232323231;
              float d2 = d1 + 1;
              System.out.println(d1==d2); //true
          }
      }
      
    • 3.2.3字符拓展

      public class Demo03 {
          public static void main(String[] args) {
              char c1 = 'a';
              char c2 = '中';
              System.out.println(c1); //a
              System.out.println((int)c1); //强制转换 97
              System.out.println(c2); //中
              System.out.println((int)c2); //强制转换 20013
              //所有的字符本质还是数字
              char c3 = '\u0061';
              System.out.println(c3); //a
      
              //转义字符
              // \t 制表符
              // \n 换行
          }
      }
      
    • 3.2.4布尔值拓展

      public class Demo03 {
          public static void main(String[] args) {
              //布尔值拓展
              boolean flag = true;
              if (flag==true){} //新手
              if (flag){} //老手 默认真
          }
      }
      
  • 3.3 类型转换

    因为Java是强类型语言所以在进行一些运算的时候需要用到类型转化

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

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

    public class Demo04 {
        public static void main(String[] args) {
            int i = 128;
            byte b = (byte)i; //高到低强制转换 小数优先级大于整数
            System.out.println(i); //128
            System.out.println(b); //-128 溢出
    
            double c = i; //低到高自动转换
            System.out.println(c); //128.0
            /*
            注意点:
            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 d = 'a';
            int f = d+1;
            System.out.println(f); //98
            System.out.println((char)f); //b
        }
    }
    

    在操作比较大的数时,要注意溢出问题,示例如下:

    public class Demo05 {
        public static void main(String[] args) {
            //操作比较大的数时 注意溢出问题
            //jdk7新特性,数字之间可以用下划线分割
            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(money); //1000000000
            System.out.println(total); //-1474836480
            System.out.println(total2); //-1474836480
            System.out.println(total3); //20000000000
        }
    }
    

四、变量、常量

  • 4.1 变量

    Java是强类型语言,每个变量都必须声明其类型

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

    每个变量都有类型,类型可以是基本类型也可以是引用类型

    public class Demo06 {
        public static void main(String[] args) {
            //int a,b,c;
            int a=1;
            int b=2;
            int c=3;
            String name ="孙";
            char x= 'x';
            double pi = 3.14;
        }
    }
    
  • 4.2 变量作用域

    • 类变量

    • 实例变量

    • 局部变量

      public class Demo08 {
          //类变量 static
          static double salary = 2500;
          //属性:变量(属性一般是基本数据类型也叫成员变量)
          
          //实例变量:从属于对象;如果不进行初始化,这个类型默认为0  0.0
          //布尔值,默认是false
          //除了基本类型,其余的默认值都是null;
          String name;
          int age;
          String str = "hello";
      
          //main方法
          public static void main(String[] args) {
              //局部变量:必须声明和初始化值
              int i =10;
              System.out.println(i); //10
      
              //变量类型 变量名 = new Demo08
              Demo08 demo08 = new Demo08();
              System.out.println(demo08.age); //0
              System.out.println(demo08.name); //null
              System.out.println(demo08.str); //hello
      
              //类变量 static
              System.out.println(salary); //2500.0
      
          }
          //其他方法
          public void add(){
              //System.out.println(i);
          }
      }
      
  • 4.3 常量

    常量:初始化后不能再改变值

    常量名一般使用大写字符

    public class Demo09 {
        //修饰符static final,不存在先后顺序
        static final double PI = 3.14;
    
        public static void main(String[] args) {
            System.out.println(PI);
        }
    }
    
  • 4.4 变量命名规则

    1. 所有变量、方法、类名:见名知意

    2. 类成员变量:首字母小写和驼峰原则:monthSalary

    3. 局部变量:首字母小写和驼峰原则

    4. 常量:大写字母和下划线 MAX_VALUE

    5. 类名:首字母大写和驼峰原则:Man

    6. 方法名:首字母小写和驼峰原则 run() runRun()


五、基本运算符

Java基本运算符:

  • 算术运算符:+,-,*,/,%,++,–
  • 赋值运算符:=
  • 关系运算符:>,<,<=,>=,==,!=,instanceof
  • 逻辑运算符:&&,||,!
  • 位运算符:&,|,^,~,>>,<<,>>>(了解)
  • 条件运算符:?:
  • 扩展赋值运算符:+=,-=,*=,/=

Java运算符优先级:

  1. 括号 ()[]
  2. 非、正、负号 !+ - ~
  3. 自增,自减 ++ –
  4. 乘、除、取余
  5. 加、减
  6. 移位运算 <<,>>,>>>
  7. 大小关系 >,<,<=,>=
  8. 相等关系 ==,!=
  9. 按位与 &
  10. 按位异或 ^
  11. 按位或 |
  12. 逻辑与 &&
  13. 逻辑或 ||
  14. 条件运算 ?:
  15. 赋值运算 =,+=,-=,*=,/=,%=

  • 实例一:

    除运算时要小心

    public class Demo01 {
        public static void main(String[] args) {
            // 二元运算符
            int a = 10;
            int b = 20;
            System.out.println(a+b);
            System.out.println(a-b);
            System.out.println(a*b);
            System.out.println(a/b);  //0 因为a和b都是int型,所以结果也是int,int(0.5)=0
            System.out.println(a/(double)b); //0.5
        }
    }
    
  • 实例二:

    public class Demo02 {
        public static void main(String[] args) {
            long a = 123412512627L;
            int b = 123;
            short c = 10;
            byte d = 8;
            double n = 3.5;
    
            // 如果有Long,结果就是Long类型
            // 如果有double,结果就是double类型
            System.out.println(a+b+c+d); //123412512768 Long
            System.out.println(b+c+d); //147 Int
            System.out.println(c+d); //18 Int
            System.out.println(n+d); //11.5 Double
        }
    }
    
  • 实例三:

    public class Demo03 {
        public static void main(String[] args) {
            //关系运算符返回结果:true false
            int a = 10;
            int b = 20;
            int c = 21;
    
            System.out.println(a>b); //false
            System.out.println(a<b); //true
            System.out.println(a==b); //false
            System.out.println(a!=b); //true
            System.out.println(c%a); //1
        }
    }
    
  • 实例四:

    public class Demo04 {
        public static void main(String[] args) {
            // ++ -- 一元运算符
            int a = 3;
            int b = a++; //先给b赋值,再进行a+1
            // a=a+1;
            // a= a+1;
            int c = ++a; //先进行a+1,再给c赋值
    
            System.out.println(a); //5
            System.out.println(b); //3
            System.out.println(c); //5
    
            //幂运算2^3,java没有^,使用一些工具类来操作
            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)); //a&&b:false
            System.out.println("a||b:"+(a||b)); //a||b:true
            System.out.println("!(a&&b)"+!(a&&b)); //!(a&&b)true
    
            System.out.println("==========================");
            // 短路运算
            int c = 5;
            boolean d = (c<4)&&(c++<4);
            System.out.println(d); //false
            System.out.println(c); // c = 5,未执行 c++
        }
    }
    
  • 实例六:

    位运算符,看代码注释

    public class Demo06 {
        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 怎么运算最快
            效率极高
            <<  左移 *2
            >>  右移 /2
             */
            System.out.println(2<<3); //16
        }
    }
    
  • 实例七:

    //三元运算符、条件运算符
    public class Demo08 {
        public static void main(String[] args) {
            // x ? y : z 如果x =true则为y,否则为z
            int score = 50;
            String type = score < 60 ? "不及格":"及格";
            System.out.println(type); //不及格
        }
    }
    
  • 实例八:

    关于字符串连接的拓展

    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("==========================");
            //字符串连接 + , String
            //""字符串在前就是连接,在后就是先加再连接
            System.out.println(""+a+b); //3020
            System.out.println(a+b+""); //50
            System.out.println("a"+a+b+"b"); //a3020b
        }
    }
    

六、包机制

Java提供包机制,用于区别类名的命名空间

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

使用某一个包的成员,需要在Java中明确导入该包,使用import语句

  • 创建 com.Suncx.www
    在这里插入图片描述
    在这里插入图片描述

  • 导入包import

    package com.Suncx.base;
    //导入这个包下所有的类
    import com.Suncx.operator.*;
    import java.util.Date;
    
    public class data {
        public static void main(String[] args) {
        }
    }
    
  • 注意:尽量不要让包中名字重复
    在这里插入图片描述


七、JavaDoc

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

文档注释

package com.Suncx.base;
//加在类上的
/**
 * @author Suncx
 * @version 1.0
 * @since 1.8
 */
public class Doc {
    String name; //属性
    //给方法加
    /**
     *
     * @param name
     * @return
     * @throws Exception
     */
    public String test(String name)throws Exception{ //方法
        return name;
    }
}
//cmd中命令行
//javadoc -encoding UTF-8 -charset UTF-8 Doc.java
  • 方法一:命令行窗口生成doc文档

    • cmd中执行
      在这里插入图片描述
      在这里插入图片描述

    • 多了很多文件
      在这里插入图片描述

    • 点开index文件

      在这里插入图片描述

  • 方法二:使用idea工具生成

    • 如图(报错未解决)

      在这里插入图片描述
      在这里插入图片描述
      在这里插入图片描述

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值