Java入门与实践(初入职场，工作复习)——Java基础

.G( );

已于 2022-05-03 17:10:00 修改

阅读量1.2k

点赞数 1

分类专栏： Java开发文章标签： java 开发语言 intellij idea 后端

于 2022-05-03 17:06:44 首次发布

本文链接：https://blog.csdn.net/weixin_45048331/article/details/124557329

版权

Java开发专栏收录该内容

23 篇文章 0 订阅

订阅专栏

Java基础

Java帝国的诞生

1972年c诞生
- 贴近硬件，运行极快，效率极高
- 操作系统，编译器，数据库，网络系统等
- 指针和内存管理指针：没有给越界检查，轻易犯错。内存：自己分配空间，自己释放。
- 时间浪费掉在指针和内存分配上！
1982年c++诞生
- 面向对象
- 兼容c
- 图形领域，游戏等
急需建立一个新语言
- 语法优点像c
- 没有指针
- 没有内存管理
- 真正的可移植性 # java虚拟机jvm
- 面向对象
- 类型安全
- 高质量类库
- …
Java面世——原名oak 现在叫Java
1995年的网页简单而粗糙缺乏互动性
图形界面的程（Applet）
Bill Gates 这是迄今为止设计的最好的语言！
Java 2 标准版（J2SE）去占领桌面
Java 2 移动版（J2ME）去占领手机
Java 2 企业端（J2EE）去占领服务器
大量的巨头加入

Java发展

很多商业巨头纷纷加入：
- 三高：高可用高性能高并发
- 他们基于Java开发了巨多的平台，系统，工具
- 构建工具：Ant Maven Jekins
- 应用服务器：Tomcat，Jetty，Jboss，Websphere，weblogic
- Web开发：Struts，Spring，Hibernate，myBatis
- 开发工具：Eclipse，Netbean，intellij idea，Jbuilder
- 2006 Hadoop（大数据领域）
- 2008 Android （手机端）

JAVA特性和优势

简单性（简单易学，免费使用）
面向对象
可以移植性 ——Write Once, Run Anywher！
高性能
分布式
动态性反射机制，
多线程
安全性
健壮性

JAVA三大版本

Write Once, Run Anywhere——JVM（Java虚拟机，可以跨平台！）
JavaSE（Java Platform Standard Edition）：标准版（桌面程序，控制台开发…）
JavaME（Java Platform Micro Edition）：嵌入式开发（手机，小家电）现在基本死掉了
JavaEE（Java Platform Enterprise Edition）：企业版，企业级开发，（web端，服务器开发…）

JDK JRE JVM

JDK: Java Development Kit ｜Java 开发者工具：包括所有东西JRE、JVM等一些开发工具
JRE：Java Runtime Environment ｜Java 运行环境：包含Java虚拟机(JVM)、Applet
JVM：JAVA Virtual Machine | Java虚拟机
java

Hello Wolrd

随便新建一个文件夹，用来存放代码：
新建一个Java文件，文件后缀名为.java
例：Hello.java

【注意点】：系统可能没有显示文件后缀名，我们需要手动打开

编写程序

public class Hello{  // 定义一个类,类名是Hello要和文件名一样，我这里文件名是Hello.java
	public static void main(String[] args){  // 核心方法：主方法,程序通过main方法执行
 		System.out.println("Hello,World!");    // 输出 Hello World！
}
}

编译，命令行进入java文件目录下：javac java文件 ，会生成一个class文件（字节码文件）
运行class文件：java class文件名（不要加后缀名）

javac Hello.java
java Hello

可能遇到的情况：

每个单词的大小写不能出现问题 Java大小写敏感
尽量使用英文
文件名和类名，必须保证一致
符号使用了中文。需要是英文

Java环境运行机制

