嗨，又见面了，我是你的老师父，那大家前面可能遇到各种各样的问题，但是大家不要着急，可以留言大家共同来讨论，来解决，闭门造车是学不好编程的，大家要相信自己，也要相信共同学习的小伙伴，同样也要相信你的老师父，多多沟通是很重要的。

那大家看到这一篇说明大家已经很努力了，也希望大家能继续跟下去，如果有必要我可以抽时间出视频，因为工作和家庭原因，暂时实在是没精力做视频，所以大家先看文章吧！推荐大家一本书教父级别的书《Java编程思想》，这本书适合有一定编程基础的人，但是大家可以买来先看看。

上一章留了个作业，还记得不？

“你的老师父开车去买橘子”需要创建水果类、人类、交通工具类，来完成这个场景，打印出这句话来！

那我来给大家实现一下，看跟大家写的是不是一样

1、首先新建三个类：

水果、人类、交通工具类。

2、之后每个类写代码如下

水果类：

交通工具类：

人类

车和水果类比较简单，因为就一个属性和一个构造方法，属性就是车的类型和水果的名字。

那人类就比较复杂了，因为人要去开车去买水果，那首先他得有车，所以你造人的时候也就是新建对象的时候，不仅要告诉他叫什么，还得告诉他有哪辆车。

因为买橘子呢是个动作，买完才是他的，所以有个买水果的动作，需要把橘子给他，他才能有。所以这是buyFruit()这个动作。

那他说话呢，想说什么就直接System.out.println()出来就好了，代码中是让他说：谁开什么车去买什么。所以最后say的时候打印结果如下：

好了作业做完了，有问题留言评论或者私信吧！

那今天咱们讲点新东西。

一、什么是“包名”

开始之前还是得说个例子！

咱们这几天一直在造人、造人和造人，那那么多Person类，有的有名字有性别，有的又只有名字，那我是不是代码删了写，写了又删？有没有办法这个同样的Person类都存在呢？

那有人一激灵说这还不好说，多建几个类不就好了？

好，我给你试试啊，你看着：

诶？File already exists？什么意思？文件已经存在！

是的，因为你已经有了Person了啊。

那怎么办？

我问你，你在电脑上两个相同的文件放在一起是不是也是会提示是否要覆盖？那你如果不覆盖，只能改名字了。还有个方法，就是放在不同文件夹中，是不是？

那java项目中也是可以分不同文件夹的。只不过java中类的文件夹不叫文件夹，叫“包名”

英文单词：package，那package还有个意思就是打包的意思，所以你可以理解为这个文件夹，就是打了一个包裹，就跟快递包裹似的，你买了好多东西，不同商家是不同的包裹，每个包裹放的东西是不同类别的。

java中也是这个意思，包中放的基本上都是同一类的东西。比如放汽车类，有Car，有Bus，有MiniBus，有Taxi是不是

好了，说这么多，其实就是一个文件夹而已！记住在Java中叫做包。

那说说这个包怎么建？

首先命名规范：

1、不同路径通过点(.)来分割，比如下图的这个目录/cn/craaaaazy，包名的话就是cn.craaaaazy了

2、由字母、数字下划线组成，不能以数字开头

3、全部小写

4、一般使用域名反写来命名包，为了保证包名唯一性，一般是用域名反写来做包名的，比如下图：

这个就是域名反写起的包名，其实是两个文件夹，一个是cn，另外一个文件加是craaaaazy，那你去这个项目目录看，其实是两个文件夹。

注意：

一般路径会这么些E:\lib\cglib 或者这么写/root/bin

但是java这个编码工具中，是通过英文的点(.)来作为路径分隔符的比如上边两个路径如果做为java的包的话，在开发工具中会显示成lib.cglb或者root.bin

在编辑工具中有个办法把文件夹都展开，看我操作：点击这个设置按钮，把第二个选项的这个对钩去掉：

那看下边这个是不是已经展开了

这样你也可以在cn中创建类文件了。

二、那说了这么半天，怎么用呢？

相信大家都会建类了。我还是说下吧。想要把类建在哪个包中，就直接在包名上右键，然后一顿选，选New，选Java Class，后边的操作我还用说吗？就是填入类名，就确定就行了。看下图

看我一通操作，建了这么多类，当然，文章开头的例子，我是在一个我已经建好的包中写的。

那上图右边代码部分，看看注释说明。

首先代码是Person类，这个类在cn.craaaaazy这个包中。

1、package关键字：

首先第一行要写上package 你这个类的包名，当然这个编辑器很强大，自动就给创建好了。

记住这个其实是目录，但是java是通过点(.)来做分割的这是JVM编译器决定的。

例如：package cn.craaaaazy; // 注意这最后是有分号的。

2、导入类

什么是导入？

说这个问题之前先问大家，类和文件的概念大家清楚不？我给大家截个图：

看到没，右边是这个包的实际文件目录

那右边目录中的java后缀的文件，这就是咱们项目中的你看到的这些类，他们其实是文件！

打开这两个文件看看

一般文件名和类名都是一样的，就像上边的Person，那也有特殊的，比如下边这个

Test.java文件中包含两个类，Water和Tea，他们和文件名不同。注意：这两个类不能写public关键字，因为public的类必须要和文件名保持一致！

那大家应该知道文件名和类名不一定要一样，一个文件中是可以写多个类的。大家可能在想，那这跟我导入类有什么关系？

那我解释下导入的概念吧，举个例子，大家喝水用水杯喝，那如果水杯没有水，是不是喝不到？你得把水倒入水杯，水杯才有水是不是？

那如果我想喝茶呢？是不是要再把茶放进去？是的，没错。

倒入水、茶叶的过程其实跟Java的导入一样。你可以把文件看做是水杯，那类就是茶叶和水，看Test.java文件中Test.java就可以看做水杯，那Tea和Water就是茶和水。这是茶和水本身就在水杯的情况。

那如果茶和水开始并没有在水杯呢？看下图

那你怎么喝茶水？

那这个时候你就得倒进去啊？在Java中就是通过import导入的

导入其实和直接写在java文件中是一样的，编译器最后都会把他们写在一起。

