2021-7-7

3.数据类型

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

弱类型语言

Java的数据类型分为两大类

基本类型

数值类型

整数类型

byte：1个字节

short：2个字节

int：4个字节

long：8个字节

浮点类型

float：4个字节

double：8个字节

字符类型

char：2个字节

boolean类型：占1位且只有true和false

int num1=10;//最常用
       byte num2=20;
       short num3=30;
       long num4=40L;//long类型要子啊数字后加L
       //小数：浮点数
       float num5=50.1F;
       double num6=1.314;
       //字符类型
       char name='A';
       char name1='中';
       //字符串,String不是关键字，是一个类
       String name2="张涛";
       //bool值，是非
       boolean flag=true;
       boolean flag1=false;

引用类型

类

接口

数组

字节：计算机中数据处理的基本单位，习惯上用大写B表示

位：是计算机内部数据存储的最小单位，11001100是一个八位二进制数

1B（byte，字节）==8bit（位）

字符：指计算机中使用的字母，数字，字和符号

表示位表示一个字节

类型拓展

//整数拓展：     进制     二进制     十进制     八进制     十六进制
       int i=10;
       int i1=010;//八进制8
       int i2=0x10;//十六进制16
       System.out.println(i);
       System.out.println(i1);
       System.out.println(i2);
       //==================================
       //浮点数拓展     银行业务？钱
       //BigDecimol   数学工具类
       //==================================
       //float     有限 离散 舍入误差   大约 接近打不等于1
       //double
       //最好完全使用浮点数进行比较
       //最好完全使用浮点数进行比较
       //最好完全使用浮点数进行比较
​
       float f=0.1f;
       double d=1.0/10;
       System.out.println(f);
       System.out.println(d);
       System.out.println(f==d);//false,不一样
​
       float d1=222222222222166541321f;
       float d2=d1+1;
       System.out.println(d1);
       System.out.println(d2);
       System.out.println(d1==d2);//true
​
       //==================================
       //字符拓展
       //==================================
       char c1='z';
       char c2='中';
       System.out.println(c1);
       System.out.println((int)(c1));//强制转换
       System.out.println(c2);
       System.out.println((int)(c2));//强制转换
​
       char c3=100;//转换
       System.out.println(c3);
       //所有的字符本质还是数字
       //编码   Unicode表     2字节     65536   Excel   2 16 =65536
       //97=a 122=z
       //转义字符
       // \t   制表符
       // \n   换行
       System.out.println("Hello\tWorld");
       System.out.println("Hello\nWorld");
       //
       String sa=new String("Hello world");
       String sb=new String("Hello world");
       System.out.println(sa==sb);//false
​
       String sc="Hello World";
       String sd="Hello World";
       System.out.println(sc==sd);//true
       //对象   从内存分析
       //布尔值拓展
       boolean flag=true;
       if(flag){
           System.out.println("zt");
      }
       if(flag==true){
           System.out.println("handsome");
      }
       //less is More 代码要精简易读

 

4.类型转换

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

运算中，不同类型的数据先转换成同一类型数据再运算

int i=128;
       byte b=(byte)i;
       //强制转换 （类型）变量名     高----低
       double b1=i;
       //自动转换 低---------高
       System.out.println(i);//输出128
       System.out.println(b);//输出-128,byte最大值为127
       System.out.println(b1);
       /*
       * 注意点：
       * 1.不能对布尔值进行转换
       * 2.不能把对象类型转换为不相干的类型
       * 3.在把高容量转换到低容量时，强制转换
       * 4.在转换的时候可能存在内存溢出，或者精度问题
       */
       System.out.println((int)23.7);
       System.out.println((int)-45.789);
       System.out.println("------------------------");
       char c='a';
       int d=c+1;
       System.out.println(d);
       System.out.println((char)d);

  //操作比较大的数时，注意溢出问题
       //JDK7新特性，数字之间可以用下划线分割
       int money=10_000_000_00;
       int year=20;
       int total =money*year;//-1474836480
       System.out.println(total);
       long total1=money*year;//默认是int，转换之前已经出现问题了？
       System.out.println(total1);//-1474836480
       long total2=money*((long)year);//20000000000
       System.out.println(total2);