编译型 (Compile)
- 有一个负责编译的程序（编译器），把整个程序编译成机器语言让计算机使用
- 速度很快，因此多用于操作系统
- 必要时需要重新编译
- 例如：操作系统 c语言
解释型
- 执行一句，解释一句。
- 效率不高，速度不要求
- 例如：网页，服务器脚本对速度要求不高，如：js
- 现在随着硬件技术的提高，解释型的效率也提高了，和编译型速度界限变得模糊了
Java程序运行机制——先编译，后解释（.class文件才真正的去执行）

Java基本语法

创建 `IntelliJ IDEA` 项目

打开 IntelliJ IDEA 选择 New Project：
java

命名项目名，创建项目文件：（我这里创建的是一个空项目，之后加模块！）
java
等待加载完成：
java
java
创建模块：（这里再创建模块，用于区分各个不同的功能）
java
选择Java模块
java
命名模块：
java
配置Java环境:
java java

编写代码，运行环境

创建class文件：
java
我这里创建的是：Hello.java
java
文件多的时候可以创建包：
java
写包名：
java

选中几个文件进行移动时：
java
java
编写代码：

public class Hello {
    public static void main(String[] args){
        System.out.println("Hello，World！");
    }
}

运行代码：
java
结果： java
在设置里允许滑动滚轮调整字体大小：
Windows系统：File -> Setting -> Editor -> General -> Change font size with Command+Mouse Wheel in：
macOS: IntelliJ IDEA -> Preferences...-> Editor -> General -> Change font size with Command+Mouse Wheel in：

java
还可以配置字体颜色：（以注释举例）
java

注释

平时我们编写代码，代码量比较少的时候，我们还可以看懂自己写的，但是当项目结构一旦复杂起来，我们就需要注释了。
注释并不会被执行，是给我们写代码的人看的
书写注释是一个非常好的习惯
平时写代码一定要注意规范

单行注释

// 这里是单行注释

多行注释 (快捷键：`选中+Ctrl+/` 注释取消：`选中+Ctrl+/`)

/* 
多行注释，可以注释一段文字
    多行注释
    多行注释
*/

文档注释（快捷键：`/**+Enter`）

/**
*@Description 这里是描述
*@Author 这里表明作者
*/

//有趣的代码注释
/***
 *                    _ooOoo_
 *                   o8888888o
 *                   88" . "88
 *                   (| -_- |)
 *                    O\ = /O
 *                ____/`---'\____
 *              .   ' \\| |// `.
 *               / \\||| : |||// \
 *             / _||||| -:- |||||- \
 *               | | \\\ - /// | |
 *             | \_| ''\---/'' | |
 *              \ .-\__ `-` ___/-. /
 *           ___`. .' /--.--\ `. . __
 *        ."" '< `.___\_<|>_/___.' >'"".
 *       | | : `- \`.;`\ _ /`;.`/ - ` : | |
 *         \ \ `-. \_ __\ /__ _/ .-` / /
 * ======`-.____`-.___\_____/___.-`____.-'======
 *                    `=---='
 *
 * .............................................
 *          佛祖保佑             永无BUG
 */

标识符与关键字

java
Java 所有的组成部分都需要名字。类名，变量名以及方法名都被称为标识符

标识符注意点

所有的标识符，都应该以字母(A-Z或者a-z) 美元符($)或者下划线()开始
首字母之后 可以可以是字母，(A-Z 或者 a-z)，美元符（$)、下划线（_）或数字的任何字符组合
不能使用关键字作为变量名或方法名。
标识符是大小写敏感的
合法标识符举例：age、$salary、_value_、__1_value
非法标识符举例：123abc、-salary、#abc
可以使用中文命名，但是一般不建议这样去使用，也不建议使用拼音，很Low。

数据类型

强类型语言

要求变量的使用要 严格符合规定，所有变量都必须 先定义 后才能使用。因此安全性高，但是速度慢。

弱类型语言

要求变量的使用符合规定即可，所有变量都必须先定义后才能使用。因此安全性高，但是速度慢。

public static void main(){
		String a = "hello";  //必须按数字类型定义
		int num = 10;
		System.out.println(a);
		System.out.println(num);
}