那我还是用Person这个类来讲import吧。

三、导入类的三种方式

a、通过import 导入完整的类路径

在你使用比如Bus类的时候，要通过import关键字导入这个类

怎么写呢，就是这个类的完整路径，同样也是(.)分割的

比如：

import cn.craaaaazy.car.Bus; // 注意这最后也是有分号的

b、通过import 导入包路径

比如你使用了某个包的所有类，你可以这样写

import cn.craaaaazy.fruit.*;

那cn.craaaaazy.fruit是一个包名，这个包中存放了所有的水果类，如果我都要用，那我得一个一个把类导入进来（在以前没有自动导入这么强大的编辑工具的时候，工作是相当乏味的！）

那如果不一个一个导入进来就需要使用通配符了，这个通配符就是星号(*)。

这样一个是省去了很多麻烦，另外也降低了代码量。

c、通过完整路径的方式使用类

比如我使用了work包中的这个Person类，其实是没办法通过import再把Person类导入进来了，刚才讲水杯、茶叶和水的时候说来着，import导入类的过程其实和直接写在Java中是一样的，所以，你如果把work.Person导入进来，那其实就是在这个类中又写了个Person，那编译器其实是不知道你要用哪个Person的，所以，不能直接通过import导入！

那我要用怎么办？

可以在你用的时候，写上完整的类路径，比如

work.Person person = new work.Person("小名", transport);

那这样其实没有导入类就可以用了。

那基本讲完了，其实使用就是这么简单。细心一点，一定要细心，好好看我代码。不行就复制粘贴。

如果遇到问题，一定要留言评论，还是那句话，我这是给12岁以上小朋友讲的，尽最大努力讲得简单明白。所以例子会很多，但是大家也是需要细心的，因为代码这个东西，一个标点符号都会造成运行不起来，但是大家也别气馁，慢慢习惯就好了，大家只要敲上一个月代码，这些就都不是事儿了。好了，大家加油。

你好，世界！

源代码组织方式

Java程序由package+class组成，package对应目录的相对路径，class对应文件，如

E:\Workspaces\MyEclipse

10\JavaStudy\src\com\happyframework\javastudy\hello\Hello.java

关于class有如下几点规则：

文件的名字必须和class的名字一致（public级别的class名字）。文件必须只包含一个public访问基本的class（可以包含多个非public级别的class）。package名字必须和目录一致。1入口方法

App.java

2

最终的项目结构

3

数据类型

8种原子类型

整数类型：byte、short、int和long。小数类型：float和double。字符类型：char。布尔类型：bool。除此之外的是interface、class和array。

小数类型的常量默认是double类型，声明float类型的常量需要使用F作为后缀。

4

运算符

算术运算符：+、-、*、/ 和 %，两个整数相除，结果还是整数。赋值运算符：=、+=、-=、*=、/=、%=、&=、|=、~=、^=、>>=、<<= 、 <<<=、++ 和 --。比较运算符：==、!=、>、>=、< 和 <=。逻辑运算符：&&、|| 和 !。位运算符：&、|、~、^、>>、<< 和 <<<。5

字符串

String是拥有“值语义”的引用类型，字符串常量实现了“享元模式”，equals会按照内容进行比较，==按照地址比较。

为了高效的修改字符串Java引入了StringBuffer。

6

数组

声明语法

DataType[] name 或 DataType name[]。

初始化语法

DataType[] name = new DataType[length]。

DataType[] name = new DataType[] { element1, element2, ...elementn }。

DataType[] name = { element1, element2, ...elementn }。

多维数组

只有不等长多维数组DataType[][]，没有DataType[xxx, xxx]。

控制结构

条件：if-else if-else、switch-case-default和三元运算符（?:）。循环：while、do-while、for和foreach。Labeled block。

最近觉得label是个不错的东西，最起码多了一种选择。

方法

Java中所有的赋值和方法调用都是“按值“处理的，引用类型的值是对象的地址，原始类型的值是其自身。

Java支持变长方法参数。

7

类

注意：调用自身的构造方法是用this(xxx,xxx,...)来完成，且必须位于第一行。

静态成员

Java中类似静态构造方法的结构，称之为：静态初始化代码块，与之对应的是实例初始化代码块，见下例：

8

继承

继承使用 extends，抽象类和抽象方法使用abstract声明，向下转型使用 (ChildType)instance，判断是否是某个类型使用 instanceof，见下例：

9

重写

Java中的重写规则比较灵活，具体如下：

除了 private 修饰之外的所有实例方法都可以重写，不需要显式的声明。重写的方法为了显式的表达重写这一概念，使用 @Override进行注解。重写的方法可以修改访问修饰符和返回类型，只要和父类的方法兼容（访问级别更高，返回类型更具体）。可以使用final将某个方法标记为不可重写。在构造方法中使用 super(xxx, xxx)调用父类构造方法，在常规实例方法中使用 super.method(xxx, xxx)调用父类方法。Java不支持覆盖（new）。

10

包

包的名字和项目路径下的目录路径相对应，比如：项目路径为：C:\Study，有一个Java源文件位于：C：\Study\com\happyframework\study\App.java，那么App.java的包名字必须为：com.happyframework.study，且 App.java 的第一行语句必须为：package com.happyframework.study。

Java支持三种导入语法：

导入类型：import xxx.xxx.xxxClass。导入包：import xxx.xxx.xxx.*。导入静态成员：import static xxx.xxx.*。

11

访问级别

Java支持四种访问级别：public、private、protected 和 default（默认），类型和接口只能使用public 和 default，成员和嵌套类型可以使用所有，下面简单的解释一下 protected 和 default。

protected 修饰过的成员只能被自己、子类和同一个包里的（不包括子包）其他类型访问。default 修改过的类型或成员只能被自己和同一个包里的（不包括子包）其他类型访问。嵌套类

Java支持如下几种嵌套类：

nested class，定义在类型内部的类型。static nested class，使用 static 声明的 nested class，static nested class 可以访问所有外部类的静态成员。inner class，没有使用 static 声明的 nested class，inner class 可以访问所有外部类的实例成员，inner class 不能定义静态成员。代码示例

