JAVASE _1

JAVASE _1

七月 20, 2022

C语言 贴近硬件，运行快，效率高 操作系统，编译器，数据库，网络系统 【非常严格】 指针和内存管理

1982 C++ 【非常复杂的特性】【需要非常多的底层知识】 面向对象 兼容C 图形领域，游戏

JAVA 语法像C 没有指针 没有内存管理 真正的可移植性，到处运行（） 面向对象 类型安全 高质量类库 层叫 C++ –

JAVA初生

图形界面程序 Applet

Java 2 桌面 J2SE

Java 2移动版 J2ME 占领手机

Java 2服务器 J2EE

构建工具：Ant,Mavern,Jekins

应用服务器：Tomcat,Jetty,Jboss,Websphere,weblogic

Web开发：Struts,Spring,Hibernate,myBatis

开发工具：Eclipse,Netbean,intellij ideam,JbUILDER

2006： Hadoop

2008: Android

JAVA特性和优势

简单性

面向对象

可移植性

高性能

分布式

动态性 反射机制

多线程

安全性

健壮性 通过捕获异常来解决异常

【心态】：去学习的过程中爱上它，这样才能主动学习

JAVA的成功：实力 + 运气 找到了互联网发展的节奏

JAVA三大版本

Write Once \Run Anywhere （虚拟机）

JavaSE：标准版 （桌面程序，控制台开发）

JavaME: 嵌入式开发 （手机，小家电） 【冷门】

JavaEE: E企业级开发 （web端，服务器开发）

JDK包含 JRE 全称：Java Development Kit [工具]

JRE 全称 ： Java Runtime Environment [运行]

JVM: 全称 JAVA Virtual Machine [虚拟机]

通过虚拟机屏蔽了底层数据的差别

JAVA SE API 【接口】

JAVA开发环境搭建

  • JDK下载与安装
  • JDK 卸载 ：

​ 1.删除JAVA安装目录

​ 2.删除变量 （电脑属性，环境变量，path）

​ 3.java -version

  • 安装JAVA

    1. 搞到安装包

    2. 设置JAVA_HOME

    3. 设置path变量

    4. (%表示引用)

  • 测试 java -version

  • src.zip 中有java源码

  • lib为库

  • include为C的头文件目录

我的JAVA对世界的第一声呐喊

1
2
3
4
5
 java public class Hello {  //类名
	public static void main(String[]args){  //方法
		System.out.print("Hello,World!");
	}
}

源码如上

承接上文 在搞完了之后爷就遇到了+编码问题

所幸在之前的RWmod开发中早已经遇到过类似的，便直接上网求证，很快解决了。

原因为txt的UFT-8中是带ROM的，而 javac是无法识别带ROM 的UFT-8

只好安装了一个Notepad++，将编码修改后，便可以正常运行了。

唔，以后池沼开发一个自己的编译器，这个用着真不舒服。。

解决问题的网址

https://blog.csdn.net/White_Idiot/article/details/54670243

同时学到了一条新命令

javac -encoding “UTF-8” FirstSample.java

通过指定编码的方式运行javac

注意事项

  • 大小写问题
  • 中英文问题

使用IDEA开发环境

新建方法 -新建类 - 快捷键 (待补充)

JAVA基本语法

  1. 注释、标识符
  2. 数据类型
  3. 类型转换
  4. 变量、常量
  5. 运算符
  6. 包机制、JavaDoc

IDEA的项目设置五大类

  • Project 项目

    |name | SDK | Language level | Compiler output ps:

    1
    名称	  |   工具   |   语言等级 		  |   输出文件夹

​ 输出文件夹 ps: Used for modules subdirectories, Production and Test directories for the corresponding sources.

​ 翻译：用于相应源的模块子目录、生产目录和测试目录。

  • Modules 模块

    Name: 模块的名称 Add Content Root（添加新的内容根）

    Sources | Paths | Dependencies

    源 | 路径 | 依赖关系

Sources ： Language level

文件夹标记

Mark as: Sources \blue\ Tests \green\ Resources\资源\ Test Resources\测试资源\ Excluded\排除\