Java的数据类型，分为两大类

基本类型：（primitive type）
引用类型：（refreence type）

public class Demo2{
  //八大基本数据类型  快捷键查看类：command或ctrl + 点击
  //整数
	int num1 = 10; //最常用
	byte num2 = 20;
	short num3 = 30;
	long num4 = 30L; //long类型要在最后加L
	
	//浮点数 （小数）
	float num5 = 50.1F; //float类型要在数字最后加F
	double num6 = 3.1415926;
  
  //字符类型
  char name = '中';
  //字符串，String不是关键字，是类
  //String name = "hello"
    
  //boolean 布尔值：是,非
  boolean flag = true;
  boolean flag2 = false;
  
}

字节

位（bit）：是计算机内部数据储存的最小单位 ，11001100是一个八位二进制数
字节（byte）：是计算机中数据处理的基本单位，习惯上用大写B来表示，
1B（byte，字节） = 8bit（位）
字符：是指计算机中使用的字母，数字，字和符号（例：'a'，'A'，'中'，'国'）
1bit 表示1位
1byte表示一个字节 1B = 8b
1024B = 1KB
1024KB = 1MB
1024MB = 1GB
1024GB = 1TB

拓展

public class Demo2 {
    public static void main(String[] args){
        //数据拓展 进制 二进制：0b开头  十进制  八进制：0开头  十六进制:0x开头
        int i = 10;
        int i2 = 010;  // 八进制：0开头   逢8进1
        int i3 = 0x10; // 十六进制:0x开头  逢16进1   0~9 A~F

        System.out.println(i);
        System.out.println(i2);
        System.out.println(i3);
        System.out.println("===================================");

        //==========================================
        //浮点数拓展  央行业务怎么表示
        float f = 0.1f;    //0.1
        double d = 1.0/10; //0.1
        System.out.println(f);
        System.out.println(d);
        System.out.println(f==d);

        float f1 = 212121212F;
        float f2 = f1 + 1;
        System.out.println(f1 == f2 );  //结果为：true 相同

        //原因：浮点数 float：是有限离散的，有舍入误差，其结果是个大约数，接近但是不等于
        //最好完全避免使用浮点数比较大小！
        //最好完全避免使用浮点数比较大小！
        //最好完全避免使用浮点数比较大小！
        //使用BigDecimal数学工具类进行银行业务

        System.out.println("===================================");
        //======================================
        //字符拓展
        char c1 = 'a';
        char c2 = '中';

        System.out.println(c1);
        System.out.println((int)c1); //强制转换
        System.out.println(c2);
        System.out.println((int)c2); //强制转换

        //所有的字符本质上还是数字
        //编码 Unicode ASCII码：a = 97,A = 65,占2字节 最多表示0～65536个字符   最早的Excel表格只有2的16次方，65536
        char c3 = '\u0061'; //定义一个Unicode编码
        System.out.println(c3); //a
        System.out.println("===================================");

        //转义字符
        // \t 制表符 tab空格
        // \n 换行符
        //......
        System.out.println("Hello\nWorld");

        System.out.println("===================================");
        
        //对象 从内存分析
        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

        System.out.println("===================================");
        
        //布尔值扩展
        boolean flag = true;
        //代码要精简易读 Less is More!
        if(flag == true){};//新手
        if (flag){};//老手
        
    }
}

类型转换

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

低 -----------------------------------------> 高 （小数优先级大于整数）
byte,short,char -> int -> long -> float -> double

运算中，不同类型的数据转化为同一类型，然后进行运算。
- 强制类型转换
- 自动类型转换

public class Demo3 {
    public static void main(String[] args){
        int i = 128;  
        //强制转换   (类型)变量名   高 -> 低
        byte b = (byte)i; //内存溢出    
        System.out.println(i); // 128
        System.out.println(b); //-128 
        
        //自动转换   低 -> 高
        double d = i
    }
}

byte范围是：-128～127
java