特殊的inner class：local class

除了inner class的规则之外，local class可以访问局部final变量，在Java8中有更多的改进。

特殊的local class：anonymous class

12

常量

不废话了，直接看代码：

有一点需要注意的是：只有一种情况Java的常量是编译时常量（编译器会帮你替换），其它情况都是运行时常量，这种情况是：静态类型常量且常量的值可以编译时确定。

接口

Java的接口可以包含方法签名、常量和嵌套类，见下例：

13

枚举

Java枚举是class，继承自java.lang.Enum，枚举中可以定义任何类型可以定义的内容，构造方法只能是private或package private，枚举成员会被编译器动态翻译为枚举实例常量，见下例：

调用枚举的构造方法格式是：常量名字(xxx, xxx)，如果构造方法没有参数只需要：常量名子，如：

14

异常

Java中的异常分为checked和unchecked，checked异常必须声明在方法中或被捕获，这点我觉得比较好，必定：异常也是API的一部分，见下例：

所有继承Exception的异常（除了RuntimeException和它的后代之外）都是checked异常。

15

装箱和拆箱

Java提供了原始类型对应的引用类型，在1.5之后的版本还提供了自动装箱和自动拆箱，结合最新版本的泛型，几乎可以忽略这块。

注意：自动装箱和自动拆箱是Java提供的语法糖。

16

泛型

Java的泛型是编译器提供的语法糖，官方称之为：类型参数搽除，先看一下语法，然后总结一点规律：

泛型方法

测试代码

调用泛型方法

输出的结果是

17

泛型类

测试代码

调用代码

输出结果

18

泛型接口

测试代码

调用代码

输出结果

19

类型参数约束

测试代码

调用代码

输出结果

类型搽除过程

将泛型定义中的类型参数去掉。

2.将T换成extends指定的约束类型，默认是Object。

3.如果有非泛型类型继承或实现了泛型基类或接口，而且进行了重写，根据情况，编译器会自动生成一些方法。

4.根据泛型参数的实际参数搽除调用代码。

这里说的不一定正确，特别是Java泛型的约束支持&（如：可以约束实行多个接口），不过过程估计差别不大，我没有看Java语言规范，这里只是大概的猜测。

然后今天就讲到这里啦，大家记得点赞收藏，分享转发，关注小姐姐哦！

eclipse无法解析导入 java.util是因为jre配置错误。

1、点击需要导入jar的项目，右击项目属性（properties）,进入到如下图界面：

2、选择Java Build Path选项，然后选择右边红框内的jre，之后点击【edit】,如图：

3、选择红色框内的“installed JREs...”,如下图：

配置完毕刷新一下workspace即可消除错误。

（本文内容由百度知道网友西风烈1205贡献）

前面的程序代码中，都会用到System类，来完成字符和数值的输出及输入。System是Java核心类库之一，提供了标准设备的输入与输出功能，默认情况下输出设备是计算机的显示器，输入设备是计算机键盘。System类结构如下图所示：

从图中可以看出，System类提供的成员（属性）和方法都是静态类型，静态类型的方法和成员（属性）在类被加载后就可以调用，无需实例化。图例没有全部列出System类提供的方法，有感兴趣地可以到oracle官方提供的Java API查看。Java SE7 API地址为：https://docs.oracle/javase/7/docs/api/。

System类的成员属性

System类提供了三个成员属性，分别是err、out、in。其中err和out属于PrintStream类，PrintStream类主要用于输出各种类型数据的格式化形式输出；in属于InputStream类，InputStream类主要用于程序通过不同的数据源获取输入数据，关于PrintStream类和InputStream类的详细介绍建议到oracle官方提供的Java API官网查看。

示例1：利用System. err输出程序错误信息

在D盘Java目录下，新建“SystemSample.java”文件。用记事本打开“SystemSample.java”文件，输入以下代码：

代码结构分析：程序主要完成两个整型数值相除，并输出结果到屏幕。程序在main方法体内声明了temp1、temp2、result三个整型变量，其中temp1被赋值为0，temp2被赋值为10，result用于存储结果。考虑到两个整数相除时，如果除数为0，Java程序执行时抛出异常错误（Java编译过程发现不了除数为0的错误），因此设置了try…catch…语句。try语句块的内容是正常的程序执行代码，在try语句块中，如果语句抛出了异常，那么try块后面的代码将不再执行，将直接进入catch异常处理代码块。

应用try…catch…语句增强程序的健壮性，是非常好的编码习惯，当预判程序可能会出现不可控的异常错误时，应使用try…catch…语句。通过catch语句的Exception类，可以获取程序异常错误信息。

编译“SystemSample.java”文件，在命令行窗口输入“javac SystemSample.java”并执行命令，编译通过后，在命令行窗口输入“java SystemSample”运行Java程序，命令行窗口显示如下信息：

从输出结果可以看出，程序出现了异常，导致产生异常的原因是“by zero”被零除。

System类的成员方法

System类提供了多种方法针对系统进行不同的操作。例如：exit()方法可以退出当前运行的程序，currentTimeMillis()可以获取当前系统时间，getProperty可以获取当前系统信息。

示例2：利用System. exit()退出当前运行的程序

在D盘Java目录下，新建“SystemExitSample.java”文件。用记事本打开“SystemExitSample.java”文件，输入以下代码：

代码结构分析：

“import java.util.*;”语句用于导入java.util类库中的所有类，import是java语言的关键字，应用该关键字可以导入Java核心类库及外部类文件。程序导入java.util主要是使用Scanner类从命令行窗口获取输入的命令。

程序在“SystemExitSample”类体内声明了类属性message，被赋值“退出程序请输入quit”，用于程序开始运行时，显示提示信息，提醒用户输入“quit”命令，可以退出程序。

在“main()”方法体内，首先调用System.out输出已定义的字符串变量，然后声明“Scanner”类型的sc，应用new运算符（运算符一节讲述）实例化Scanner类，并赋值给sc。最后，利用while循环语句（循环语句一节讲述），等待用户输入退出命令，获取用户输入后，判断输入的是否是“quit”命令，如果是则调用System.exit()方法退出程序。需要注意的是，exit()方法要求传入一个参数，传入的参数为0表示正常退出。

