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对世界的第一声呐喊

 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基本语法

注释、标识符
数据类型
类型转换
变量、常量
运算符
包机制、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

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 字符串

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
- 运算中，不同类型的数据先转换为同一类型，然后进行运算。

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
    }

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变量是程序中最基本的存储单元，其要素包括变量名变量类型和作用域。

变量划分内存的空间

作用域：
- 类变量
- 实例变量
局部变量

格式

  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为一个数字
    }
}

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 变量名值;

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是个报错

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类型
    }
}

自增

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);
    }
}

逻辑

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");//字符串在输出中可以用加号连接捏
    }
}

位运算符

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)）

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+"");//正常运算，因为字符串连接符在后面
    }
}

三元运算符

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 + 回车（生成错误信息）然后自动找包~~爱了爱了~

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

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右键的翻译

javadoc的CMD命令

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

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

使用IDEA生成javadoc

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

JAVA流程控制

用户交互Scanner
顺序结构
选择结构
循环结构
Break & continue
练习

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

1	Scanner s = new Scanner(System.in);

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

next接收

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();
    }
}

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. 可以获得空白。

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();
    }
}

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("输入的不是小数数据");
        }
    }
}

本文作者 Allureluoli

文字版权归作者所有，转载请注明出处；商业用途请先联系二月。

CC BY-NC-ND 4.0 原文链接 ↗

评论COMMENTS

查看评论 · 基于 GitHub Issues

注释

关键字