public class Demo3 {
    public static void main(String[] args){
        int i = 128;
        //强制转换 (类型)变量名 高 -> 低
        byte b = (byte)i;  //内存溢出
        System.out.println(i);//128
        System.out.println(b);//-128

        //自动转换   低 -> 高
        double d = i;
        System.out.println(i);//128
        System.out.println(d);//128.0

        System.out.println("=========================");
        //精度问题
        System.out.println("23.7强制转换int类型："+(int)23.7);//23
        System.out.println("-45.98f强制转换int类型："+(int)-45.89f);//-45

        System.out.println("=========================");
        char c = 'a';
        int e = c+1; //低到高，自动转换
        System.out.println(e); //98
        System.out.println((char)e);// 转换回char类型，高到低，强制转换 //b

        /*
        注意点：
        1. 不能对boolean值进行转换
        2. 不能把类型转换为不相干的类型
        3. 在把高容量转换为低容量的时候，强制转换，反之自动转换
        4. 转换的时候可能存在内存溢出或者精度问题。
         */

        System.out.println("=========================");
        //操作比较大的数的时候，注意溢出问题
        //JDK7 新特性，数字之间可以使用下划线分割
        int money = 10_0000_0000; // 不会输出下划线 _
        System.out.println(money);//1000000000

        int years = 20;
        int total = money*years; //计算的时候溢出了
        System.out.println(total); //-1474836480

        double total2 = money*years; //默认是int类型，转换之前已经出现问题了，因此就是把结果转换成long
        System.out.println(total2);
        long total3 = money*((long)years);//先把一个数转换成long
        System.out.println(total3);
        
        //因为long L 和 l 都可以 但是l容易看成1，所以建议都使用L
    }
}

变量

变量是什么：就是可以变化的量！（代表一个空间，空间里面存储的值是可以变化的。）
Java是一种强类型语言，每个变量都必须声明其类型。
Java变量是程序中最基本的存储单元，其要素包括变量名，变量类型和作用域。

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

注意事项：
- 每个变量都有类型，类型可以是基本类型，也可以是引用类型。
- 变量名必须是合法的标识符。
- 变量声明是一条完整的语句，因此每一个声明都必须以分号结束。

public class Demo4 {
    
    public static void main(String[] args){
         //int  a,b,c; //不建议
        //程序的 可读性
         int a = 1;
         int b = 2;
         int c = 3;
         String name = "name";
         char x = 'X';
         double p1 = 3.14;
         
    }
}

变量作用域

类变量
实例变量
局部变量

public class Demo5 {

    // 常量
    //public private final static 修饰符 不存在先后顺序
    static final double PI = 3.14;
    final static double PI2 = 3.14;

    //属性：变量

    // 类变量 static  与类一起出现，一起消失！
    static double salary = 2500;

    //实例变量：从属于对象，在方法外面定义
    //如果不自行初始化，这个类型的默认值：0，0.0, null(u0000)
    // 布尔值 boolean默认：false
    // 除了基本类型，其余的默认值都是null
    String str ; //实例变量
    int age;

    static int allClicks = 0;  // 类变量  static 静态的

    //main方法：主程序方法
    public static void main(String[] args){

        //常量
        System.out.println(PI);
        System.out.println(PI2);

        //局部变量 是在方法里：{}里 ：必须声明和初始化值
        int i = 10;

        //使用实例变量：变量名字 == new Demo5();
        //变量类型 Demo5
        Demo5 demo5 = new Demo5(); //建立对象
        System.out.println(demo5.age); //没有默认初始值，初始值为0
        System.out.println(demo5.str); //没有默认初始值，默认值 null

        //类变量 static
        System.out.println(salary);//可以直接输出

    }

    //其他方法
    public void method(){
        int i = 0; //局部变量
    }

}

常量

常量（Constant）:初始化（initialize）后不能再改变值！不会变动的值。
所有常量可以理解成一种特殊的变量，它的值被设定后，在程序运行过程中不允许被改变。
常量名一般使用大写字符！