​
       // L   l   分清大小写

5.变量，常量

变量：可以变换的量

java是一种强类型语言，每个变量都必须声明类型

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

type varName=[=value] [{,varName=[=value]}];
//数据类型变量名=值；
//可以使用逗号隔开来声明多个类型变量

变量作用域

类变量

实例变量

局部变量

public class Varible{
   static int allClick=0;//类变量
   String str="hello world";//实例变量
   public void method(){
       int i=0;//局部变量
  }
}

//类变量   static
   static double salary=15000;
​
   //属性:变量
​
   //实例变量：从属于对象；如果不进行初始化，这个类型的默认值 0 0.0
   //布尔值：默认false
   //除了基本类型，其余默认null
   String name;
   int age;
   //main方法
   public static void main(String[] args) {
       //局部变量:必须声明和初始化值
       int i=10;
       System.out.println(i);
​
       //变量类型 变量名字=new Demo06();
       Demo06 demo06=new Demo06();
       System.out.println(demo06.age);
       System.out.println(demo06.name);
​
       //类变量   static
       System.out.println(salary);
  }
   //其他方法
   public void add(){
       int i=0;//局部变量
  }
}

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

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

final 常量名=值;
final double PI=3.14;

常量名一般是用大写字符

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

变量的命名规范

1. 所有变量，方法，类名：见名知意

   1. 类成员变量：首字母小写和驼峰原则：monthSalary；除了第一个单词以外后面的单词首字母大写：lastName，firstName

2. 局部变量：首字母小写和驼峰原则

3. 常量：大写字母和下划线：MAX_VALUE

4. 类名：首字母大写和驼峰原则：Man，GoodMan

5. 方法名：首字母小写和驼峰原则run(),runRun()

注意事项

• 每个变量都必须有类型，类型可以是基本类型，也可以是引用类型

• 变量名必须是合法的标识符

• 标量声明是一条完整的语句，因此每个生命都必须以分号结束

6.运算符

		//二元运算符
        //CTTRL+D复制当前行到下一行
        int a=10;
        int b=20;
        int c=20;
        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=1654654165416541L;
        int b=123;
        short c=10;
        byte d=8;
        System.out.println(a+b+c+d);//long	1654654165416682
        System.out.println(b+c+d);//int	141
        System.out.println(c+d);//int	18
        System.out.println((double)c+d);//double	18.0

 		//关系运算符返回的结果;   正确：错误   布尔值
        int a=10;
        int b=20;
        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);	2

      	//  ++  --  自增，自减   一元运算符
        int a=3;
        int b=a++;
        System.out.println(a);	4
        int c=++a;
        System.out.println(a);	5
        System.out.println(b);	3
        System.out.println(c);	5
            
        //幂运算   2^3     2*2*2
        double pow=Math.pow(2,3);
        System.out.println(pow);    8.0

逻辑运算符

		//与  或   非
        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);	4

位运算

	System.out.println(2<<3);	//16

		int a=10;
        int b=20;

        a+=b;//a=a+b
        a-=b;//a=a-b
        System.out.println(a);//    10
        //字符串连接运算   +   String
        System.out.println(a+b+"");//运算 30
        System.out.println(""+a+b);//拼接 1020
        //三元运算符
        //x?y :z
        //若果x==true，则结果为y，否则为z
        int score=80;
        String type=score<60?"不及格":"及格";
        System.out.println(type);// 及格

7.7.包机制，JavaDoc

包机制：用于区别命名空间，包的本质就是文件夹

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

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

import  packag1[.package2...],(classname *);

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

参数信息

1. @author作者名
2. @version版本号
3. @since 指明需要最早使用的jdk版本
4. @param参数名
5. @return返回值情况
6. @throw异常抛出情况

javadoc -encoding UTF-8 -charset UTF-8 test.java