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 异常抛出情况

posted @ 2022-03-09 17:44 心,不伤不碎阅读(30) 评论(0) 收藏举报

刷新页面返回顶部