变量的命名规范

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

运算符

Java 语言支持如下运算符：
- 算术运算符：+、-、*、/、%（取余）、++、--
- 赋值运算符：=
- 关系运算符：>、<、>=、<=、==（等于）、!=（不等于）、instanceof
- 逻辑运算符：&&（与）、||（或）、！（非）
- 位运算符：&、｜、^、~、>>、<<、>>>（了解即可）
- 条件运算符：？、：
- 扩展赋值运算符：+=、-=、*=、/=

package operator;

/**
 * 计算
 */
public class Demo1 {
    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/b);// 0.5 不是int类型 四舍五入 需要强转 a/(double)b

        System.out.println("=====================");
        long l1 = 1212121212;
        int i = 123;
        short s = 10;
        byte dd = 8;

        System.out.println(l1+i+s+dd); //long 只要存在long类型，结果也为long类型
        System.out.println(i+s+dd); //int 没有long类型，结果都为int
        System.out.println(s+dd);// int
        System.out.println((double)s+dd);//double 类型  只要存在double类型，结果也为double类型


        System.out.println("=====================");
        //关系运算符的结果：布尔值 正确 错误
        //多和if 一起用
        int a1 = 10;
        int a2 = 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("=====================");

        //取余 模运算
        int a3 = 21;

        System.out.println(a3%a1); // c/a =  21/10 = 2.......1

        System.out.println("=====================");
        //++ 自增 -- 自减 一元运算符

        int f = 3;
        int g = f++; // 执行完这个代码后，先给g赋值，再自增
        // f = f + 1  执行完
        System.out.println("f="+f);// 4
        System.out.println("g="+g);// 3 先给g赋值，再自增
        System.out.println("f="+f);// 4

        System.out.println("+++++++++++++++");
        f = 3;
        int h = ++f; // 执行完这个代码前，先再自增，再给h赋值
        // f = f + 1  执行完
        System.out.println("f="+f);// 4
        System.out.println("h="+h);// 4 先再自增，再给h赋值
        System.out.println("f="+f);// 4

        System.out.println(f);// 4
        System.out.println(g);// 3
        System.out.println(h);// 4

        System.out.println("=====================");
        // 幂运算  使用工具类来操作
        double pow = Math.pow(2,3);// 2^3 = 2*2*2 = 8
        System.out.println(pow);
    }
}

package operator;

/**
 * 逻辑运算
 */
public class Demo2 {
    public static  void main(String[] args){
        // 与（and） 或（or） 非（取反）
        boolean a = true;
        boolean b = false;
        System.out.println("a && b ="+(a && b)); //逻辑与运算：两个变量都为真，结果才为真true
        System.out.println("a || b ="+(a || b)); //逻辑或运算：两个变量有一个为真，结果为真true
        System.out.println("!(a && b) ="+(!(a && b)));//逻辑非运算：如果是真即为假，如果为假即为真

        //短路运算
        int c = 5;
        boolean d = (c < 4)&&(c++<4);
        System.out.println(d);
        System.out.println(c);// 5 因为(c < 4)&&(c++<4)中(c < 4)已经为false，因此不会再计算(c++<4) c依旧为5

        //位运算
        /*
        与运算：0与0 = 0   0与1，1与0 = 0  1与1 = 1
        或运算：0或0 = 0   0或1，1或0 = 1  1或1 = 1
        异或运算：相同即为0 不同即为1
        取反：0取1 1取0 取反

        A = 0011 1100
        B = 0000 1101
       ----------------------
        A&B  0000 1100
        A|B  0011 1101
        A^B  0011 0001
        ~B   1111 0010
         */

        /*
        //面试题：
        2*8 如何计算最块?
        2*8 = 16 2*2*2*2 位运算
        << 左移
        >> 右移
         */
        System.out.println("====================");
        /*
        0000 0000  0
        0000 0001  1
        0000 0010  2
        0000 0011  3
        0000 0100  4
        0000 1000  8
        0001 0000  16
        位运算效率极高
        <<  *2
        >>  /2
        */
        System.out.println(2<<3);

        System.out.println("====================");
        //
        int x = 10;
        int y = 20;

        x+= y; //x = x+y
        System.out.println(x);

        x = 10;
        y = 20;
        x-= y; //x = x-y
        System.out.println(x);

        System.out.println("====================");
        x = 10;
        y = 20;
        //字符串链接符  +
        System.out.println("——"+ x + y);// ——1020 只要+两侧有一侧是String类型，
        System.out.println(x + y +"——");// 30——  如果先+是数，则先计算后String拼接

        System.out.println("====================");
        //三元运算符  ？ ：
        // x ? y : z
        //如果x==true，则结果为y，否则结果为z

        int score = 80;
        String type1 = score < 60 ? "不及格": "及格";
        System.out.println(type1);//及格

        score = 50;
        String type2 = score < 60 ? "不及格": "及格";
        System.out.println(type2);//不及格
    }

}