编译“SystemExitSample.java”文件，在命令行窗口输入“javac SystemExitSample.java”并执行命令，编译通过后，在命令行窗口输入“java SystemExitSample”运行Java程序，命令行窗口显示如下信息：

从上图运行情况可以看出，输入错误的命令后，程序并没有退出，而是继续提示用户“请输入退出命令”，输入正确的退出命令后，程序退出运行。

示例3：利用getProperty()方法显示当前系统信息

在D盘Java目录下，新建“SystemPropertySample.java”文件。用记事本打开“SystemPropertySample.java”文件，输入以下代码：

代码结构分析：

程序主要完成获取操作系统名称并输出到屏幕上的任务。

语句“String operationSystem = System.getProperty("os.name");”也是程序编码常用的方式，语句等号左边是变量声明部分，语句等号右边是赋值部分，赋值部分可以是表达式、也可以是单个的数值、字符串等、也可以是调用方法返回的数值或字符串等数据。需要注意的是赋值语句两边的数据类型要保持一致。getProperty方法要求传入一个字符串参数，根据传入的参数，getProperty返回不同的系统信息，传入“os.name”字符串，可以获取当前操作系统的名称。

编译“SystemPropertySample.java”文件，在命令行窗口输入“javac SystemPropertySample.java”并执行命令，编译通过后，在命令行窗口输入“java SystemPropertySample”运行Java程序，命令行窗口显示如下信息：

从上图运行情况可以看出，程序运行后，获取了正确的操作系统名称。

当程序需要通过向控制台（Windows命令行窗口或其它命令行窗口）输出信息，或通过控制台获取用户输入时，可以使用System类的out和in属性输出信息和获取输入。

（1）System类的三个主要成员属性是（）

A．err、in、sc

B．err、in、out

C．in、out、int

D．out、exit、in

（2）System类可以退出程序的方法是（）

A．console()

B．exit(int status)

C．getProperty(String key)

D．gc()

（3）下面的那条语句会出现程序异常（）

A．int num = 3+5;

B．int num = 3*5;

C．int num = 3-5;

D．int num = 3 / 0;

当程序需要从键盘获取用户输入的命令或数据时，例如：获取用户输入的计算表达式。可以通过Scanner类方便地获取用户输入。

通过Scanner类获取用户输入时，控制台会一直等待用户的输入，直到用户敲回车键结束，把所输入的内容传给Scanner，程序要从Scanner获取输入的内容，则只需要调用Scanner的nextLine()方法即可。

Scanner类的初始化

声明一个scanner变量，并用new运算符实例化Scanner，实例化Scanner时，需要传入System.in对象，Scanner通过传入的System.in获取用户输入，并对用户输入的字符进行处理，屏蔽了获取用户输入的复杂操作。

Scanner scanner = new Scanner(System.in);

示例1：Scanner类的初始化

在D盘Java目录下，新建“ScannerInitSample.java”文件。用记事本打开“ScannerInitSample.java”文件，输入以下代码：

代码结构分析

程序功能主要是演示Scanner如何声明及初始化。

语句“import java.util.*;”，用于导入包含Scanner的类库，Scanner包含在Java 核心类库util中，要使用Scanner类，必须导入java.util库，类库导入关键字为import。

编译“ScannerInitSample.java”文件，在命令行窗口输入“javac ScannerInitSample.java”并执行命令，编译通过后，在命令行窗口输入“java ScannerInitSample”运行Java程序，命令行窗口显示如下信息：

Scanner类的方法

Scanner类提供了多个方法，用于完成字符串的输入。下面列举了几个主要的操作方法，其它方法请参考Java API：

（1）方法名称：next()

方法说明：返回由输入设备输入的有效字符，返回类型为字符串。该方法一定要读取到有效字符后才能返回。

方法示例：

Scanner sc = new Scanner(System.in);

String szWelcome = sc.next();

（2）方法名称：nextLine()

方法说明：返回由输入设备输入的字符串，返回类型为字符串。该方法以用户按下回车键（Enter）结束当前输入。

方法示例：

Scanner sc = new Scanner(System.in);

String szWelcome = sc. nextLine() ;

示例2：Scanner类的输入操作

在D盘Java目录下，新建“ScannerInputSample.java”文件。用记事本打开“ScannerInputSample.java”文件，输入以下代码：

代码结构分析

程序功能主要是演示Scanner的next和nextLine输入方法的区别。

语句“import java.util.*;”，用于导入包含Scanner的类库，Scanner包含在Java 核心类库util中，要使用Scanner类，必须导入java.util库，类库导入关键字为import。

语句“String tempValue = sc.nextLine();”，通过nextLine方法获取用户输入，用户按下回车键（Enter），nextLine返回按下回车键前所有输入的字符。

语句“tempValue = sc.next();”，通过next方法获取用户输入，用户按下回车键（Enter），next返回过滤空格后的字符串。

编译“ScannerInputSample.java”文件，在命令行窗口输入“javac ScannerInputSample.java”并执行命令，编译通过后，在命令行窗口输入“java ScannerInputSample”运行Java程序，命令行窗口显示如下信息：

从上述结果可以看出，nextLine返回按下回车键前输入的所有字符，包括空格；next则返回过滤掉空格后的字符串。

Scanner仅是简化了文本的输入，Scanner通过传入的InputStream从键盘获取用户输入的字符串，然后对字符进行相应处理并返回。

编写一个程序，应用Scanner的next和nextLine方法获取用户输入的字符串，辨别两种输入方法的不同之处。

前面一节讲到面向对象的封装，封装就是把现实世界同类事物的共同特征和行为抽取出来，放到一个新建的类中，并设置类属性（特征）和行为的访问权限，同时提供外部访问类属性和行为的方法。

