进收藏夹吃灰系列Java基础快速扫盲

倡议看完目录后扔进收藏夹吃灰，须要用的时候再翻出来。（手动狗头）

本文次要包含 Java 入门的一些常识，包含 JDK 环境装置，罕用语法以及面向对象编程等。

【目录构造】

Java 根底 1，Java 语言的特点 2，配置开发环境 3，经典 HelloWorld3.1 命令行运行 Java 程序 3.2 应用 IDEA 运行 Java 程序 4，数据类型 & 变量 4.1 为什么要设计不同品种的数据类型？4.2 数据变量 & 类型的定义 4.3 根本数据类型 4.4 主动类型转换 & 强制类型转换 4.5 包装类面向对象 1，灵魂拷问，什么是面向对象？2，如何实现面向对象？——封装，继承，多态 2.1 封装 2.2 继承 2.3 多态 3，关键字盘点 3.1 static3.2 final

基于 JVM 的跨平台语言
具备垃圾回收机制
生态弱小

JDK 版本多样，次要包含 Oracle JDK 和 OpenJDK

反对国产的话能够思考阿里的 dragonwell：https://cn.aliyun.com/product/dragonwell

【win10 装置 JDK 的罕用步骤】

jdk8 下载地址：

https://www.oracle.com/technetwork/java/javase/downloads/jdk8-downloads-2133151.html

【下载的这个安装包次要蕴含 JDK，JRE，JavaFx 包】（JavaFX 次要用于桌面端开发）

设置 jdk 装置门路

设置 jre 装置门路

设置环境变量
- 找到 jdk 装置的 bin 目录，复制装置门路