运算符优先级

java

包机制 (文件夹)

为了更好的组织类，Java提供了包机制，用于区别类名的命名空间。
包语句的语法格式为：
package pkg1[.pkg2[.pkg3...]];
一般利用公司域名倒置作为包名：com.test.blog.www
为了能够使用某一个包的成员，我们需要在Java程序中明确导入该包。使用import语句可完成此功能
import package1[.package2...].(classname|*);

改变一下以上项目的存储方式：
java

// 定义包：写在所有代码的最前面
// 查看包：command/Ctrl + 点击 
package com.learn.base;
package com.learn.operator;

//导入包
//自动生成包，快捷键macOS：option+shift+Enter  Windows: Alt+Enter
import com.learn.base.Demo1 //必须在package...下面
import com.learn.* //.*通配符，导入包下所有的类

JavaDoc

Java官方文档 java

Jdk8官方文档
java

Javadoc命令是用来生成自己的API文档的
参数信息：
- @author 作者名
- @version 版本号
- @since 指明需要最早使用的jdk版本
- @param 参数名
- @return 返回值情况
- @throws 一场抛出情况

生成自己的API文档

先写好自己的注释

package com.learn.base;

/**
 * @author name 
 * @version 1.0    
 * @since 1.8   
 */
public class doc {
    String name;
    
    /**
     * 
     * @param name        //参数
     * @return            //返回值
     * @throws Exception  //异常
     */
    public String test(String name) throws Exception{
        return name;
    }
     //通过命令行生成文档： javadoc 参数 java文件
}

自动生成文档：
可以在要生成文档的的文件夹下打开命令行：(在当前doc文件下)

# encoding 编码  chartset 字符集编码 可显示中文
javadoc -encoding UTF-8 -charset UTF-8 doc.java

cmd代码：
java
代码运行后会生成很多文件：关注index.html
java
文档内容：
java

来源：狂神说

狂神说

.G( );

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录

Java入门与实践(初入职场，工作复习)——Java基础

Java基础

Java基础

Java帝国的诞生

Java发展

JAVA特性和优势

JAVA三大版本

JDK JRE JVM

Hello Wolrd

Java环境运行机制

Java基本语法

创建 IntelliJ IDEA 项目

编写代码，运行环境

注释

单行注释

多行注释 (快捷键：选中+Ctrl+/ 注释取消：选中+Ctrl+/)

文档注释 （快捷键：/**+Enter）

标识符与关键字

标识符注意点

数据类型

强类型语言

弱类型语言

Java的数据类型，分为两大类

字节

拓展

类型转换

变量

变量作用域

常量

变量的命名规范

运算符

运算符优先级

包机制 (文件夹)

JavaDoc

生成自己的API文档

来源：狂神说

创建 `IntelliJ IDEA` 项目

多行注释 (快捷键：`选中+Ctrl+/` 注释取消：`选中+Ctrl+/`)

文档注释（快捷键：`/**+Enter`）