类是把同类事物的共同特征和行为封装在一起的结构体，事物的特征称为属性，事物的行为称为方法，类是抽象的概念集合，表示的是一个共性的产物，类中定义的是属性和方法。例如前面一节创建的Fruits类（水果类），Fruits类有属性water（汁液含量）、sugar（糖分含量）、fragrance芳香度，这些属性是水果类所具有的共同特点，汁液含量丰富、糖分含量大、有一定程度的芳香气味。Fruits类也有方法showFruit()，showFruit对外展示水果的汁液含量度、糖分含量度、芳香度，当外部需要了解水果的各种成分含量时，可以调用类的showFruit方法。

在Java中，通过关键字class来声明类，类声明语法如下：

public class 类名

{

//定义类属性部分

属性1的类型 属性1;

属性2的类型 属性2;

……

属性n的类型 属性n;

//定义方法部分

方法1：

……

方法n：

}

一个完整的Java类由类声明和类体构成，类体内容包含在{ }括号之内。

类声明为“public class 类名”，其中class是Java类定义关键字，声明Java类时，类声明需要包含class关键字。public是Java预定义的访问权限关键字，用来修饰被定义类的访问权限，当被定义类修饰为public时，其它定义的外部类就可以访问该类的内部成员和方法。类体包含了类的属性和方法。

例1：定义一个日期类。

声明的日期类有year、month、day三个属性,用来存储日期的年、月、日。另外，日期类还提供了isRunnian()和print()两个方法，isRunnian()用于判断当前日期是否是闰年，print()用于输出当前日期。

例2：定义一个Person类

声明的Person类有name、age两个属性,用来存储人的姓名、年龄。另外，Person类还提供了tell()方法，用来输出人的姓名、年龄。

声明的Person类有name、age两个属性,用来存储人的姓名、年龄。另外，Person类还提供了tell()方法，用来输出人的姓名、年龄。

如果用类的思想来描述职业信息的话，我们需要从职业这个事物中抽取共同特征和行为，并将抽取的特征和行为封装到一个类中，把这个类命名为Job, 把职业的共同特征名称、类别、技能、测评内容等作为Job的属性，把职业的评测行为作为方法，代码如下：

用eclipse创建Job类

启动eclipse，新建项目JobManager（创建项目步骤参见10.4节——用eclipse创建第一个HelloWorld项目），在JobManager项目下，创建com.milihua. job包（包的概念及创建步骤参见10.5节——理解Java包的概念）。

在“JobManager”项目列表中。选择新创建的“com.milihua. job”包项，单击鼠标右键，在弹出的菜单中选择“New”命令，再下一层菜单中选择“Class”命令，如下图所示：

系统弹出“New Java Calss”对话框中，如下图所示：

对话框的主要选项或输入项说明如下：

① Source folder

创建的类代码文件默认的存储目录，默认目录为当前项目目录下的src目录，一般情况下，该目录不要改动。

② Package

创建的类隶属于哪个包（包的概念参见10.5节——理解Java包的概念）目录，一般无需改动。

③ Name

创建的类名称，在输入框中输入“Job”。

④ Superclass

创建类的父类（类的继承后面会讲述），默认的继承父类是java.lang.Object，本案例中无需改动。

⑤ public static void main(String[] args)

该选项是指在创建新类时，是否在新类中添加main方法，main方法是Java应用程序的入口，一般包含在项目主类（例如：10.4节的HelloWorld项目的HelloWorld类）中。本案例创建的Job类不是项目的主类，因此无须选择该选项。

在Name输入框中输入类名“Job”，其它选项采用默认值即可，单击“Finish”按钮即完成Job类的创建。

■ 知识点拨

从现实世界的事物中抽取特征并归纳为类，对Java初学者或项目经验缺乏者确实有一定的难度。不过也无须担心，从现实世界的事物中抽取特征并归纳为类属于项目的需求分析阶段，是系统分析员做的事情，在实际工作中，项目涉及到的类及属性和行为在需求规格说明书和系统设计文档中已经详细给出，程序员只需按照文档要求创建项目和编写类代码就可以了。

■ 思考与练习

请参照本节内容，在eclipse中创建Job类。

课程导言

【在上节课了解了变量的作用及如何声明变量，本节课探讨Java类库以及基本的输出与输入。通过本课的学校，你将掌握如何输出内容到控制台，如何从获得用户从键盘输入的数据，并了解类库的使用方法】

在程序运行过程中，既需要输入数据，也需要输出数据。例如，求长方形面积算法要求用户输入长方形的长度和宽度值，求出面积后，将结果输出到控制台。在Java程序中，控制台是指运行Java程序的窗口。例如，在Windows命令行窗口下运行程序时，控制台是Windows命令行窗口，在集成开发工具Eclipse运行Java程序时，控制台是Eclipse提供的程序运行窗口，也称为Java console。

课程分为三个小节，第一小节介绍Java类库，Java类库为开发者提供一组程序集合，开发者可以直接使用Java类库提供的程序集合完成诸如输入输出等功能；第二小节介绍Java类库中的Sysytem类，Sysytem类提供了系统控制以及输出信息到控制台的方法；第三小节介绍Java类库中的Scanner类，Scanner类提供了从键盘等外部设备输入数据的功能。

第一小节 Java类库

类库是一组类的集合，一个类可以帮助开发者完成一些通用功能，提高开发速度和质量，这些类可以被开发者直接使用。

Java类库以包层次的方式对外提供，可以把Java包理解为文件目录层次，最外层的目录为Java，Java包含lang、util等子目录，util子目录又包含Scanner、Properties等类文件，也包含zip等子目录。

在程序中使用Java类库时，必须要把类的整个包路径通过Java语言的import语句导入到程序中。例如，如果在程序中要引入Scanner类，可以将下面的语句加在程序的开始。

import java.util.Scanner;

Java编译器默认为所有的Java程序引入了Java类库的Java.lang 包中所有的类。其中定义了一些常用类，如System、String、Object、Math等。因此我们可以直接使用这些类，而不必显式引入。但使用其他包中的类时，则必须先引入、后使用。不过，也存在一种特殊情况，可以不用导入而直接使用外部包的类，就是使用类的完全限定名称。例如，程序要使用Scanner类，如果省略了导入Scanner的语句，则需要在使用Scanner类的位置使用Java.util.Scanner。