![1566378270545](https://img2020.cnblogs.com/blog/1401585/202007/1401585-20200714114815730-1502938281.png)

*   右键电脑抉择属性
    
    ![1566378337808](https://img2020.cnblogs.com/blog/1401585/202007/1401585-20200714114815475-1056133413.png)

增加刚刚复制的门路到 path 里：

点击三个确定。

查看是否装置胜利
java -version

java

javac

新建文件，命名为 HelloWorld.java
用记事本关上，输出

public class HelloWorld {

public static void main(String[] args) {
System.out.println(“Hello World!”);
}
}
关上命令行，定位到 HelloWorld.java 所在位置
javac HelloWorld.java // 编译

java HelloWorld // 运行

装置 IDEA
https://www.jetbrains.com/idea/
配置 JDK

创立 Java 程序
输入 HelloWorld

package com.company;

public class Main {

public static void main(String[] args) {
System.out.println(“Hello World!”);
}
}

运行程序

以后果为导向来剖析：Java 的整数类型分为 4 种：byte，short，int，long。四种的区别在于占用的存储空间不一样。

byte 占用 1 个字节，short 占用 2 个字节，int 占用 4 个字节，而 long 占用 8 个字节。

1 字节等于 8 位而八位能够示意数 -128 – 127。这是 byte 类型的示意范畴。那如果想用计算机计算 1000 加上 1000，byte 显著是不可用的。因为 byte 示意不了 1000 这个数值。

而 short 类型的存储空间为 2 个字节，也就是 16 位。对于 short 数据类型来说，能示意多大的数呢？依据 8 位的示意范畴推算：

-2^15 = 2^15-1 -32768–32767

以此类推，int 为 4 个字节，long 为 8 个字节，能示意的数更大。

Java 通过定义变量的类型来规定变量的内存空间大小，通过阶梯式的定义，既有满足小数值运行的 byte 类型，也有反对大数值运算的 long 类型。这样不仅满足运算的最大反对（long），同时也能节俭零碎内存资源（byte）。

【总结】

数据类型的辨别是一种零碎资源分配优化的计划。

【字节和位的关系】

字节是一种存储单位的度量。1 个字节等于 8 位。

位能够了解为计算机的最小单位：0 或者是 1。也就是是说 1 个字节是 8 个 0 和 1 的排列组合：

比如说：00000000,00000001,00000011,……11111111。

【实践上 1 个字节能够示意多大的数呢？】

在无符号位的状况下：
00000000 转换为十进制仍然是 0,11111111 转换为十进制是 255。

转换工具：https://tool.lu/hexconvert/

也就是说，一个字节最大能够示意 255 而最小 1 能够示意 0。
在有符号位的状况下：
如果 8 位示意负数和正数，那么 8 位能够示意的范畴是多大呢？

通常状况下，用第一位来示意正负【0 为正，1 为负】，这样算下来 8 位能够示意的范畴是 -127 到 +127。

【实际上 1 个字节能够示意多大的数呢？补码退场】

上述引入符号位的 8 位二进制数能够了解为原码。对于负数来说，原码就是补码，而对于正数来说，符号位不变，其余原码按位取反加 1 所得即为补码。

为什么须要补码？

补码的呈现使得加减法只有加法，简化了计算构造，进步运算速度。（减法变成了加一个正数）

【为什么 8 位二进制数补码示意的范畴是 -128-127？】

无符号位原码：0000 0000 – 1111 1111 示意范畴 0 – 255

有符号位原码：1111 1111 – 0111 1111 示意范畴 -127 – 127

补码：符号位不变，在原码的根底上按位取反加 1，实践上最大的数 0111 1111 = 127，最小的数 1111 1111 = -127

然而非凡状况：原码 0000 0000 实践上示意负数，也就是 +0，原码 1000 0000 实践上示意正数，变为补码后去掉最高为也是 0000 0000。

[+0]原码 =0000 0000，[-0]原码 =1000 0000
[+0]反码 =0000 0000，[-0]反码 =1111 1111
[+0]补码 =0000 0000，[-0]补码 =0000 0000

+ 0 的补码和 - 0 的补码都是 0000 0000。但 8 位二进制数的补码能够示意 2^8 也就是 256 个数 1 -127，-1-（-127）一共数 254 个数。

所以计算机将补码 -0（1000 000）非凡设为 -128。这个数没有原码和反码。

（就是多了一个示意的数，计算机就非凡解决了）

变量是内存中的一个存储区域。而数据类型的定义决定了这块存储区域的大小。

比方 int x；其中 x 变量在内存中占有肯定空间，而 int 决定这个空间是 4 个字节。

【对于变量的形容】

变量是内存中的一个存储区域。【程序运行的时候，变量是放在内存里的】
存储区域的数据能够在同一类型范畴里一直变动【所以叫变量，就是能变嘛】
变量包含：例如【int x = 3】变量类型 int 变量名 x 变量的值 3
变量必须先申明后应用
int x = 10; (√)

x = 10; (×)

申明：变量必须得先指定具体的数据类型能力应用。

4 类 8 种：4 种整数型，2 种浮点型，1 种字符型，一种布尔型

byte

1 字节

默认值

short

2 字节

int

4 字节

long

8 字节

float

4 字节

double

8 字节

char

2 字节

‘u000’

boolean

4 字节

false

主动类型转换：由示意范畴小的主动转换为示意范畴大的。

强制类型转换：反向转换

包装类是 Java 设计之初提出的，次要解决根本数据类型无奈面对对象编程的问题。

装箱：根本数据类型 to 包装类

拆箱：包装类 to 根本数据类型

//int 与 Integer 之间的转换
int x = 5;
Integer y = new Integer(x);
System.out.println(“int 转换为 Integer,y=”+y);

int z = y.intValue();
System.out.println(“Integer 转换为 int,z=”+z);

System.out.println(“=======================”);

//Integer 与 String 转换
String s1 = “666”;
Integer i1 = Integer.parseInt(s1);
System.out.println(“String 转换为 Integer，i1=”+i1);

String s2 = i1.toString();
System.out.println(“Integer 转换为 String，s2=”+s2);

System.out.println(“=======================”);

//int 与 String 转换
int xx = 2;
String ss1 = String.valueOf(xx);
System.out.println(“int 转换为 String，ss1=”+ss1);

int yy = Integer.parseInt(ss1);
System.out.println(“String 转换为 int,yy=”+yy);

System.out.println(“=======================”);

//JDK1.5 后 Java 采取主动装箱和主动拆箱性能
// 主动装箱，编译器执行了 Integer x1 = Integer.valueOf(x)
Integer x1 = x;
System.out.println(“ 主动装箱，x1=”+x1);

// 主动拆箱，编译器执行了 int y1 = y.intValue()
int y1 = y;
System.out.println(“ 主动拆箱，y1=”+y1);

百度的解释：

面向对象 (Object Oriented) 是软件开发办法。面向对象的概念和利用已超过了程序设计和软件开发，扩大到如数据库系统、交互式界面、利用构造、利用平台、分布式系统、网络管理构造、CAD 技术、人工智能等畛域。面向对象是一种对事实世界了解和形象的办法，是计算机编程技术倒退到肯定阶段后的产物。面向对象是绝对于面向过程来讲的，面向对象办法，把相干的数据和办法组织为一个整体来对待，从更高的档次来进行零碎建模，更贴近事物的天然运行模式。

网上有一个活泼的例子来阐明面向对象的特点：

我要用洗衣机洗衣服，只须要按一下开关和洗涤模式就能够了。有必要理解洗衣机内部的构造吗？有必要碰电动机吗？有必要理解如何通电的吗？

这是一个很“实在”的例子，没有人会为了应用洗衣机去学一下电学的组成原理，但咱们却不便使用者洗衣机，手机，电脑等各种各样的事物却并不理解它们的原理。这是坏事还是好事？洗衣机能够洗脏衣服，手机能够和亲朋好友打电话，电脑能够帮忙咱们不便的解决难以解决的各种问题。但这个世界上并不是没有人不懂洗衣机的原理，手机的制作，电脑的组装。咱们不懂其内部结构却失常的应用着这些设施，并不是单纯科技的提高，而是人类对于事物的解决思路产生了变动，究其基本是为了更高的效率！设计手机的人兴许用着他人制作的洗衣机，敲着键盘的人是另一个畛域的创造者，社会分工明确，整体效率极大晋升，你只需专一一项，就可取得所有的便当。

回到面向对象的问题上来，什么是面向对象呢？

集体认为：如果摒弃软件开发的领域，这是一种通过明确社会分工而提高效率的办法。在软件开发的范畴内，就是通过形象出零碎性能而实现最大化代码复用的开发模式。

面向对象的延长：

面向对象是软件开发的名词，但其中蕴含的是这个世界的倒退法则。

比方，住房子不肯定本人建，也能够买；吃饭不肯定本人做，也能够进来吃或者叫外卖；至于洗衣机，电脑冰箱这些更不必提了。你只须要做好本人的事，剩下的，交给其他人就好了。

在软件开发的领域内，除了编写代码上使用了面向对象的思维，应用第三方框架等同样是面向对象的延长，从底层的操作系统，JVM 虚拟机，包含 Java 语言，咱们并不需要从新再创造一遍，站在伟人的肩膀上，咱们能做的事更多。

什么是封装？
外围：通过暗藏实现，裸露接口，一来实现代码解耦，二来通过拜访修饰符保障数据安全。
如何保障数据安全
比如说设置年龄，能够在 set 中加个 if 强制不能超过 30 岁。（同理，不能为空等等能够保障数据安全）

public void setAge(int age) {
if(age>=30){
this.age=18;
}else{
this.age = age;
}
}

参考这位女司机豪横：https://zhuanlan.zhihu.com/p/37853346

外围目标：实现代码复用。

继承规定
- 子类具备父类非 private 的属性和办法
- 子类能够扩大本人的属性和办法
结构器会被继承吗？
- 结构器是不会被子类继承的，但子类的对象在初始化时会默认调用父类的无参结构器。
  子类会继承父类的数据，所以必须要看父类是如何对数据进行初始化的；故子类在进行对象初始化时，会先调用父类的构造函数。
当父类显式写了有参结构器，且没有无参结构器。子类继承父类的时候必须 显式的调用父类的有参结构器。调用的形式能够应用 super(a,b)来调用。
子类，父类初始化程序
准则：动态优于非动态，父类优于子类

– 父类动态变量，动态语句块
– 子类动态变量，动态语句块

– 父类非动态代码块，结构器
– 子类非动态代码块，结构器

class Base {
// 1. 父类动态代码块
static {
System.out.println(“Base static block!”);
}
// 3. 父类非动态代码块
{
System.out.println(“Base block”);
}
// 4. 父类结构器
public Base() {
System.out.println(“Base constructor!”);
}
}

public class Derived extends Base {
// 2. 子类动态代码块
static{
System.out.println(“Derived static block!”);
}
// 5. 子类非动态代码块
{
System.out.println(“Derived block!”);
}
// 6. 子类结构器
public Derived() {
System.out.println(“Derived constructor!”);
}
public static void main(String[] args) {
new Derived();
}
}

Base static block!
Derived static block!
Base block
Base constructor!
Derived block!
Derived constructor!
继承之父——Object 类

Object 类是所有 Java 类的根父类，如果在类的申明中未应用 extends 关键字指明其父类，则默认父类为 java.lang.Object 类（任何类都能够调用 Object 的办法）

【Object 的次要组成】
- public native int hashCode(); 获得 hash 码
  hash 码是依据肯定的规定将与对象相干的信息（比方对象的存储地址，对象的字段等）映射成一个数值，这个数值称作为散列值。次要作用是为了配合基于散列的汇合一起失常运行，这样的散列汇合包含 HashSet、HashMap 以及 HashTable。
  
  当汇合要增加新的对象时，先调用这个对象的 hashCode 办法，失去对应的 hashcode 值，如果 table 中没有该 hashcode 值，它就能够间接存进去，不必再进行任何比拟了；如果存在该 hashcode 值，就调用它的 equals 办法与新元素进行比拟，雷同的话就不存了，不雷同就散列其它的地址。
- equals（Object obj）比拟对象
- clone（）可用于简单对象的深拷贝

什么是多态？
一类事物的多种体现状态。（比方手机有各种各样的品牌，但都属于手机这一类事物）
多态的体现形式：重载，重写
办法重载：同一个类中，办法名雷同，参数或者参数的个数不同

办法重写：类产生了继承关系，子类重写父类办法（办法名，参数，返回类型必须与父类统一）
向上转型
将子类对象转化为父类对象，目标：调用父类的公共办法

规定：能够拜访父类独有的办法和子类重写父类的办法，无法访问子类扩大的办法

[如果有 100 个类继承了同一个父类，父类的办法能够被这 100 个类应用，相比于在子类中一一定义，在父类中定义具备更好的代码复用性]

Father 是父类，Son 类继承自 Father。

Father f1 = new Son(); //（向上转型)

Son s1 = (Son)f1; //(向下转型，父类转换为子类)
向下转型
将父类对象转换为子类对象，目标：调用子类独有的办法（为什么不间接 new 一个子类对象？？？）

规定：能够调用父类的办法，子类重写父类的办法，子类扩大的办法

Father 是父类，Son 类继承自 Father。

Father f1 = new Son();

Son s1 = (Son)f1; //(向下转型，父类转换为子类，注：父类对象无奈间接转换为子类对象，向下转型前必须先向上转型)

static 能够润饰办法，变量，代码块，类，前两种利用更加常见。

static 润饰办法

static 润饰的办法称为 静态方法 ，也称 类办法，能够间接通过类名. 办法名间接拜访，不须要实例化对象拜访。

规定：
- 非 static 办法能够拜访 static 办法.
- static 办法不能拜访非 static 办法
static 润饰变量
static 润饰的变量称为 动态变量 ，也称 类变量 ， 全局变量，能够间接通过类名. 变量名间接拜访，不须要实例化对象拜访。
static 的继承问题
子类是不会继承父类被 static 润饰的办法和变量，然而能够调用。
static 润饰代码块

代码块的作用：对类或对象进行初始化。

动态代码块【static 润饰】
- 不能够对非动态的属性初始化。即：不能够调用非动态的属性和办法。
- 动态代码块的执行要先于非动态代码块。
- 动态代码块随着类的加载而加载，且只执行一次

非动态代码块
- 除了调用非动态的构造外，还能够调用动态的变量或办法。- 每次创建对象的时候，都会执行一次。且先于结构器执行。

final 关键字能够润饰类，办法，变量。

final 润饰类
不能被继承
final 润饰办法
办法不能被子类重写
final 润饰变量
润饰根本数据类型的变量，想当于定义了一个常量。

final int x =5;
x=6;// 报错

润饰援用类型的变量，固定栈，不固定堆，也就是援用变量的地址是不可变的，然而援用地址指向的堆中的内容是可变的。

final StringBuffer s = new StringBuffer(“hello”);
s.append(“world”);

进收藏夹吃灰系列Java基础快速扫盲

Java 根底

1，Java 语言的特点

2，配置开发环境

3，经典 HelloWorld

3.1 命令行运行 Java 程序

3.2 应用 IDEA 运行 Java 程序

4，数据类型 & 变量

4.1 为什么要设计不同品种的数据类型？

4.2 数据变量 & 类型的定义

4.3 根本数据类型

4.4 主动类型转换 & 强制类型转换

4.5 包装类

面向对象

1，灵魂拷问，什么是面向对象？

2，如何实现面向对象？——封装，继承，多态

2.1 封装

2.2 继承

2.3 多态

3，关键字盘点

3.1 static

3.2 final

Just My Socks（注册教程 内含优惠码）

Just My Socks（注册教程内含优惠码）