Paths : Compiler Output （编译器输出）：Inherit project compile output path(和项目输出路径相同)

​ ：Use module compile output path （使用模块编译输出路径）

JavaDoc：Manage external JavaDocs attached to this module, External JavaDoc override Javadoc override Java DOc annotations you might have in your module.（管理附加到此模块的外部JavaDoc，外部JavaDoc覆盖模块中可能有的JavaDoc注释。）

  • Libraries 图书馆

​ Nothing to show（没啥可展示的）

​ 右侧 Select a library to view or edit its details here (在此处选择要查看或编辑其详细信息的库)

  • Facets 面

    No facets are configured(没有配置的面)

    Detection (检查)

    右侧 ：Enable framework detection（启用检测框架）

    ​ Exclude from detection(排除在检测外)

  • Artifacts

即编译后的Java类，Web资源等的整合，用以测试、部署等工作。再白话一点，就是说某个module要如何打包，例如war exploded、war、jar、ear等等这种打包形式。某个module有了 Artifacts 就可以部署到应用服务器中了。

注释

// 单行注释

/* */ 多行注释

关键字

| abstract | assert | bollean | break | byte | | :——: | ——- | ——- | ——- | —– | | case | catch | char | calss | conse | | continue | default | do | double | else | | enum | extends | final | finally | float | | for | goto |if|implements|import| | instanceof |int|interface|long|native| | new |package|private|protected|public| | return|strictfp|short|static|super| | switch|synchronized|this|throw|throws| | transient|try|void|volatile|while|

1
2
3
4
5
6
7
8
9
10
11
public class calss1 {
    public static void main(String[] args) {
        String qwq ="233"; //qwq为标识符，以小写字母开头
        String QAQ = "233";//大写字母
        String $qwq = "233";//美元符号
        String _QWQ = "233";//下划线
        String 傻逼 = "233";//中文命名
    }
}

//标识符是大小写敏感得

JAVA 数据类型

JAVA为强类型语言

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

    弱类型就反之了（例：VB，JS ）

JAVA的数据类型分为两大类

  • 基本类型 primitive type

    1. 整数类型: byte1个字节范围 short 2个字节范围 int 四个字节范围 long 8个字节范围
    2. 浮点类型 ： float 占四个字符范围 double 占8个字符范围
    3. 字符类型： char 占两个字节
    4. boolean类型：占1位，只有true 和 false

  • 引用类型 reference type ：类、接口、数组

变量需要初始化 = 变量需要定义

int 和 String 都是类型

int 整数 String 字符串

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
import java.sql.SQLOutput;

public class calss2 {
    public static void main(String[] args) {
        // 整数扩展： 进制 二进制 八进制 十六进制
        int i = 10; //
        int i2 = 010; // 八进制
        int i3 = 0x10; //十六进制 0x开头

        System.out.println(i);
        System.out.println(i2);
        System.out.println(i3);
        System.out.println("-------------------------------------------");
        //-------------------------------------------
        //浮点数扩展： 有限 离散 舍入误差 大约 接近但不等于
        //最好减少使用浮点数进行表示和比较 ，由于浮点数字长有限所以有误差得
        //float（浮点数）
        float f =0.1f; //0.1
        double d= 1.0/10; //0.1
        System.out.println(f==d);
        //字符扩展
        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 2字节 65 =A
        // U0000 UFFFF 为Unicode编码格式
        char c3 ='\u0061';  //一个Unicode字符进行转换
        System.out.println(c3);
        //转义字符 \t 制表符
        // \n 换行
        // 更多转义字符待查
        System.out.println("-------------------------------------------");
        String sa = new String("Hello");
        String sb = new String("Hello");
        System.out.println(sa==sb);//判断相等 “==” //判断为不相等

        String sc = "Hello";
        String sd = "Hello";
        System.out.println(sc==sd); //识别为相等
        //对象
        //布尔值扩展
        boolean flag = true;
        if (flag==true) {}
        if (flag){}   //默认是等于true
        } //Less is more! 代码精简易读


    }
}

字节

位（bit）

字节（byte）

1B = 8BIT

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