下面是Java程序中常用的类库：

● Java.lang：包含一些Java语言的核心类库，如String、Math、Interger、System和Thread。

● Java.util：包含一些实用工具类，如定义系统特性、日期时间、日历、集合类等。

● Java.io：包含能提供多种输入输出的文件读写类。

● Java：包含执行网络相关操作的类。

● Java.sql：Java操作数据库的一些API。

● Java.text：包含了一些用来处理文本、数字和消息的类和接口。

● java.awt：用来构建和管理Java程序图形用户的界面的类。

● Javax.swing：在awt基础上构建的一套新的图形界面类。

第二小节 System类

System类是Java核心类库之一，提供了标准设备的输入与输出以及系统控制功能。这里说的标准设备是指计算机的显示器、键盘和鼠标，其中显示器是输出设备，键盘和鼠标是输入设备。

System类本身并不支持对设备的读（输入）写（输出）功能。不过System有三个重要的属性err、in、out，System借助这三个属性实现了对设备的读写功能。

其中，err和out用于输出信息。

err是输出错误信息的，错误信息是在程序发生错误时要输出的信息。例如，当你预测一条除法语句可能会发生被零除的错误时，就可以用err输出错误信息；再如，程序应用try—catch语句时，被catch语句捕捉到的错误，在catch语句中就可以用err输出捕捉到的错误信息。

err默认是把错误信息输出到显示器（控制台），也可以通过重定向输出到其它显示设备，也可以输出到文件，可以调用err的setErr方法进行重定向。

out用于输出程序的运行信息，运行信息包括程序对用户的提示信息、程序计算结果等信息。例如，程序提醒用户输入长方形的长度和宽度值；再如，程序计算机长方形面积值，并将计算结果输出到控制台。

out同err一样，默认把运行信息输出到控制台。也可以通过重定向输出到其它显示设备。

err和out提供了print、println、printf等方法用于输出信息，print和println的主要区别是print输出结束后，不添加换行符，下次调用print输出数据时，依然是接上次的位置输出。println输出结束后，添加换行符，下次调用print或println会另起一行输出；printf可以对信息进行格式化输出。

前面介绍了err和out，下面介绍in。

in用于输入信息。程序运行时需要从外部获取数据，数据的输入有人工输入、文件输入、机器输入等多种输入方式。人工可以通过键盘、鼠标、手写等方式输入信息到程序；文件输入是指信息存储在文件中，由程序打开文件直接读取文件内容，例如视频播放器的输入源就是视频文件，视频播放器打开视频文件，读取视频内容并实时播放；机器输入是指由机器识别外部内容，并将识别的内容输入的程序。例如，扫描仪扫描照片，并将识别的照片内容输入到扫描程序，扫描程序再把识别的照片内容存储到照片文件。

in完成从输入源获取数据的功能，in提供了统一抽象的读取方法，以适应不同的输入设备需要。支持输入设备的类需要实现in抽象的读取方法，才能从in获取数据。同时in可以扩展其输入功能，简化输入程序。例如，把in与支持文本扫描的Scanner类关联起来，就可以简化输入程序的编写，下面的语句将in和Scanner关联起来：

Scanner sc = new Scanner(System.in);

第三小节 Scanner类

当程序需要从键盘获取用户输入的命令或数据时，就需要使用到Scanner类，Scanner类是文本扫描类，用于简化输入程序的编写。例如：获取用户输入的长方形的长度和宽度时，就可以通过Scanner类方便地获取。

通过Scanner类获取用户输入时，控制台会一直等待用户的输入，直到用户敲回车键结束，把所输入的内容传给Scanner类，程序要从Scanner类获取输入的内容，则只需要调用Scanner类的nextLine()方法即可。

Scanner需要和System类in属性关联起来，可以方便获取用户从键盘的输入。Scanner通过传入的System.in获取用户输入，并对用户输入的字符进行处理，屏蔽了获取用户输入的复杂操作。

Scanner类提供了多个方法，用于获取用户的输入，主要方法有next和nextLine。next一定要读取到有效字符后才可以用回车键结束输入，对输入有效字符之前遇到的空格键、Tab键或Enter键等结束符，next会自动将其滤掉；nextLine持续接收用户输入，直至用户按下回车键，与next不同的是，nextLine不过滤空格和Tab键。

代码示例：Scanner类的输入操作

了解了类库和基本的输入与输出后，可以回到求长方形面积算法的问题了，算法的第二个步骤是输入长度和宽度，并将长度赋值给num1，宽度赋值给num2，用代码实现算法的1、2步骤：

■ 课程小结

1、Java类库是一组类的集合，包含众多的类。开发者可以直接将这些类集成到代码中，而无需再重写类似功能的代码。如输入与输出功能、文件读写功能、网络功能等。使用Java类库时，开发者需要使用import语句将类库导入到程序中，然后才能使用。Java编译器默认为所有的Java程序引入了Java类库的Java.lang 包中所有的类。其中定义了一些常用类，如System、String、Object、Math等，因此使用这些类时，无需再导入类库。

2、System类是一个非常重要的类，该类提供了标准设备的输入与输出以及系统控制功能。System类有三个非常重要的属性err、out、in，其中err和out是都是输出信息到设备，err和out的区别是err用于程序错误信息的输出，out用于程序运行信息的输出；in是从各类输入设备获取数据，in不能被直接使用，需要和支持输入设备的类关联后才能使用。

3、从键盘获取用户输入的数据时，一般使用Scanner类。Scanner类可以对System.in获取的数据进行预处理，简化开发者对输入数据的处理工作。

■ 思考与练习

1、当程序运行发生错误时，如何在程序中输出错误信息?

2、当程序需要输出相应信息给用户时，如何输出信息？

3、如何从键盘获取用户输入的数据？

概述

虚拟机把描述类的数据从Class文件加载到内存中，并对数据进行验证，准备，解析，初始化的一个过程，最终是可以被虚拟机直接使用的java类型，这即是类加载的一个简略的过程。

