Java学习第二天

数据类型

Java、c++是一种强类型语言要求变量的使用要严格符合规定，所有变量都必须先定义后才能使用，安全性高，速度较慢

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

Java数据类型分为两大类：基本类型、引用类型

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

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

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

1B(字节,byte)=8(位)bit

1024B=1KB

1024KB=1M

1024M=1G

寻址能力（32位，64位包括32位）

类型转换

public class datatype {
    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);
        System.out.println(d);
        System.out.println(d==f);//false
        float  d1=232323231323213f;
        float d2=d1+1;

        System.out.println(d1==d2);//ture

        //===============================================
        //字符拓展
        //===============================================
        char c1='a';
        char c2='中';

        System.out.println(c1);
        System.out.println((int)c1);//强制换行
        System.out.println(c2);
        System.out.println((int)c2);//强制换行
        //所有字符的本质还是数字
        //编码 Unicode  表：(97=a 65=A) 2字节   65536   Excel  2 16=65536
        //U0000  UFFFF
        char c3='\u0061';
        System.out.println(c3);
        //转义字符
        //\t
        System.out.println("Hello\nWold");
    }
}

代码运行结果：

10
8
16
0.1
0.1
false
true
a
97
中
20013
a
Hello
Wold

类型转换：

运算中，不同类型的数据先转化为同一类型，然后再运算

低-------------------------------------------------------------高

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

import java.util.Arrays;

public class Demo05 {
    public static void main(String[] args) {
        int i=128;
        byte b=(byte)1;//内存溢出
//加了括号的为强制转换   （类型）变量名   高--低
        //自动转换      低--高
        System.out.println(i);
        System.out.println(b);

        /*注意点：
        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);
        System.out.println((char) d);



    }
}

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

        long total3=money*((long)year);
        System.out.println(total3);

        //L l

    }
}

变量、常量 和作用域

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

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

注意：

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

2.变量名必须是合法标识符。

3.变量声明是一条完整的语句，因此每一个声明都必须以分号结束。

4.不建议在一行里面定义多个值。

变量分为类变量、实例变量和局部变量

static静态的

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 0000-0000-0000-0000
    //布尔值默认是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);
        System.out.println(demo08.name);

        //类变量 static
        System.out.println(demo08.salary);

    }
    //其他方法
    public void add(){
    }
}

变量的命名规范:

1.所有变量、方法、类名：见名知意,不要用拼音用英文单词

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

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

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

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

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

尽量让自己的代码便于阅读

package base;

public class Demo09 {
    //修饰符不存在先后顺序
    //一般在程序中常量用大写字母表示
    static final double PI=3.14;

    public static void main(String[] args) {
        System.out.println(PI);
    }
}

运算符

算数运算符：+，-，*，/，%（模运算），++，--

赋值运算符=

关系运算符：>,<,>=,<=,==,!=instanceof

逻辑运算符：&&，||，！（与，或，非）

位运算符：&，|，^，~，>>，<<,>>>(了解！！！)

条件运算符？：

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

重点掌握上面四个

//算术运算符
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);
        System.out.println(a-b);
        System.out.println(a*b);
        System.out.println(a/(double)b);//强制转换类型，注意作用范围
    }
}

//赋值运算符
package operator;

public class Demo2 {
    public static void main(String[] args) {
        long a=123123123123123L;
        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
    }
}

//关系运算符
package operator;

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

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

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

    }
}

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);
        System.out.println(c);
    }
}

package operator;

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
        ~B  1111 0010

        2*8=16  2*2*2
        <<   *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);
    }
}

package operator;

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

        a+=b;//a=a+b
        a-=b;//a=a-b

        System.out.println(a);
        //字符串连接符 +,只要最先出现的是String类型，右边的类型无论是什么都会被同化为String类型
        System.out.println(a+b);
        System.out.println(" "+a+b);
        System.out.println(a+b+" ");
    }
}

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?"不及格":"及格";//必须掌握会，在开发中十分常见
        //if
        System.out.println(type);
    }
}

包机制

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

包的本质就是文件夹

一般利用公司域名倒置作为包名：www.baidu.com com.baidu.www baike

com.kuangstudy.blog.www

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

import package1[.package2...].(classname|*);

包语句的语法格式为：package pkg[.pkg2[.pkg3...]];

例子如何导入这个包下所有的类：import com.kuang.base.*;

JavaDoc

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

BAT（百度、阿里、腾讯）

参数信息：

@author作者名

@version版本号

@since指明需要最早使用的jdk版本

@param参数名

@return返回值情况

@throws异常抛出情况

package base;

/**
 * @author wusiyu
 * @version 1.0
 * @since 1.8
 */
public class Doc {
    String name;
    /**
     *
     * @poram name
     * @return
     * @throws Exception
     */
    public String test(String name) throws Exception{
        return name;
    }
    //我是通过命令行生成的 javadoc 参数 Java文件
    //作业：学会查找使用IDEA生产JavaDoc文档！  面向百度编程
    //基础部分的一切知识，后期几乎每天都会用
}

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

index.html

用户交互Scanner

java.util.Scanner是java5的新特征，我们可以通过Scanner类来获取用户的输入

基本语法：Scanner s=new Scanner(System.in);

通过Scanner类的nexy()与nextLine()方法获取输入的字符串，在读取前我们一般需要使用hasNext()与hasNextLine（）判断是否还有输入的数据。

package Scanner;

import java.util.Scanner;

public class Demo01 {
    public static void main(String[] args) {
        //创建一个扫描器对象，用于结束键盘数据
        Scanner scanner=new Scanner(System.in);

        System.out.println("使用next方式接收：");//程序等待用户输入完毕
        //怕不断用户有没有输入字符串
        if(scanner.hasNext()){
            //使用next方式接收
            String str=scanner.next();
            System.out.println("输出的内容为："+str);
        }
        //凡是属于IO流的类如果不关闭会一直占用资源，要养成好习惯用完就关掉
        scanner.close();
    }
}

输入：hello world

输出结果为hello

package Scanner;

import java.util.Scanner;

public class Deom02 {
    public static void main(String[] args) {
        //从键盘接受数据
        Scanner scanner=new Scanner(System.in);

        System.out.println("使用nextLine方式接收：");
//判断是否还有输入
        if(scanner.hasNextLine()){
            String str=scanner.nextLine();
            System.out.println("输出的内容为："+str);
        }
        scanner.close();
    }
}

输入：hello world

输出结果：hello world

注意：用完就关掉后面记得打上一句：scanner.close();

package Scanner;

import java.util.Scanner;

public class Demo03 {
    public static void main(String[] args) {
                //从键盘接受数据
                Scanner scanner=new Scanner(System.in);
                System.out.println("请输入数据：");
                    String str=scanner.nextLine();
                    System.out.println("输出的内容为："+str);
                scanner.close();
    }
}

输入：deepseek 开心

输出：deepseek 开心