whoway

# Java核心基础-总结

<font style="background:yellow">
<font style="background:pink">
<font style="background: MediumSpringGreen">
1
2
3

# 目录

[TOC]

# JAVA的配置方法（配合学堂在线）

# 2.配置「环境变量」

1.找到环境变量设置入口

win+R打开cmd

输入sysdm.cpl

image-20221021165727081

  • 2/点击环境变量
  • 3、 在“系统环境变量”中点击“新建”

image-20221021165811196

  • 4/\1. 这么填写（变量名最好这么写，变量值是==前面复制==的那个）
    • 变量名，最好是JAVA_HOME
  • 5/ 然后双击“系统变量”中的“path”

image-20221021165900897

  • 6.然后在它的最前面写上：

image-20221021165917633

    1. 这样就配置完成了

# 1-3.Java基础

# ⭐️1.2.如何理解JAVA中的包和类？

为了便于对硬盘上的文件进行管理，通常会将文件分目录存放。

同理，在程序开发中，也需要将编码的类在项目中分目录存放，以便于文件管理。

为此，Java引入了**包(package)**机制，程序可以通过声明包的方式对Java类分目录管理。

Java中的包是专门用来存放目录的，通常功能相同的类存放在同一个包中。

包通过package关键字声明，示例代码如下：

  • 需要注意的是，包的声明只能位于Java源文件的第一行。
package cn.itcast.chapter01; 	//使用package关键字声明包
public class Example01{...}
1
2

Java 允许使用包（ package > 将类组织起来。借助于包可以方便地组织自己的代码，并将 自己的代码与别人提供的代码库分开管理

标准的 Java 类库分布在多个包中，包括 java.lang、java.util 和java.net 等。标准的 Java 包具有一个层次结构。如同硬盘的目录嵌套一样，也可以使用嵌套层次组织包。所有标准的 Java 包都处于java 和 javax 包层次中。

使用包的主要原因是确保类名的唯一性。假如两个程序员不约而同地建立了 Employee 类。只要将这些类放置在不同的包中， 就不会产生冲突。事实上，为了保证包名的绝对 唯一性， Sun 公司建议将公司的因特网域名（这显然是独一无二的） 以逆序的形式作为包 名，并且对于不同的项目使用不同的子包。例如， horstmann.com 是本书作者之一注册的域 名。逆序形式为 com.horstmann。这个包还可以被进一步地划分成子包， 如 com.horstmann.corejava

//举例如下，嵌入式比赛的时候
import com.verisilicon.vsbleclient.proxy.ProxyManager;

//公司域名verisilicon.com
1
2
3
4

从编译器的角度来看， 嵌套的包之间没有任何关系。例如，java.util包与java.util.jar 包 毫无关系。每一个都拥有独立的类集合。

# ⭐️1.3.类的导入

一个类可以使用所属包中的所有类， 以及其他包中的公有类（ public class。) 我们可以 采用两种方式访问另一个包中的公有类。

（不建议）第一种方式是在每个类名之前添加完整的包名。 例如：

java.tiie.LocalDate today = java.tine.Local Date.now();
1

这显然很繁琐。更简单且更常用的方式是使用 import 语句。import 语句是一种引用包含 在包中的类的简明描述。一旦使用了 import 语句，在使用类时，就不必写出包的全名了。

可以使用 import 语句导人一个特定的类或者整个包。import 语句应该位于源文件的顶部 (但位于 package 语句的后面)。例如， 可以使用下面这条语句导人 java.util 包中所有的类。

 import java.util.*; //注意，是*号
1

然后， 就可以使用

LocalDate today = Local Date.now()；
1

而无须在前面加上包前缀。还可以导人一个包中的特定类：

import java.time.LocalDate;
1
  • 易错

但是， 需要注意的是， 只能使用星号（*) 导入一个包， 而不能使用import java.* 或 import java.*.*导入以 java 为前缀的所有包。

# ⭐️1.4.同时使用同名class的情况

在大多数情况下， 只导入所需的包， 并不必过多地理睬它们。 但在发生命名冲突的时 候，就不能不注意包的名字了。

例如，java.util 和 java.sql 包都有日期（ Date) 类。

如果在程 序中导入了这两个包： import java.util .*;

import java.sql .*; 在程序使用 Date 类的时候， 就会出现一个编译错误：

Date today; // Error java.util .Date or java.sql .Date?
1

此时编译器无法确定程序使用的是哪一个 Date 类。可以采用增加一个特定的 import 语句来 解决这个问题：

import java.util .*; 
import java.sql .*; 
import java.util .Date;
1
2
3

==如果这两个 Date 类都需要使用，又该怎么办呢？==

答案是，在每个类名的前面加上完整的包名。

java.util.Date deadline = new java.util.Date();
java.sql.Date today = new java.sql.Date(...);
1
2

在包中定位类是编译器 （ compiler) 的工作。 类文件中的字节码肯定使用完整的包名来引用其他类。

# 1.5.C++的理解