Java中的类加载是在运行时加载，这样会比较的消耗性能，可是恰是在运行时加载使得java具有极好的灵活性和可扩展性。

类加载的时机

类从被加载到内存中开始，到卸载出内存为止。它的生命周期总共七个阶段：加载---->验证---->准备---->解析---->初始化---->使用---->卸载。如下图所示：

类的生命周期

其间解析这个进程是不确定的，它可能会在初始化后，这是为了使java支持运行时的绑定。

·*new ，getstatic，putstatic，invokestatic这四条指令时会触发初始化的操作。

new是new一个新的对象时会触发初始化。

ogetstatic是获取静态字段时会触发。

oputstatic是设置静态字段时会触发。

invokestatic是调用另一个类的静态方法的时候会触发。

PS：需要注意的是getstatic和putstatic被final修饰的，在编译期就放入到常量池中是不会触发的。

·*使用java.lang.reflect的包方法对类进行反射调用时，如果类没有初始化就需要进行初始的操作。

·*子类进行初始化时需要对父类先进行初始。

*·java启动时需要的启动主类，程序的入口。该类就需要进行初始化。

*使用JDK1.7的动态语言支持时，如果一个java.lang.invoke.Methondhandle实例最后解析结果REF_getStatic，REF_putStatic，REF_invokeStatic的方法句柄，如果没有进行初始化时会触发初始化。

加载

加载是类加载中前面提到的其中的一个过程。类加载的基本过程：

·*通过全限定类加载二进制流。

·*将二进制流代表的静态存储结构转换方法区中运行时的数据结构。

·*在内存中生成java.lang.Class对象，将这个作为该方法区这个类中各种数据的一个入口。

加载分为数组类加载过程和非数组类的加载过程。java的数组类的加载过程其实是由虚拟机直接加载的但是数组中的类型需要类加载机制加载：

·*非数组类加载机制：可控性强既可以由系统类加载器进行加载又可以由用户自定义的类加载器进行加载。

·*数组类型的加载机制：数组类型的加载机制如果是引用类型，就使用递归进行加载，并且会在加载的类型上加入一个标志。如果是非引用类型则会把标志与引导类加载器关联。

ps：数组类的可见性与它组件的可见性是相同的，如果组件类型不是引用类型的可见性一般设置为public。

类加载完成会有一个连接，可能在没完成加载就开始连接，虽然如此但是该顺序是一定的。

验证

验证的主要目的是保证加载进来的Class文件的字节流包含的信息符合虚拟机的当前的要求，不会有危害自身的数据存在。

Java是相对C++语言是安全的语言，例如它有C++不具有的数组越界的检查。这本身就是对自身安全的一种保护。验证阶段是Java非常重要的一个阶段，它会直接的保证应用是否会被恶意入侵的一道重要的防线，越是严谨的验证机制越安全。验证的四个阶段文件格式验证-->元数据验证-->字节码验证-->符号引用验证。

·*文件格式验证：主要验证字节流是否符合Class文件格式规范，并且能被当前的虚拟机加载处理。

是否以魔数开头。

主，次版本号是否在当前虚拟机处理的范围之内。

常量池中是否有不被支持的常量类型。

指向常量的中的索引值是否存在不存在的常量或不符合类型的常量。

CONSTANT_Utf8_info型的常量中有不符合utf8格式的编码数据。

还有其他的验证这里就不一一的列举了。

·*元数据验证：对字节码描述的信息进行语义的分析，分析是否符合java的语言语法的规范。

·*字节码验证：最重要的验证环节，分析数据流和控制，确定语义是合法的，符合逻辑的。主要的针对元数据验证后对方法体的验证。保证类方法在运行时不会有危害出现。

·*符号引用验证：主要是针对符号引用转换为直接引用的时候，是会延伸到第三解析阶段，主要去确定访问类型等涉及到引用的情况，主要是要保证引用一定会被访问到，不会出现类等无法访问的问题。

尽管验证很主要但并不是必须的阶段。当然大量重复的验证会相当的花费性能和时间的。

准备

准备阶段主要是类变量进行分配内存和数据的初始化阶段，所谓的初始化并不是你编码时所定义的变量值。例如：

数据的初始化并不会将它初始化为20，而是初始化为0，系统有一套自己的初始化值。如下图：

当然会有特殊的情况，如下面的代码：

这种情况是类的字段时存在ConstantValue属性所指定的字段。用final修饰后出现该属性，加初始化时会直接的使用ConstantValue的属性值，所以会初始化为20。

解析

解析是将常量池中的符号引用转化为直接引用的过程，还记得前面验证阶段时出现的符号引用验证吗？就是对该阶段的验证。

·*符号引用：符号引用是以一组符号来描述所引用的目标，符号可以是任何的字面形式的字面量，只要不会出现冲突能够定位到就行。布局和内存无关。

·*直接引用：是指向目标的指针，偏移量或者能够直接定位的句柄。该引用是和内存中的而布局有关的，并且一定加载进来的。

虚拟机可能会多次的进行解析。解析主要的对类，接口，字段，类方法，接口方法，方法类型，方法句柄和调用点限定符引用进行。这七种解析有细节上的不同，主要的思想是通过限定性类名找到解析的类型进行解析。主要的是会分为数组类型，非数组类型存在一个直接进行解析的过程。

初始化

初始化算是类加载过程的最后一个阶段，在这个阶段在是真正的开始有java代码主导。大家应该记得在准备阶段已经进行过一次赋值，但是只是系统的默认赋值（ConstantValue的例外情况）。初始化是执行的过程。

·*的主要是查找static模块，用户自定义类变量的赋值，该顺序是由文件中的顺序界定的。加载过程存在的是父类的一定会比子类先进行加载到，因为会保证子类的加载完成时父类的一定会加载完成。所有就像大家所知道的java.lang.object一定会是虚拟机中第一个加载完成的。

·*在接口中的加载是不同的它是不存在静态块的，接口中也是会有赋值进行的，但是接口中的是在需要用到才会去进行加载的。

·*允许在定义之前进行赋值的操作，但是不允许使用，如下：