电脑32位和64位的区别，寻指的能力，可以装的内存不同，

类型转换

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

    低 ——————————————>高

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

    • 运算中，不同类型的数据先转换为同一类型，然后进行运算。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public class calss3 {
    public static void main(String[] args) {
        int i =128;
        byte b = (byte)i;//强制转换 byet最大值为127 ，所以内存溢出了。输出值变成了-128 //高-->低
        //自动转换  低--高
        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
        char c ='a';
        int d = c+1;//转换成了int形式，低向高自动转换
        System.out.println(d);
        System.out.println((char)d);//强制转换为字符，输出为b
    }

1
2
3
4
5
6
7
8
9
10
11
12
public class class4 {
    public static void main(String[] args) {
        //操作比较大的数的时候，注意溢出问题
        //JDK7新特性，数字直接可以用下划线分割
        int money = 10_0000_000;
        int years = 20;
        int total = money*years; // 输出后返回的为数字，计算的时候溢出了
        long total2 = money*years;//默认为Int，转换之前已经存在问题了，所以无用
        long total3 = money*((long)years);//先把一个数转换为long，则整个表达式提升，全部用Long计算，则不会内存溢出，就没事了。
        System.out.println(tota3);
    }
}

变量

变量定义：可以把变化的量。

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

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

变量划分内存的空间

  • 作用域：

    • 类变量
    • 实例变量

  • 局部变量

  • 格式 

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
      type varname	[=value] [{,varName[=value]];
      //数据类型  变量名 =值；可以用逗号隔开来声明多个同类型变量。
                                 //ps：老师不建议在一行里定义多个值，会看起来比较复杂。 

    ```java
    public class class5 {
        public static void main(String[] args) {
            //int a,b,c; //定义a b c 为int类型
           //int a=1,b=2,c=3; //定义a,b,c三个的量，但是程序可读性不好
            int a=1;
            int b=2;
            int c=3; //单独定义可读性会好
            String name ="23333"; //定义一个name为字符串
            char x = 'X'; //定义x为一个字符
            double pi =3.4; //定义pi为一个数字
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
public class class08 {
    static double salary = 2500;//加前期变量都加static，这个static定义了一个变量

    //实例变量：从属于对象，如果不自行初始化，这个类型的默认值则为0 或0.0；所以14行输出了一个0
    //字符串初始化为16位的0000....，布尔值默认为false
    //除了以上的基本类型，其他的初始值都为null
    String name; //变量在类里
    int age;
    //属性：变量
    //main 方法
    public static void main(String[] args) {

        int i=10;//定义一个i为局部变量，只能在此处使用，且初始化值。
        System.out.println();
       // 变量类型 变量名字 = new class08 ,相当于把自己拿到了。
        class08 class08 =new class08();
        System.out.println(class08);//输出class08@1b6d3586
        System.out.println(class08.age);//输出0
        System.out.println(class08.name);//输出null
    }
    //其他方法
    public void add(){

    }
}

  • 常量 （Constant）:初始化 （initialize）后不能再改变值！不会编队的值。
  • 所谓常量是一种特殊的变量，它的值被设定后，在程序运行过程中不允许被改变。

格式： ps:常量名一般使用大写字符

1
final 变量名 值;
1
2
3
4
5
6
7
8
public class class09 {
    //修饰符，不存在先后顺序 指final static double PI ,,等号之前的这些东西(但是谁=谁要定义好了)。
    final static double PI = 3.14; //定义了一个静态的常量PI

    public static void main(String[] args) {

    }
}

变量的命名规范

  • 所有变量、方法、类名：见名知意。
  • 类成员变量：首字母小写和驼峰原则：monthSalary 除了第一个单词以外，后面的单词首字母大写
    • 例 lastname lastName
  • 局部变量：首字母小写和驼峰原则
  • 常量：大写字母和下划线：MAX_VALUE
  • 类名：首字母大写和驼峰原则：Man,GoodMan
  • 方法名：首字母小写和驼峰原则：run(),runRun()

运算符

JAVA语言支持如下运算符：

  • 算数运算符：+,-,*,/,%（取余=模运算）,++,–
  • 赋值运算符： =
  • 关系运算符：>,<,>=,<=,==（相等）,!=（不等于），instanceof
  • 逻辑运算符：&&,||,! （与，或，如果是真则为假，如果是假则为真）
  • 位运算符：&，|,^，~,>>,<<,>>>(了解！！！）
  • 条件运算符？：
  • 扩展赋值运算符：+=，-=，*=，/=

IDEA创建包和MOVE

点击src 右键 new —> Package

此时弹出一个窗

Move : 项目名

To directory: 路径

Search in comments and strings （在字符串中搜索）

Search for text occurrences （所属出现的文本） //这两位默认勾选暂时不管

Open in editor（在编辑器中打开（也叫开放编辑）） //此处勾选即可 

                                                         Refactor     Preview     Cancel

一次移动多个文件会出现 Refactoring Preview（重构预览）

点击 Do Refactor 即可 ps:原来这tm是个报错

1
2
3
4
5
6
7
8
9
10
11
12
13
14
package base2;

public class class2 {
    public static void main(String[] args) {
        long a= 12312345623156415L;
        int b =123;
        short c = 10;
        byte d = 8;
        System.out.println(a+b+c+d);//有一个数字类型为long则结果类型也为long，如果没有long则结果都为int，（待求证的理解）默认类型为int类型，加入其他类型后，加什么则跟什么，那么同时加了俩会怎么样呢?
      //  System.out.println((String) (c+d)); //触发报错：incovertible tpyes cannot cast 'int' to 'java.lang.String'
                                                    //无法将 int 类型转换为 String类型
    }
}

自增

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
package base2;

public class class4 {
    public static void main(String[] args) {
        //++ -- 自增，自减  一元运算符
        int a = 3; //定义a为3
        int b =a++; //就是 a给自己加个1 （a+1）
        System.out.println(a);//这个回合自增了一下//输出4 因为此时的a已经加了个1
        System.out.println(b); //输出3  也就是说b的值就是a的值，但b的值不是a++的值，a++仅是为了给a再次赋值，让a加1
        int c =++a; //自增后给c赋值 这个才是赋值回合
        System.out.println(a);//这个回合再次自增 输出5，c在原先a++的基础上，再次++a
        System.out.println(b);//输出3
        System.out.println(c);//输出5   ps: ++是自增，b = a++ b=a=3 和a++这个a的自增是没有关系的，只是++刚好在b=a这个赋值的时候
        System.out.println(c);//输出5   ps： 而 c =++a 将++放在了前面，则就是c = 再次自增的a
        //话不多说测试一波
        int f = ++c; //那么这个f 按照我的理解，f等于 自增后的c，那么输出应该等于6。测试一波
        System.out.println(f); //输出为6 ，没有问题
        //接着测试一波，g = f ++ ，按照我的理解，g = 6 ,f 在这条语句后变成了7
        int g = f++;
        System.out.println(g);
        System.out.println(f);//over 没有问题~~~
         //幂运算 //这些运算可以使用工具【类】来进行操作，java中有很多的类
        double pow = Math.pow(2,3);//Math类提供了很多的科学计算和常数捏
        System.out.println(pow);
    }
}

逻辑

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
package base2;
//逻辑运算符
public class class5 {
    public static void main(String[] args) {
        // 与（and） 或（or） 非（取反）
        boolean a =true;
        boolean b =false;
        System.out.println("a %% b ："+(a&&b));//逻辑与运算：两个变量都为真，结果才为真，因为只有a是真所以输出假
        System.out.println(" a || b："+(a||b));//逻辑或运算：两个变量有一个为真则结果为真，因为有一个a是真所以结果是真
        System.out.println("!(a && b：)"+!(a&&b));//如果是真，则变为家，如果是假则变为真，因为只有a是真，所以应该输出假，但是取反，输出真
        //短路运算
        int c = 5;
        boolean d = (c<4)&&(c++<4);
        System.out.println(d);//这里输出了假，由于短路运算，在检测到假后后面的就不去考虑了，所以c++并没有运行，c的值还是4
        System.out.println(c);//这里c仍然是5

        //字符串的连接
        System.out.println("23333"+"woc666");//字符串在输出中可以用加号连接捏
    }
}

位运算符

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
package base2;

public class class6 {
    public static void main(String[] args) {
        /*
        A = 0011 1100
        B = 0000 1101
        A&B = 0000 1100 //两个都是1 才能得1（和相乘差不多）
        A|B = 0011 1101 //只要一个为1，则就是1 1|0=1酱紫得
        A^B = 0011 0001 //两个位置，相同则为0，否则则为1
        ~B  = 1111 0010 //取反，就是反过来啦~

        面试题：2*8 怎么运算最快？
        拆分到 2*2*2*2 正常运算需要电路，这个只需要增量（hhh记下来）
        << 左移  相当于乘2
        >> 右移  相当于除2  （算法中效率贼高~~~）

        0000 0000 0
        0000 0001 1
        0000 0010 2
        0000 0011 3
        0000 0100 4
        0000 1000 8
        0001 0000 16




         */

    }
}

扩展运算符（偷懒计算(bushi)）

1
2
3
4
5
6
7
8
9
10
11
12
13
package base2;

public class class7 {
    public static void main(String[] args) {
        int a = 10;
        int b = 10;
        a+=b; //a+=的意思就是a= a+b
        a-=b; // 意思为a = a-b
        //字符串连接
        System.out.println(""+a+b);//如果字符串连接符出现了前面，则后面所有的都会转换为String类型
        System.out.println(a+b+"");//正常运算，因为字符串连接符在后面
    }
}

三元运算符

1
2
3
4
5
6
7
8
9
10
11
12
package base2;

public class class8 {
    public static void main(String[] args) {
        // x ? y : z
        // 意思为 如果 x==true,则结果为y,否则结果为z
        int score =80;
        String type = score <60 ? "不及格":"及格";
        System.out.println(type);
    }
}

ps :为了方便代码的使用和理解多打括号（）

包机制

  • 为了更好的组织类，JAVA提供了包机制，用于区别类名的命名空间。
  • 包语句的语法格式为：
1
package pkg1[. pkg2[. pkg3...]];
  • 一般利用公司域名倒置作为包铭；例：com.baidu.www
  • IDEA创建包会帮忙写好所属的包名：package xxxx;
  • import xxxx.xxx.xx;使用包

快捷键 Alt + 回车 （生成错误信息） 然后自动找包~~爱了爱了~

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package base2;

import java.util.Date;//这玩意必须在package的下面
                        //import xx.xx.xx就是路径，导入包，也可以导入自己的源码~~

public class class8 {
    public static void main(String[] args) {
        // x ? y : z
        // 意思为 如果 x==true,则结果为y,否则结果为z
        int score =80;
        String type = score <60 ? "不及格":"及格";
        System.out.println(type);

    }
}

骚操作 import xx.xx.xx.* 会将第四个包下的所有类全导入进来捏

Java Doc

  • 作用：生成自己的API文档

  • 参数信息：

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

  • 官方帮助文档得地址捏：docs.oracle.com/javase

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
package base2;

/**
 * @author allure
 * @version 1.0
 * @since 1.8
 */

public class doc {
    String name;

    /**   //** +回车就星了
     *
     * @param name
     * @return
     */



    public String test(String name){
        return name;
    }
}

关于DIEA右键的翻译

Find Usages | 搜索用法 Analyze |分析 Refactor |重新构建 —— Bookmarks |书签 —— Browse type Hierarchy|浏览类型层次结构 Reformat Code |格式化代码 Optimize Imports |优化包引用 Delete |删除 Override File Type |覆盖文件类型 —— Build Module |构建模块 —— Open in Right Split |从右边打开 Open in |打开

—— Local History |历史记录 Repair IDE |修复IDE Reload from Disk |从磁盘重新加载 —— Compare With |与…比较 Compart File with Editor |将文件与编辑器比较 —— Diagrams |图表 —— Convert java File to Kotlin File|将Java文件转换为Kotlin文件

javadoc的CMD命令

javadoc -encoding UFT-8 -charset UTF-8 xx.java

​ -编码 参数 -字符 参数 xxx.java

使用IDEA生成javadoc

  1. 点击上方的Tool
  2. 点击Generate JavaDoc
  3. Out put directory: 则是生成的文档的路径捏
  4. 设置各项参数 Loacale:填写zh_CN可以指定以中文格式生成捏
  5. Other command line arguments: 输出配置 就是cmd javadoc 后面写的那些了~~呐呐

JAVA流程控制

  1. 用户交互Scanner
  2. 顺序结构
  3. 选择结构
  4. 循环结构
  5. Break & continue
  6. 练习

  • Scanner 对象

  • 通过Java给我们提供的工具类，我们可以获取用户的输入。java.util.Sacnner 是Java5的新特征，我们可以通过Scanner类来获取用户的输入。

  • 基本语法：

1
Scanner s = new Scanner(System.in);
  • 通过Scanner类的next()与nextLine()方法获取输入的字符串，在读取前我们一般需要使用 hasNext()与hasNextLine()判断是否还有输入的数据。

next接收

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
package scanner;

import java.util.Scanner;

public class class1 {
    public static void main(String[] args) {
        //创建一个扫描器对象，用于接收键盘数据
      Scanner scanner = new Scanner(System.in); //接收用户的输入 并封装成scanner对象
        System.out.println("使用next方式接收：");
        ///判断用户有没有输入字符串
        if (scanner.hasNext()) {//默认这个里面为判断==true
            //使用next的方式接收
            String str = scanner.next(); //程序等待用户输入完毕
            System.out.println("用户输入的内容为" + str);
        }
        //凡是始于IO流的类如果不关闭会一直占用资源，要养成好习惯用完就关掉。
        scanner.close();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
package scanner;

import java.util.Scanner;

public class calss2 {
    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();//关闭程序的语句

    }
}

  • next()

    1. 一定要读取到有效字符后才可以结束输出
    2. 对输入有效值字符之前遇到的恐怖，next()方法会自动将其去掉。
    3. 只有输入有效字符后才将其后面输入的恐怖作为分隔符或者结束符。
    4. next() 不能得到带有空格的字符串。

  • nextLine()

    1. 以Enter为结束符，也就说nextLine（）方法是返回输入回车之前的所有字符。
    2. 可以获得空白。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
package scanner;

import java.util.Scanner;

public class calss3 {
    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();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
package scanner;

import javax.security.sasl.SaslClient;
import java.util.Scanner;

public class class4 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        //从键盘接收数据
        int i = 0;
        float f = 0.0f;
        System.out.println("请输入整数：");
        if (scanner.hasNextInt()){
           i = scanner.nextInt();
            System.out.println("整数数据："+i);}else { //检测i是不是int类型，如果返回为false就走了else，如果不是就继续向下走
            System.out.println("输入的不是整数数据");
        }
        System.out.println("请输入小数：");
        if (scanner.hasNextFloat()){
            f = scanner.nextFloat();
            System.out.println("小数数据："+f);}else { //检测i是不是float类型，如果返回为false就走了else，如果不是就继续向下走
            System.out.println("输入的不是小数数据");
        }
    }
}
  1. 1. 注释
  2. 2. 关键字
  • JAVA 数据类型
    1. 1. JAVA为强类型语言
      1. 1.1. JAVA的数据类型分为两大类
      2. 1.2. 字节
    2. 2. 类型转换
    3. 3. 变量
    4. 4. 变量的命名规范
    5. 5. 运算符
      1. 5.1. JAVA语言支持如下运算符：
  • IDEA创建包和MOVE
  • 自增
  • 逻辑
  • 位运算符
  • 扩展运算符（偷懒计算(bushi)）
  • 三元运算符
  • 包机制
  • 快捷键 Alt + 回车 （生成错误信息） 然后自动找包~~爱了爱了~
    1. 0.1. 骚操作 import xx.xx.xx.* 会将第四个包下的所有类全导入进来捏
  • Java Doc
  • javadoc的CMD命令
  • 使用IDEA生成javadoc
  • JAVA流程控制
    1. 1. next接收