C++ 程序员经常将 import 与 #include 弄混。 实际上， 这两者之间并没有共同 之处。在 C++ 中，必须使用 include 将外部特性的声明加栽进来，这是因为 C++ 编译器 无法查看任何文件的内部，除了正在编译的文件以及在头文件中明确包含的文件。Java 编译器可以查看其他文件的内部，只要告诉它到哪里去查看就可以了

在 Java 中， 通过显式地给出包名， 如java.util.Date， 就可以不使用 import ; 而在
C++ 中， 无法避免使用 include 指令
    
Import 语句的唯一的好处是简捷。 可以使用简短的名字而不是完整的包名来引用一个类。例如， 在 import java.util.* (或 import java.util.Date) 语句之后， 可以仅仅用 Date
引用 java.util.Date 类。
1
2
3
4
5

在 C++中， 与 包 机 制 类 似 的 是 命 名 空 间（namespace)。 在 Java 中， package 与 import 语句类似于 C++中的 namespace 和 using 指令。

# 4.对象与类⭐️(入门核心章节)

# ⭐️4.7.2.静态导入

import 语句不仅可以导入类，还增加了导人静态方法和静态域的功能

例如，如果在源文件的顶部， 添加一条指令：

import static java.lang.System.*;
1

就可以使用 System 类的静态方法和静态域，而不必加类名前缀：

out.println("Goodbye, World!"); //i.e., System.out
exit(0); //i.e., System.exit
1
2

另外，还可以导入特定的方法或域：

import static java.lang.System.out;
1

实际上，是否有更多的程序员采用 System.out 或 System.exit 的简写形式，似乎是一件值得怀疑的事情。这种编写形式不利于代码的清晰度。不过，

sqrt(pow(x, 2) + pow(y, 2))
看起来比
Math.sqrt(Math.pow(x, 2) + Math.pow(y, 2))
1
2
3

清晰得多。

# ⭐️4.7.3 将类放入包中

要想将一个类放入包中， 就必须将包的名字放在源文件的开头，包中定义类的代码之 前。例如，

# 程序清单 4-7

中的文件 Employee.java 开头是这样的：

package com.horstiann.corejava;
public class Employee
{
    ..
}
1
2
3
4
5

如果没有在源文件中放置 package 语句， 这个源文件中的类就被放置在一个默认包 ( defaulf package ) 中。默认包是一个没有名字的包。在此之前，我们定义的所有类都在默认 包中。

将包中的文件放到与完整的包名匹配的子目录中。例如，com.horstmann.corejava 包 中的所有源文件应该被放置在子目录 com/horstmann/corejava ( Windows 中 com\horstmann\ corejava) 中。编译器将类文件也放在相同的目录结构中。

程序清单 4-6 和程序清单 4-7中的程序分放在两个包中： PackageTest 类放置在默认包中； Employee 类放置在 com.horstmann.corejava 包中。因此， Employee.java 文件必须包含在子目录 com/horstmann/ corejava 中。换句话说， 目录结构如下所示：

image-20220722172809129

要想编译这个程序， 只需改变基目录，并运行命令

javac PackageTest.java
1

编译器就会自动地查找文件 com/horstmann/corejava/Employee.java 并进行编译

下面看一个更加实际的例子。在这里不使用默认包， 而是将类分别放在不同的包中 ( com. horstmann.corejava 和 com.mycompany) 0

image-20220722173044723

在这种情况下，仍然要从基目录编译和运行类，即包含 com 目录：

javac com/myconipany/Payrol1App.java
java com.mycompany.PayrollApp
1
2

需要注意，

  • 编译器对文件 （带有文件分隔符和扩展名 .java 的文件）进行操作。
  • 而 Java 解释器加载类（带有 . 分隔符 )。

从下一章开始， 我们将对源代码使用包。这样一来，就可以为各章建立一个IDE 工程， 而不是各小节分别建立工程

# 坑：编译器在编译源文件的时候不检查目录结构

例如，假定有一个源文件开头有下 列语句：

package con.myconpany;
1

即使这个源文件没有在子目录 com/mycompany 下， 也可以进行编译。

如果它不依赖于其他包， 就不会出现编译错误。

但是， 最终的程序将无法运行， 除非先将所有类文件移到正确的位置上。 如果包与目录不匹配， 虚拟机就找不到类.

import com.horstmann.corejava.*;
// the Employee class is defined in that package

import static java.lang.System.*;

/**
* This program demonstrates the use of packages ,
* ©version 1.11 2004-02-19
* ©author Cay Horstmann
*/
public class PackageTest
{
public static void main(String口 args)
{
// because of the import statement, we don't have to use
// com.horstmann. corejava.Employee here
	Employee harry = new Employee ("Harry Hacker" , 50000, 1989, 10, 1);

	harry.raiseSalary(5);

// because of the static import statement, we don't have to use System.out here
	out.println("name=" + harry.getName() + " ,salary=" + harry.getSal aryO；)
}
}
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