*虚拟机会保证在多线程的环境下进行加锁，保证正确执行。如果有多个进行加载一个会保证只有一个去加载，其他的会进去阻塞等待中。同一个类只会加载一次，就算多个进入阻塞也不会重新唤醒。

类加载器

·*类与类加载器：一个类的相同判断条件大家都知道，但是如果不是由同一个类加载器加载出来的，就算是看起来相同的也是出现false的。

·*三大类加载器：

启动类加载器

扩展类加载器

应用程序类加载器

·

java类有两种方法一种是类方法就是用static修饰的，一种是实例方法，就是没有static修饰的方法。类方法可以同时类名.方法名的方式调用。而实例方法必须先生存类的实例在通过实例.方法名的方式调用。例如：

publicclassMethodCall

{

publicstaticvoidmain(String[]args)

Test.sayStatic();

Testtest=newTest();

test.sayInstance();

}

classTest

publicstaticvoidsayStatic()

System.out.println("这是一个静态方法。");

publicvoidsayInstance()

System.out.println("这是一个实例方法。");

（本文内容由百度知道网友菜鸟无涯贡献）

首先我们必须要先了解什么是Java的类库

Java的类

Java官方为开发者提供了很多功能强大的类，这些类被分别放在各个包中，随JDK一起发布，称为Java类库或JavaAPI。API(ApplicationProgrammingInterface:应用程序编程接口)是一个通用概念。

例如我编写了一个类，可以获取计算机的各种硬件信息，它很强大很稳定，如果你的项目也需要这样一个功能，那么你就无需再自己编写代码，将我的类拿来直接用就可以。但是，我的类代码很复杂，让你读完这些代码不太现实，而且我也不希望你看到我的代码（你也没必要也不希望读懂这些晦涩的代码），我要保护我的版权，怎么办呢？我可以先将我的类编译，并附带一个文档，告诉你我的类怎么使用，有哪些方法和属性，你只需要按照文档的说明来调用就完全没问题，既节省了你阅读代码的时间，也保护了我的版权。例如，获取CPU信息的方法：

getCpuInfo(intcpuType);

这就是一个API。也就是说，该文档中描述的类的使用方法，就叫做API。

我也可以开发一个软件，用来清理计算机中的垃圾文件，我比较有公益心，希望让更多的开发人员使用我的软件，我就会在发布软件的同时附带一个说明文档，告诉你怎样在自己的程序中调用，这也叫做API。

那么，类的概念大家应该都理解了，下面就教一些调用API的方法

1，调用Java官方发布的API

JavaAPI有一个说明文档，入口地址：http://oracle/technetwork/java/api

选择对应版本的Java，点击链接进入即可。J2SE1.7的API地址为：http://docs.oracle/javase/7/docs/api/

这个文档是在线的，官方会随时更新。当然你也可以下载到本地，请大家自己百度怎么下载。

J2SE1.7的API文档

Java类库中有很多包：

以java.*开头的是Java的核心包，所有程序都会使用这些包中的类；

以javax.*开头的是扩展包，x是extension的意思，也就是扩展。虽然javax.*是对java.*的优化和扩展，但是由于javax.*使用的越来越多，很多程序都依赖于javax.*，所以javax.*也是核心的一部分了，也随JDK一起发布。

以org.*开头的是各个机构或组织发布的包，因为这些组织很有影响力，它们的代码质量很高，所以也将它们开发的部分常用的类随JDK一起发布。

在包的命名方面，为了防止重名，有一个惯例：大家都以自己域名的倒写形式作为开头来为自己开发的包命名，例如百度发布的包会以com.baidu.*开头，w3c组织发布的包会以org.w3c.*开头，微学苑发布的包会以net.weixueyuan.*开头……

组织机构的域名后缀一般为org，公司的域名后缀一般为com，可以认为org.*开头的包为非盈利组织机构发布的包，它们一般是开源的，可以免费使用在自己的产品中，不用考虑侵权问题，而以com.*开头的包往往由盈利性的公司发布，可能会有版权问题，使用时要注意。

常用的几个包，更多的包和说明请参考API文档

2，通过导入Java包中的类（欢迎大家关注我公众号，每日更新Java最新玩法，也可以加入学习交流群632119504一起交流学习）

如果你希望使用Java包中的类，就必须先使用import语句导入。

import语句与C语言中的#include有些类似，语法为：

importpackage1[.package2…].classname;

package为包名，classname为类名。例如：

注意：

import只能导入包所包含的类，而不能导入包。

为方便起见，我们一般不导入单独的类，而是导入包下所有的类，例如importjava.util.*;。

Java编译器默认为所有的Java程序导入了JDK的java.lang包中所有的类（importjava.lang.*;），其中定义了一些常用类，如System、String、Object、Math等，因此我们可以直接使用这些类而不必显式导入。但是使用其他类必须先导入。

前面讲到的”HelloWorld“程序使用了System.out.println();语句，System类位于java.lang包，虽然我们没有显式导入这个包中的类，但是Java编译器默认已经为我们导入了，否则程序会执行失败。

Java类的搜索路径

Java程序运行时要导入相应的类，也就是加载.class文件的过程。

假设有如下的import语句：

importp1.Test;

安装JDK时，我们已经设置了环境变量CLASSPATH来指明类库的路径，它的值为.;%JAVA_HOME%\lib，而JAVA_HOME又为D:\ProgramFiles\jdk1.7.0_71，所以CLASSPATH等价于.;D:\ProgramFiles\jdk1.7.0_71\lib。该语句表明要导入p1包中的Test类。

Java运行环境将依次到下面的路径寻找并载入字节码文件Test.class：

.p1\Test.class（"."表示当前路径）

如果在第一个路径下找到了所需的类文件，则停止搜索，否则继续搜索后面的路径，如果在所有的路径下都未能找到所需的类文件，则编译或运行出错。

你可以在CLASSPATH变量中增加搜索路径，例如.;%JAVA_HOME%\lib;C:\javalib，那么你就可以将类文件放在C:\javalib目录下，Java运行环境一样会找到。

欢迎大家关注我公众号，每日更新Java最新玩法，也可以加入学习交流群632119504一起交流学习