Java从入门到精通
2023-09-04 09:15:45 7 举报AI智能生成
java从入门到精通第1到12章
作者其他创作
大纲/内容
Java是1995年由sun公司推出的一门极富创造力的面向对象的程序设计语言
1.1.1：什么是Java语言
1.桌面应用系统开发
2.嵌入式系统开发
3.电子商务应用
4.企业级应用开发
5.交互式系统开发
6.多媒体系统开发·
7.分布式系统开发
8.web应用系统开发
9.移动端应用开发
java的应用领域主要有以下几个方面
1.1.2：java的应用领域：借助java程序人员可以自由地使用现有的的软件系统平台和硬件
Javase：java标准版
Javaee：java企业版
1.1.3：java的版本：Javase和Javaee
明确方向
基础学习
了解设计模式
不要死记语法
多实践，多思考，多请教
不要急躁
尝试自己解决问题
多查阅资料
多阅读别人代码
1.1.4：怎样学好java
api是应用程序编程接口，主要包括类的继承结构，成员变量，成员方法，构造方法等
1.1.5：javaapi文档
1.1java简介
简单：java语法简单明了，容易掌握
面向对象：java语言的重要特性
分布性：java的分布特性分别是操作分布和数据分布
可移植性：java的类库也实现了针对不同平台的接口
解释型：运行Java需要解释器
安全性：java可以编写出防病毒和防修改的系统
健壮性：Java语言的设计目标之一，是能编写出多方面、可靠的应用程序
多线程：java语言支持多线程机制，能够使用应用程序在同一时间并执行多项任务
高性能：字节码可以在程序运行时被翻译成特定的机器指令，从而进一步提高运行速度
1.2：Java语言的特性
jdk版本众多，选择适合的就好
1.3.1：jdk下载
配置环境变量
1.3.2：在Windows10系统下搭建jdk环境
1.3：搭建Java环境
第1章：初始java
2.1.1：eclipse简介：eclipse为编程人员提供了一流的java程序开发环境
2.1.2：下载eclipse：点击下载
2.1.3：安装eclipse的中文语言包：下载Babel汉化包（习惯英文更好使用）
将eclipse压缩包解压至想要盘中的目录（注意全英文文件夹路径）
2.1.4：eclipse的配置与启动
进入欢迎界面，点击菜单一行中的file--new--Javaproject（新建java文件）
2.1.5：eclipse工作台
1.透视图：不同透视图可以切换，但是同一时刻只能使用一个透视图
2.视图：视图有自己独立的菜单栏和工具栏
2.1.6：透视图与视图
图片均为视图
文件、编辑、源代码、重构、帮助、搜索、窗口、项目、运行、浏览
2.1.7：菜单栏
1.主工具栏：位于eclipse菜单栏下方的工具栏
2.视图工具栏:视图有不同的用途
3.透视图工具栏：切换视图按钮
2.1.8：工具栏
2.1.9：“包资源管理器”视图
2.1.10：“控制台”视图
2.1：熟悉eclipse
选择文件新建
弹出新建java对话框
点finish完成
2.2.1：创建java项目
新建java类
向导文件夹
2.2.2：创建Java类文件
打开java编辑器
编写java代码
2.2.3：使用编译器编写程序代码：
运行结果
2.2.4：运行Java代码
2.2：使用eclipse
1.断点：java调试器每次遇到程序断点时都会将当前线程挂起，及暂停当前线程的运行
2.以调试方式运行java程序
3.程序调试：单步跳过：运行单独的一行程序代码。
2.3：程序调试
第2章：熟悉eclipse开发工具
1.包声明：package Number为声明类的包
2.声明局部变量和成员变量：s1为成员变量，s2为局部变量
3.编写主方法：main为主方法。从花括号开始（{）至花括号结束（}），public static void是main（）的修饰符、静态修饰符，必须声明public static void main(String[] args)一组字符串，字符串为main（）的主参数。[文字描述算法在代码中]
3.1：Java主类结构
public class Hi { //类名 static String s1=\"你好\";//声明成员变量 public static void main(String[] args) { //主函数 String s2=\"java\";//声明局部变量 System.out.print(s1);//输出s1内容 System.out.print(s2);//输出s2内容 }} //例题3.1
整数类型：（byte，short，interesting，long)
3.2.1：整数类型：简称整形，用来存储整数值
public class Thirdone { public static void main(String[] args) { // TODO Auto-generated method stub byte b=1;//定义byte形 System.out.println(b);//输出换行 short z=12345;//定义short形 System.out.println(z);//输出换行 int i=11254;//定义int形变量 System.out.println(i);//输出换行 long l=7946626126L;//定义long形L大写 System.out.println(l);//输出换行 float h=9.99F;//定义float单精度浮点型 System.out.println(h);//输出 double m=5.66D;//定义double双精度浮点型 System.out.println(m);//输出 } }
浮点类型：(float、double)
3.2.2：浮点类型：简称浮点型，用来存储含有小数部分的数值
public class BMIexponent{ public static void main(String[] args) { // TODO Auto-generated method stub double height=1.71;//定义double型，height为高度，将数值赋予这个量 int weight=70;//douuble为局部变量，定义int类型，weight为重量 double exponent=weight/(height*height);//算法为重量除以升高和重量的乘积 System.out.println(\"您的身高为：\"+height);//输入身高 System.out.println(\"您的体重为：\"+weight);//输入体重 System.out.println(\"您的BMI指数为：\"+exponent);//计算bmi指数 System.out.println(\"您的体重属于：\");//判断语句 if(exponent<18.5) { System.out.println(\"体重过轻\");//如果exponent小于18.5，输出体重过轻 } if(exponent>=18.5&&exponent<24.9) { //如果exponent大于等于18.5并且小于24.9，输出正常范围 System.out.println(\"正常范围\"); } if(exponent>=24.9&&exponent<29.9) {//如果exponent大于等于24.9且小于29.9，输出体重过重 System.out.println(\"体重过重\"); } if(exponent>=29.9){//如果exponent大于等于29.9，输出肥胖 System.out.println(\"肥胖\");} }}//例题3.2
字符类型：.char型：储存单个字符，占用16位，用单引号表示
2.转义字符：是一种特殊的字符变量，以反斜杠开头
3.2.3：字符类型：用于储存单个字符
public class Char { public static void main(String[] args) { // TODO Auto-generated method stub char c1='\\\\';//定义char字符类型 char c2='\\u2650';//Unicode编码 System.out.println(c1);//打印输出c1 System.out.println(c2);//输出c2 } } //例题3.4
布尔类型：只有true和false两个值
3.2.4：布尔类型
public class TrueOrFalse { public static void main(String[] args) { // TODO Auto-generated method stub boolean b1=true;//定义布尔类型字符b1 boolean b2=Boolean.FALSE;//定义布尔类型字符b2（注意大写） System.out.println(b1); System.out.println(b2);//打印输出 } }
3.2：基本数据类型
1.标识符：用来标识类名、变量名、方法名、数组名、文件名的有效字符序列由任意顺序字母（A/a）、下划线（-）、美元符号（＄）和数字（不能放开头）组成。.只能包含字母、下划线、美元符号、数字.不能以数字开头.要避开关键字（关键字即为代码中彩色的字）这里用任意代码作为示例。
2.关键字：又称保留字，是Java语言中的已经被赋予特定意义的一些单词，不可以把这些单词作为标识符来使用。3.2节介绍数据类型时提到的int Blooean等都是关键字Java语言中的关键字，如表3.4所示。
3.3.1：标识符和关键字
3.3.2：声明变量：变量的使用是程序设计中的一个十分重要的环节。声明变量就是要告诉编译器这个变量的数据类型，这样编译器才能知道配置多少空间给它。变化的定义和赋值：类型+变量名 例如：（double+weight）.局部变量：在方法内部定义，只在该方法内有效
3.3.3：声明常量：在程序中运行过程中一直不会改变的量，称为常量，通常也被称为final变量常量在整个程序中只能被赋值一次。
1.成员变量
2.局部变量
3.3.4：变量的有效范围：由于变量被定义出来后只是暂时存在内存中，等到程序执行到某一个点，该变量会被释放掉。也就是说变量有它的生命周期。
3.3：变量与常量
public class Thirdtwo { static int times=3;//成员变量 public static void main(String[] args) { int times=4;//局部变量 System.out.println(\"times的值为：\"+times);//当局部变量和成员变量名字相同使用就近原则 } }//将局部变量删除就会输出成员变量的值或者将成员变量输出
public class ThirdPart { public static void main(String[] args) { final int number;//定义一个int类型number数字 number=1125; System.out.println(number); } }
public class ThirdPart { //创建类 static final double PI =3.14; //声明变量pi public static void main(String[] args) { final int number;//定义一个int类型number数字 //static为静态 number=1125;//赋值1125 System.out.println(number);//输出number System.out.println(PI);//输出pi } }
3.4.1：赋值运算符：以“=”表示，将右边数赋值给左边
Java中的算术运算符主要，加有减乘除求余，他们都是二元运算符。Java中算术运算符的功能及使用方式如表3.5所示。
3.4.3：自增和自减运算符：a++，++a；a--，--a；（运算符在前，先运算后使用；运算符在后，先使用后运算）；
比较运算符属于二元运算符，用于程序中的变量之间变量和自变量之间以及其他类型的信息之间的比较。比较运算符的运算结果是boolean型，当运算符对应的关系成立时运算结果为true，否则为false。所有比较运算符通常作为判断依据，用在条件语句中比较运算符。共有六个，如图3.6所示。
3.4.5：逻辑运算符：&&（与）:两者都为真，结果才是真；||（或）：只要有一者为真，结果就是真；！（非）：非真即假，非假即真；false&&.....&&.....:结果一定为false(短路现象)true||.....||.....:结果一定为true（短路现象）
3.4.6：位运算符：二进制之间进行运算使用位运算符&（与）：两者都为1，结果才是1；|（或）：只要有一者为1，结果就是1；~（取反）：0变1，1变0；^(异或)：两者相同即为0，不同为1；<<(左移):整体往左移一位，空位补0，溢出去掉。>>(右移)：整体往右移一位，正数补0，负数补1，溢出去掉。>>>(无符号右移)：整体往右移，空位补0，溢出去掉。
3.4.7：三元运算符：例如：A？B：CA:一定是一个条件语句B：A为真结果为BC：A为假结果为Cint a=3；int b=a>2? a++/a--/++a：8；a=4；b=3 / a=2 b=4 /a=4 b=4转换if else语句：if(a>2）{b=a++/a--/}else{b=8}
Java中的表达式就是使用运算符连接起来的。符合Java规则的是指运算符的优先级决定了表达式中运算执行的销售数据。通常优先级由高到低的顺序次增量和减量运算。算术运算比较运算逻辑运算赋值运算。如果两个运算有相同的优先级，那么左边的表达式要比右边的表达式。先被处理表3.9显示了在Java中众多运算符特定的优先级。
3.4：运算符
import java.util.Scanner;//例题3.8 public class Eval {public static void main(String[] args) { Scanner sc =new Scanner(System.in); System.out.println(\"请输入两个数字，用空格隔开（num1 num2）:\"); double num1=sc.nextDouble();//可以改为int类型 double num2=sc.nextDouble(); System.out.println(\"num1+num2的和为：\"+(num1+ num2)); System.out.println(\"num1-num2的差为：\"+(num1-num2)); System.out.println(\"num1*num2的积为：\"+(num1* num2)); System.out.println(\"num1/num2的商为：\"+(num1/ num2)); System.out.println(\"num%num2的余数为：\"+(num1% num2)); sc.close(); }}
public class Compare { public static void main(String[] args) { // TODO Auto-generated method stub int number1=4; int number2=5; System.out.println(\"number1 > number2的返回值为：\"+(number1 > number2)); System.out.println(\"number1 < number2的返回值为：\"+(number1 < number2)); System.out.println(\"number1 == number2的返回值为：\"+(number1 == number2)); System.out.println(\"number1 != number2的返回值为：\"+(number1 != number2)); System.out.println(\"number1 >= number2的返回值为：\"+(number1 >= number2)); System.out.println(\"number1 <= number2的返回值为：\"+(number1 <= number2));//例题3.9 } }
隐式换也要遵循一定的规则来解决。在什么情况下将哪种类型的数据转换成另一种类型的数据表。表3.10列出了各种数据类型隐式转换的一般规则。
当把高精度的变量的值赋给低精度的变量时，必须使用显式类型转换运算。
3.5：数据类型转换：自动类型转换：一定不会丢失数据（即低精度数据类型向高精度数据类型转换 例如：byte型转换为short型，系统会自动进行转换）强制类型转换：有可能会丢失数据（即高精度数据类型向低精度数据类型转换 例如：short型转换位byte型）数据类型排列顺序：byte<short<int<long<float<double
public class Conver {//创建类 public static void main(String[] args) { // TODO Auto-generated method stub byte mybyte=127;//定义byte型变量mybyte，并赋值 int myint=(int)45.232323; //强制类型转换 float myfloat=452.12f;//定义float型变量myfloat，并赋值 char mychar=10;//定义char型变量mychar，并赋值 double mydouble=45.46546;//定义double型变量mydouble，并赋值 System.out.println(\"byte型与float型数据进行运算结果为：\"+(mybyte+ myfloat));//输出结果 System.out.println(\"byte型与int型数据进行运算结果为：\"+(mybyte* myint)); System.out.println(\"byte型与char型数据进行运算结果为：\"+(mybyte/ mychar)); System.out.println(\"double型与char型数据进行运算结果为：\"+(mydouble+ mychar)); } } //例题3.11
3.6：代码注释与编码规范单行注释//....（注释内容）多行注释/*....注释内容*/文档注释/** */
第3章：java语言基础
4.1：复合语句：女生语言及其他语言相同。Java语言的复合语句是以整个块区为单位的语句，所以又称块语句。复合语句由开括号。到闭括号结束。在前面的学习中，我们已经接触到了这种复合语句。例如，在定义一个类或方法时，类体是由花括号作为开始与结束的标记方法体也同样是以花括号作为标记。复合语句中的每个语句都是从上到下执行复合语句以整个块为单位，没有能够用在任何一个单独语句可以使用的。地方，并且在复合语句中还可以嵌套复合语句。
if...else语句：if（条件表达式）{语句序列2}else{语句序列3}语句4
if语句：
if...else if语句：
4.2.1：if条件语句：
public class Fourone { public static void main(String[] args) { // TODO Auto-generated method stub int phoneNumber=123456789; if(phoneNumber!=84972266) { System.out.println(\"对不起，您拨打的号码不存在！\"); } }}
public static void main(String[] args) { // TODO Auto-generated method stub System.out.println(\"欢迎光临，请问有多少人用餐？\"); int count=9; System.out.println(\"回答：\"+count+\"人\"); if(count<=4) { System.out.println(\"客人请到大厅4人桌用餐\"); }else if(count>4&&count<=8){ System.out.println(\"客人请到大厅8人桌用餐\"); }else if(count>8&&count<=16) { System.out.println(\"客人请到楼上包厢用餐\"); }else { System.out.println(\"抱歉，我们店暂时没有这么大的包厢！\"); } } }
4.2.2：switch多分支语句：
4.2：条件语句
import java.util.Scanner; public class Fourfour { public static void main(String[] args) { // TODO Auto-generated method stub Scanner sc=new Scanner(System.in); System.out.print(\"请输入成绩：\"); int grade=sc.nextInt(); switch(grade) { case 10: case 9: System.out.println(\"成绩为优：\"); break; case 8: System.out.println(\"成绩为良：\"); break; case 7: case 6: System.out.println(\"成绩为中：\"); break; case 5: case 4: case 3: case 2: case 1: case 0: System.out.println(\"成绩为差：\"); break; default: System.out.println(\"成绩无效：\"); } sc.close(); } }
4.3.1：while循环语句
4.3.2：do...whie循环语句
4.3.3：for循环语句
4.3：循环语句
4.4.1：break语句:跳出当前循环
4.4.2：contiune语句：跳过本次循环
4.4：循环控制
第4章：流程控制
5.1：数组概述：具有相同类型的一组数据的集合，数组简单的认为是很多格子。
1.如何去定义数组：上面先括号+数组名比较常用
2 分配内存并进行初始化
5.2.1：创建一维数组：点
5.2.2：初始化一维数组
5.2.3：使用一维数组
5.2：一维数组
1声明数组
2.分配内存
5.3.1：创建二维数组：面
5.3.2：初始化二维数组
5.3.3：使用二维数组
5.3：二维数组
5.4.1：遍历数组：遍历数组中的每个元素
替换数组的部分元素（前索引值改后索引值不改）Arrays.fill（数组名，前索引，后索引，值）；前索引和后索引的值
5.4.2：填充替换数组元素：数组中的元素定义完成后，可通过Arrays类的静态方法fill（）对数组中元素进行替换Arrays.fill（数组名，值）；
5.4.3：对数组进行排序：Arrays.soft（数组名）
5.4.4：复制数组：（空位补0，溢出去掉）新数组名= Arrays.copyOf（旧的数组名，新数组长度）；多种重载形式，类型多样
5.4.5：查询数组:（先排序后查询）索引=Arrays.binarySearch(数组名，元素)；
5.4：数组的基本操作
数组如果不进行排序索引值会变成负数
前索引含后索引不含）索引=Arrays.binarySearch(数组名，前索引，后索引，元素)；import java.util.Arrays;//导入java.utill.Arrays public class Fivetwo { public static void main(String[] args) { String str[]=new String []{\"ab\
5.5.1：冒泡排序：它排序数组元素的过程总是在将小的数往上放，较大的竖往后放类似于水中气泡往上升的动作，所以称为冒泡排序。
5.5.2：直接选择排序：选择排序也叫直接排序，它的排序速度比冒泡排序要快一些。
5.5.3：反转排序：就是以相反的排序，把原有的数组内存重新排序。反转排序的基本思想比较简单，把数组的最后1个元素和第1个元素替换，倒数第2个元素与第2个元素替换，以此类推。
5.5：数组排序算法
第5章：数组
错误：数组下标越界，超出赋值长度解决方法：重新赋值分配a，或者将多赋值删掉，注意for循环里条件（或者用a.length）/（for循环，注意冒号）
6.1.1：对象：对象是事物存在的实体
6.1.2：类：同一类事物的统称，以方法的形式定义
6.1.4：继承：类与类之间同样具有关系，称为关联。继承就是关联的一种。例如：水果（父类）——香蕉，苹果，橘子......——苹果：脆的，粉的（子类）....父类和子类存在层次关系
6.1.5：多态：多个形态
6.1：面对对象概述
6.2.1：成员变量：静态属性和动态属性直接写在类里的叫成员变量
6.2.2：成员方法：框住局部变量
6.2.3：权限修饰符：控制着类和类的成员变量以及成员方法的访问，具体如表所示
6.2.4：局部变量：在方法被执行时创建
6.2.5：局部变量的有效范围：从变量的开始到变量的结束
6.2.6：this关键字：表示当前类的对象\t//静态属性————成员变量去写public class Bird {//静态属性\t//静态属性————成员变量去写\tprivate String name;//名字 //default默认的意思\tprivate String wing;//翅膀\tprivate String mouth;//嘴\tprivate String head;//头\t\t\tpublic String getName() {\t\treturn name;\t}\tpublic void setName(String name) {\t\tthis.name = name;//指这个类bird\t}\tpublic String getWing() {\t\treturn wing;\t}\tpublic void setWing(String wing) {\t\tthis.wing = wing;\t}\tpublic String getMouth() {\t\treturn mouth;\t}\tpublic void setMouth(String mouth) {\t\tthis.mouth = mouth;\t}\tpublic String getHead() {\t\treturn head;\t}\tpublic void setHead(String head) {\t\tthis.head = head;\t}\tprivate String name;//名字 //default默认的意思\tprivate String wing;//翅膀\tprivate String mouth;//嘴\tprivate String head;//头\t\t\tpublic String getName() {\t\treturn name;\t}\tpublic void setName(String name) {\t\tthis.name = name;//指这个类bird\t}\tpublic String getWing() {\t\treturn wing;\t}\tpublic void setWing(String wing) {\t\tthis.wing = wing;\t}\tpublic String getMouth() {\t\treturn mouth;\t}\tpublic void setMouth(String mouth) {\t\tthis.mouth = mouth;\t}\tpublic String getHead() {\t\treturn head;\t}\tpublic void setHead(String head) {\t\tthis.head = head;\t}
6.2：类
public class Sixone { //类 private String name; //String类型的成员变量 public String getName() {//name的Getter方法 return name; } public void setName(String name) {//name的set方法 this.name=name;//将参数的值赋予成员变量 } }//6.1例题
6.3：类的构造方法：产生对象但信息不全面（需要传入参数）
6.4：静态变量和静态方法：同一个类的不同实例对象，可以共用同一静态变量。
6.5：类的主方法：主方法是类的入口点，它定义了程序从何处开始。
6.6.1：对象的创建:使用new操作符调用构造方法就可以创建一个对象
6.6.2：访问对象的属性和范围:
6.6.3：对象的引用:在项目中创建TransferProperty类，在该类中说明对象是如何调用类成员的。
6.6.4：对象的销毁:Java有一套完整的垃圾回收机制
6.6：对象
第6章：类和对象
7.1：类的继承:Java语言每一个子类只能继承一个父类：简称单继承。子类——父类——祖父类继承：extends父类：和平常类写法一样public class 父类类名{}子类：public class子类类名 extends 父类类名{}子类继承父类后，调用后同时会进行子类和父类打印
toString方法重写
7.2：Object类:所有的类的父类
7.3.1：向上转型:将子类对象（等号右边）向父类引用（等号左边）自动类型转换
7.3.2：向下转型\":将父类对象向子类引用需要进行强制类型转换
7.3：对象类型的转换
Animal a=new Dog();
Dog a=(Dog) new Animal;
7.4:使用instanceof关键字判断对象类型:对象名+instanceof+类名（判断对象是否属于这个类或者是他的子类）
7.5：方法的重载：方法名相同，参数不同
7.6.1：final变量
7.6.2：final方法
7.6.3：final方法
7.6：final关键字：不可被修改（常量）final修饰方法——不可以被重写final修饰方法——不可以被继承
7.7：多态：同一方法或同一个地方出现不同的形态就叫多态
7.8.1：抽象类：抽象方法：修饰符 abstract 返回数 方法名（）；有抽象方法的类一定是抽象类修饰符 abstract class 类名{}将抽象方法写入普通类中会报错有以下两种方法改变 1.将abstract移除加上方法体2.将普通类改成抽象类
7.8：抽象类与接口
为什么要用抽象类子类要继承父类，在父类里，有抽象方法出现的情况（子类会继承抽象方法）：父类将制定一种规则：子类必须重写两个抽象方法，不然就会报错。
interface Paintable{ //可绘制接口，制定规则 public void draw(); //绘制抽象方法} class Quadrange { public void doANything(){ System.out.println(\"四边形的提供方法\"); }}//平行四变形类，继承四边形类，并实现了可绘制接口class Parallelogram extends Quadrange implements Paintable{ public void draw()//由于该类实现了接口，所以需要覆盖draw（），也就是重写{ System.out.println(\"绘制平行四边形\"); } }//正方形类，继承四边形类，并实现了可绘制接口class Square extends Quadrange implements Paintable{ public void draw()//由于该类实现了接口，所以需要覆盖draw（），也就是重写{ System.out.println(\"绘制正方形\"); } }//圆形类class Circular implements Paintable{ public void draw()//由于该类实现了接口，所以需要覆盖draw（），也就是重写{ System.out.println(\"圆形\"); } } public class Demo7{public static void main(String[] args){ Square s=new Square(); s.draw(); s.doAnything; Parallelogram p=new Parallelogram (); p.draw(); p.doAnything(); Circular c=Circilar(); c.draw();}}例题7.13
第7章：继承、抽象类、多态和接口
在所有类的构造方法第一行都有隐藏super ：在执行构造方法之前调用其父类的构造方法
inse
public class Parent { public Parent () { System.out.println(\"调用Parent类的构造器\"); } }//例题7.1public class Child extends Parent {//继承父类 public Child() { System.out.println(\"调用Child的构造方法\"); } }//例题7.1public class Demo1 { public static void main(String[] args) { // TODO Auto-generated method stub new Child();//调用Child类 } }//例题7.1
class Quadrangle{}class Square extends Quadrangle{}class Circular{} public class Demo5 { public static void main(String args[]) { Quadrangle q=new Quadrangle(); Square s=new Square(); System.out.println(q instanceof Square); System.out.println(s instanceof Quadrangle); }}//例题7.7
final class Finalclass{ } public class FinalTest extends Finalclass{ //继承一个final的类 }
class Shape{}class Square extends Shape{}class Circular extends Shape{} public class Demo6 { public static void draw(Shape s) { if(s instanceof Square) { System.out.println(\"绘制正方形\"); }else if (s instanceof Circular) { System.out.println(\"绘制圆形\"); }else { System.out.println(\"绘制父类图形\"); } } public static void main(String[]args) { draw(new Shape()); draw(new Square()); draw(new Circular()); }}//例题7.12
8.1.1：类名冲突：有包的存在就有类名存在，类名定义多种，但功能不同
8.1.2：完整的类路径：1.双击打开工作区域是不一样的C:\\Users\\隐入尘烟\\eclipse-workspace2.复制空间寻找包内内容3.创建项目
8.1.3：创建包：在项目里创建包
8.1.4：导入包：1.使用import导入包2.使用import导入静态成员
8.1：Java类包：
package com.baidu.www; import java.util.Scanner; public class Game1 { public static void main(String[] args) { // TODO Auto-generated method stub //从键盘获取一个整数 //输出整数 Scanner sc =new Scanner(System.in); //创建扫描器 System.out.println(\"请输入一个数\"); int c1 =sc.nextInt(); System.out.println(c1); sc.close(); } }
8.2.1：成员内部类：
8.2.2：匿名内部类：匿名类是只在创建对象时才会编写类体的一种写法，匿名类特点：现用现写
8.2：内部类
final方法
public class TheSameName { private int x =7; //外部类的x private class inner{ private int x =9; //内部类的x public void doit() { int x = 11; //局部变量x x++; //调用局部变量 this.x++; //调用内部类的x TheSameName.this.x++; //调用外部类的x } }}例题8.4
abstract class Dog{ String Color; public abstract void move(); public abstract void call();} public class Demo { public static void main(String args[]) { Dog maomao = new Dog() { public void move() { System.out.println(\"四腿狂奔\"); } public void call() { System.out.println(\"嗷呜~\"); } }; maomao.Color = \"灰色\"; maomao.move(); maomao.call(); } }例题8.5
第8章：包和内部类
9.1：异常概述：异常可能由程序员没有想到的情况超出范围内
9.2.1：抛出异常
9.2.2：捕捉异常：try{//代码块}catch （Exceptiontype1）{catch (xceptiontype2)}....finally{//程序代码块}
9.2：异常的抛出与捕获
public class Nineone { public static void main(String[] args) { // TODO Auto-generated method stub try { int result =3/0; System.out.println(result); }catch(ArithmeticException e) { System.out.println(\"算法异常\"); } } }//例题9.1
9.3：Java常见的异常类：红色为常见异常
9.4：自定义异常：定义1个exception类继承，这就是自定义异常括号里是传入参数，super是隐藏方法，作用是调用父类的构造方法打印出错误信息
9.5.1：使用throws关键字抛出异常
9.5：在方法中抛出异常:错误：1.黄色感叹号：是警告，对于Java代码没有太大影响；2.Exception异常处理，要处理 3.报错，错误是无法解决的
public class Shoot { //创建类 static void pop()throws NegativeArraySizeException{ //定义方法并抛出NegativeArraySizeException：【数组元素为负数】异常 int arr[] = new int [-3]; //创建数组 } public static void main(String[] args) { //主方法 try { //尝试处理异常信息 pop(); }catch (NegativeArraySizeException e) { System.out.println(\"pop()方法抛出的异常\"); //输出异常信息 } }}//例题9.6
9.6：运行时异常:各类异常
9.7：异常的使用原则:
第9章：异常处理
public class Nineone { public static void main(String[] args) { // TODO Auto-generated method stub int result =3/0; System.out.println(result); } }//例题9.1出现异常：不能被零整除，算法异常
public class MyException extends Exception { //自定义异常 public MyException (String ErrowMessage) {//输出错误方法 super(ErrowMessage);//调用父类的构造方法 } }//例题9.4
10.1.1：声明字符串:声明一个字符串就是创建一个字符串对象。声明字符串：包含在双引号之内
10.1：String类
public class Test1 { public static void main(String[] args) { // TODO Auto-generated method stub //10.1 String 类 //字符串变量的声明 String str;// System.out.println(str); //字符串变量的初始化 str=\"你好\"; str=new String(\"你好\
10.2.1：连接多个字符串:使用+连接运算符可实现连接多个字符串的功能
10.2.2：连接其他数据类型
10.2：连接字符串
10.3.1：获取字符串长度:在数组中，用.length，获取长度
10.3.2：字符串查找:第一次出现和最后一次出现的长度indexOf和last indexOf
10.3.3：获取指定索引字符的位置:str.charAt
10.3：获取字符串信息
public class Text { public static void main(String[] args) { // TODO Auto-generated method stub String str = \"We are students\"; int size =str.lastIndexOf(\"\");//将空字符串在str中的索引位置的值赋给size System.out.println(\"空字符串在字符串str中的索引位置是：\"+size);//将变量size输出 System.out.println(\"字符串str的长度是：\"+str.length());//将字符串str的长度输出。 } }//例题10.3
public class Test2 { public static void main(String[] args) { // TODO Auto-generated method stub // 10.3 获取字符串信息 String str =\"hellowworld\"; // 获取字符串长度 int length = str.length(); System.out.println(length);//获取长度 //查找字符串中出现该元素的位置。 //第一次出现的位置 int indexOf =str.indexOf(\"l\"); System.out.println(indexOf); //最后一次出现的位置 int lastindexOf =str.lastIndexOf(\"l\"); System.out.println(lastindexOf); //获取指定索引号的字符 char charat=str.charAt(3); System.out.println(charat); } }
public class Ref { public static void main(String[] args) { // TODO Auto-generated method stub String str =\"hellowworld\";//定义字符串为str char mychar=str.charAt(6);//将字符串中索引位置为6的字符返回 System.out.println(\"字符串str中索引位置是6的字符为：\"+mychar);//输出信息 } }//例题10.4
10.4.1：获取子字符串:str.substring(int beginindex)
10.4.2：去除空格:font color=\"#e74f4c\
10.4.3：字符串替换:str.replace
10.4.4：判断字符串的开始与结尾:startsWith()和endWith（）
10.4.5：判断字符串是否相等:equals：equalsIgnoreCase ：忽略大小写判断是否相同
10.4.6：按字典顺序比较两个字符串:str.compareTo
10.4.7：字母大小写转换:str.toLowerCase()str.toUpperCase()
10.4.8：字符串分割:split
10.4：字符串操作
public class Subs { public static void main(String[] args) { // TODO Auto-generated method stub String str =\"《将进酒》：李白（唐）\
//去除首尾空格 String st = \" Java Class \"; System.out.println(st+ \"的长度为\"+st.length()); String trim = str.trim(); System.out.println(trim+ \"的长度为\"+trim.length());
//替换字符串 String s = \"address\"; String replace =s.replace(\"a\
//判断字符串的开始与结尾 String num1=\"22045612\"; boolean startWith = num1.startsWith(\"22\"); System.out.println(startWith); //结尾 String num2=\"22045612\"; boolean endsWith = num2.endsWith(\"12\"); System.out.println(endsWith);
public class Opinion { public static void main(String[] args) { // TODO Auto-generated method stub String s1 =new String(\"abc\"); String s2 =new String(\"ABC\"); boolean b =s1.equals(s2); boolean b2 =s1.equalsIgnoreCase(s2); System.out.println(s1+\"equals\"+s2+\":\"+b); System.out.println(s1+\"equals\"+s2+\":\"+b2); } }//例题10.9
//10.4.6按照Unicode值比较字符串先后顺序 String str1 =\"a\"; String str2 =\"b\"; String str3 =\"c\"; System.out.println(str1.compareTo(str2));//前面的和后面相比 System.out.println(str2.compareTo(str2));//自己和自己相比 System.out.println(str3.compareTo(str2));//后面和前面比
//10.4.7字母大小写转换 String stri =\"MY LOVE\"; String lower = stri.toLowerCase();//全部转换为小写，向下走 System.out.println(lower ); String upper = stri.toUpperCase();//全部转换为大写，向上走 System.out.println(upper);
//10.4.8字符串的分割 String strin=\"192.168.0.1\"; String[] split =strin.split(\"\\\\.\");//转义，分割为4个部分 for(String temp: split) { System.out.println(temp); } String[] split2 =strin.split(\"\\\\.\
import java.util.Date; public class Test4 { public static void main(String[] args) { // TODO Auto-generated method stub //10.5 格式化字符串 //String 格式化后的字符串 = String.format（格式，字符串）; //日期和时间字符串的格式化 Date date = new Date(); //默认输出当前的时间 System.out.println(date); //日期 String year = String.format(\"%ty\
10.5.1：日期和时间字符串格式化:
子主题
10.5：格式化字符串str.format(String):指定格式字符串str.format(Local)：指定语言环境
10.6：使用正则表达式
10.7：字符串生成器:StringBuild类
第10章：字符串
public class Jerque { public static void main(String[] args) { // TODO Auto-generated method stub String str=\"\"; long starTime=System.currentTimeMillis(); for(int i=0;i<10000;i++) { str=str+i; } long endTime=System.currentTimeMillis(); long time=endTime-starTime; System.out.println(\"String 消耗时间:\"+time); StringBuilder builder=new StringBuilder(\"\"); starTime=System.currentTimeMillis(); for(int j=0;j<10000;j++) { builder.append(j); } endTime=System.currentTimeMillis(); time=endTime-starTime; System.out.println(\"StringBuilder 消耗时间:\"+time); } } //例题10.18
11.1.1：Interger类：integer类在对象中包装了一个基本数据类型int的值，该类的对象包含了一个int类型的字段。此外，该类提供了多个方法，能在int类型和String类型之间互相转换，同时还提供了其他一些处理int类型时非常有用的常量和方法，integer类的常用方法如表11.2所示
11.1.2：Double类：double类在对象中包装一个基本类型为double的值，每个double类的对象都包含一个double类型的字段。此外，该类还提供多个方法，可以将double类型转换为String类型，将String类型转换为double类型，也提供其他一些处理double类型时有用的常量方法。double类的常用方法如表11.3所示
11.1.3：Boolean类：Boolean类将基本类型为boolean的值包装在一个对象中。一个Boolean类型的对象只包含一个类型为boolean的字段，此外，此类还为Boolean类和Stringl类型的相互转换提供了许多方法。并提供处理boolean类型时非常有用的其他一些常量方法。boolean类的常用方法如表11.4所示
11.1.4：Character类：Characte在对象中包装一个基本类型为char的值，该类提供了多种方法以确定字符的类别(小写字母数字等)，并可以很方便的将字符从大写转换为小写，反之亦然。Characte提供了很多方法来完成对字符的操作。常用的方法，如表11.5所示。
11.1.5：Number类：font color=\"#a23735\
11.1：包装类：把基本数据类型转换为对象进行处理，java中的包装类及其对应的基本数据类型如表11.1所示
public class IntergerDaemo { public static void main(String[] args) { // TODO Auto-generated method stub int num = Integer.parseInt(\"456\"); //将字符串转换为int类型 Integer iNum = Integer.valueOf(\"456\"); //创建一个intefer对象 System.out.println(\"int数据与Integer对象的比较：；\
public class DoubleDemo { public static void main(String[] args) { // TODO Auto-generated method stub Double dNum =Double.valueOf(\"3.14\"); //判断是否为非数字值 System.out.println(\"3.14是否为非数字值：\"+Double.isNaN(dNum.doubleValue())); System.out.println(\"3.14转换为int的值为\"+dNum.intValue());//转换为int类型 //判断大小 System.out.println(\"值为3.14的Double对象与3.14的比较\"+dNum.equals(3.14)); //转换为十六进制 System.out.println(\"3.14转换为十六进制为：\"+Double.toHexString(dNum)); } }//例题11.3
public class BooleanDemo { public static void main(String[] args) { // TODO Auto-generated method stub Boolean b1 =Boolean.valueOf(\"true\"); //创建Boolean对象 Boolean b2 =Boolean.valueOf(\"ok\"); System.out.println(\"b1:\"+b1.booleanValue()); System.out.println(\"b2:\"+b2.booleanValue()); } }//代码
public class UpperOrLower { public static void main(String[] args) { // TODO Auto-generated method stub Character mychar1=Character.valueOf('A'); Character mychar2=Character.valueOf('a'); if(Character.isUpperCase(mychar1)) { System.out.println(mychar1+\"是大写字母\"); //转换为小写字母输出 System.out.println(\"转换为小写字母的结果：\"+Character.toLowerCase(mychar1)); } if(Character.isLowerCase(mychar2)) { System.out.println(mychar1+\"是小写字母\"); //转换为大写字母输出 System.out.println(\"转换为小写字母的结果：\"+Character.toUpperCase(mychar2)); } }}//例题11.5
11.2.1：数字格式化:DecimalFormat类数字化格式化在解决实际问题时应用非常普遍，如表示某超市的商品价格需要保留两位有效数字。数字格式化操作主要针对的是浮点型数据，包括double型和float型数据。在Java中使用Java.test Decimal format格式化数字。本节将着重讲解Decimal format类在Java中。没有格式化的数据将遵循以下原则：1.如果数据绝对值大于0.001并且小于10000000，使以常规小数形式表示2.如果数据绝对值小于0.001并且小于10000000，使用科学计数法表示由于上述输出格式不能满足解决实际问题的要求，通常将结果格式化为指定形式后输出。在Java中可以使用decimal format类进行格式化操作。decimal format类是number format的一个子类，用于格式化十进制数字。它也可以将一些数字格式化为整数，浮点数，百分数等。通过使用该类可以为要输出的数字加上单位或控制数字的。精度一般情况下，可以在实例化decimal format对象时传递数字格式，也可以通过decimal format类中的apply Parttner（）方法来实现数字格式化。当格式化数字时。可在的decimal format类中使用一些特殊字符构成一个格式化模板，使数字按照一定的殊字符规则进行匹配。表11.7列举了格式化模板中的特殊字符及其所代表的含义。
1三角函数
2.指数函数
3.取整函数
4.取最大值、最小值、绝对值
11.2.2：Math类:math类提供了众多数学函数方法，主要包括三角函数方法指数函数方法取整函数方法取最大值最小值以及平均值函数方法。这些方法都被定义为static形式，所以在程序应用中比较简便，可以使用如下形式调用。
public class TrigonometricFunction { public static void main(String[] args) { // TODO Auto-generated method stub System.out.println(\"90度的正弦值为：\"+Math.sin(Math.PI/2)); System.out.println(\"0度的余弦值：\"+Math.cos(0)); System.out.println(\"90度的正弦值为：\"+Math.tan(Math.PI/3)); //取2的平方根与2商的反正弦 System.out.println(\"取2的平方根与2商的反正弦\"+Math.asin(Math.sqrt(2)/2)); //取2的平方根与2商的反余弦 System.out.println(\"取2的平方根与2商的反余弦\"+Math.asin(Math.sqrt(2)/2)); System.out.println(\"1的反正切值\"+Math.atan(1)); System.out.println(\"120度的弧度制\"+Math.toRadians(120.0)); System.out.println(\"Π/2的角度值\"+Math.toDegrees(Math.PI/2)); } }//例题11.7
public class ExceponentFunction { public static void main(String[] args) { // TODO Auto-generated method stub System.out.println(\"e的平方值\"+Math.exp(2)); System.out.println(\"以e为底的2的对数值\"+Math.log(2)); System.out.println(\"以10为底2的对数值\"+Math.log10(2)); System.out.println(\"4的平方根值\"+Math.sqrt(4)); System.out.println(\"8的立方根值\"+Math.cbrt(8)); System.out.println(\"2的2次方值\
public class IntFunction { public static void main(String[] args) { // TODO Auto-generated method stub System.out.println(\"使用ceil（）方法取整\"+Math.ceil(5.2)); System.out.println(\"使用floor（）方法取整\"+Math.floor(2.5)); System.out.println(\"使用rint（）方法取整\"+Math.rint(2.7)); System.out.println(\"使用rint（）方法取整\"+Math.rint(2.5)); //将参数加上0.5后返回最接近的整数 System.out.println(\"使用round（）方法取整\"+Math.round(3.4f)); //将参数加上0.5后返回最接近的整数，并且将结果强制转换为长整型 System.out.println(\"使用round（）方法取整\"+Math.round(2.5)); } }//例题11.9
11.2.3：Random类:random类是GDP中随机数生成器类，可以通过实例化一个random对象创建一个随机数生成器，语法如下。
11.2.4：BigInterger类:big integer类的数字范围较integer类的数字范围要大得多。前文介绍过，intent类是int的包装类，int的最大值为2的31次方减1，如果要计算更大的数字，使用intent类就无法实现了。所以Java中提供了 big integer类来处理更大的数字。big integral支持任意精度的整数，也就是说，在运算中big integer类可以准确的表示任何大小的整数值而不会丢失信息。在big integer类中封装了多种操作。除了基本的加减乘除，这些操作还提供了绝对值相反数最大公约数以及判断是否为质数等操作。使用big intent类可以实例化一个对象，并自动调用相应的构造函数。 big integer具有更多构造函数，但是最直接的一种方式是参数以字符串形式代表要处理的数字。
11.2.5：BigDecimal类:big December类和big integer 类都能实现大数字的运算。不同的是，big December类加入了小数的概念，一般的float型和double型数据只可以用来做科学计算或者工程计算，但由于在商业计算中要求数字精度比较高，所以要用到big decimal类。bigdecimal支持任何精度的定点数，可以用它来精确计算货币值。在big decimal类中常用的两个构造方法，如表11.8所示。
11.2：数字处理
import java.util.Random; public class RandomDemo { public static void main(String[] args) { // TODO Auto-generated method stub Random r = new Random(); //随机产生一个整数 System.out.println(\"随机产生一个整数\"+r.nextInt()); //随机产生一个大于等于0且小于10的整数 System.out.println(\"随机产生一个大于等于0且小于10的整数\"+r.nextInt(10)); //随机产生一个布尔型的值 System.out.println(\"随机产生一个布尔型的值\"+r.nextBoolean()); //随机产生一个双精度浮点型的值 System.out.println(\"随机产生一个双精度浮点型的值\"+r.nextDouble()); //随机产生一个单精度浮点型的值 System.out.println(\"随机产生一个单精度浮点型的值\"+r.nextFloat()); //随机产生一个概率密度为高斯分布的双精度浮点型的值 System.out.println(\"随机产生一个概率密度为高斯分布的双精度浮点型的值\"+r.nextGaussian()); } }//例题11.11
import java.math.BigInteger; public class BigIntegerDemo { public static void main(String[] args) { // TODO Auto-generated method stub BigInteger b1 =new BigInteger(\"987654321987654321\"); BigInteger b2 =new BigInteger(\"123456789123456789\"); System.out.println(\"加法操作：\"+b1.add(b2)); System.out.println(\"减法操作：\"+b1.subtract(b2)); System.out.println(\"乘法操作：\"+b1.multiply(b2)); System.out.println(\"除法操作：\"+b1.divide(b2)); System.out.println(\"取商：\"+b1.divideAndRemainder(b2)[0]); System.out.println(\"取余数：\"+b1.divideAndRemainder(b2)[1]); System.out.println(\"做2次方操作：\"+b1.pow(2)); System.out.println(\"取相反数操作：\"+b1.negate()); } }//例题11.12
import java.math.BigDecimal;import java.math.RoundingMode; public class BigDecimalDemo { public static void main(String[] args) { // TODO Auto-generated method stub //11.2.4 BigDecimal BigDecimal b1=new BigDecimal(\"0.728382834535\"); BigDecimal b2=new BigDecimal(\"0.00045353\"); System.out.println(\"两个数字相加结果：\"+b1.add(b2)); System.out.println(\"两个数字相减结果：\"+b1.subtract(b2)); System.out.println(\"两个数字相乘结果：\"+b1.multiply(b2)); //除法运算，商小数点后保留9位，并将结果进行四舍五入操作 System.out.println(\"两个数字相除，保留小数点后9位：\
11.3.1：控制台输出字符:system 类提供了标准输入标准输出的和错误输出流。也就是说，system类提供了三个静态对象，in out和err。本书中的代码多次使用了这些对象。最常见的是out对象。在控制台输出字符串输出的字符有两种：1.会自动换行2.不会自动换行print方法与println方法输出的对比效果如表11.12所示。
113.2：计时
11.3：System类::system 类是jdk中提供的系统类，该类用final修饰的，所以不允许被继承。system类提供了很多系统层面的操作方法，并且这些方法全部都是静态的。system类提供的较常用方法，如表11点11所示。本节重点讲解利用system 类控制台输出和计时这两个操作。
public class SystemTimeDemo { public static void main(String[] args) { // TODO Auto-generated method stub long start = System.currentTimeMillis();//程序开始时间 String str =null;//创建null字符串 for(int i=0;i<10000;i++) { //循环10000次 str+=i;//字符串与循环变量拼接 } long end = System.currentTimeMillis(); System.out.println(\"循环用时：\"+(end-start)+\"毫秒\");//记录循环时间 } }//例题11.14
11.4：Scanner类:与c语言不同，java从控制台中读取用户输入的值，用到的不是一行可以直接使用的代码，而是由一个叫Scanner的类来实现的。Scanner类提供了如表11.13所示的几种常用的方法。
11.5.1：Date类:date类用于表示日期时间，使用该类表示时间需要使用其构造对象，其构造方法及其说明如表11.14所示。上述代码System类的currentTimeMi拉力赛（）方法主要用来获取当前系统时间距标准时间的毫秒数。另外，这里需要注意的是，创建Date对象时使用的long型整数，而不是double型，这主要是因为double类型可能会损失精度。date类的常用方法及其说明如表11.15所示。
11.5.2：日期时间格式化:使用GetDateInstance（）方法获取的是所在国家或地区的标准日期格式。datefomart类的常用方法及其说明如表11.16所示
import java.text.DateFormat;import java.text.SimpleDateFormat;import java.util.Date; public class DateTest { public static void main(String[] args) { // TODO Auto-generated method stub //11.5 Date类 Date d1 =new Date(); //当前时间 System.out.println(d1); Date d2 = new Date(1692673826189L); System.out.println(d2); //判断顺序以及获取毫秒数 System.out.println(d1.after(d2)); System.out.println(d1.before(d2)); System.out.println(d1.getTime()); System.out.println(d1); d1.setTime(1782927261567L); System.out.println(d1); //11.5.2 DateFormat 日期时间格式化 //抽象类不能示例化 //第一种：单纯格式化时间模式 DateFormat df1 = DateFormat.getInstance(); System.out.println(df1.format(d1)); //第二种：获取精准的时间日期 DateFormat df2 = DateFormat.getDateInstance(); System.out.println(df2.format(d1)); DateFormat df3 = DateFormat.getDateTimeInstance(); System.out.println(df3.format(d1)); //书上举例 DateFormat df = DateFormat.getInstance(); System.out.println(df.format(new Date()));//将当前日期按照DateFormat类默认格式输出 //使用他的子类简单实例化 DateFormat df4 = new SimpleDateFormat(\"yyyy年MM月dd日 HH时mm分ss秒\"); System.out.println(df4.format(new Date())); }}
import java.text.SimpleDateFormat;import java.util.Calendar;import java.util.Date; public class CountDown { public static void main(String[] args) { System.out.println(\"——————————共和国建立100周年倒计时——————————\"); Date date = new Date(); // 当前时间 // 创建SimpleDateFormat对象，指定目标格式 SimpleDateFormat simpleDateFormat = new SimpleDateFormat(\"yyyy年MM月dd日\"); // 调用format方法，格式化时间，转换为指定方法 String today = simpleDateFormat.format(date); System.out.println(\"今天是\
11.5.3：Canlendar类:Calendar类提供的常用字段及其说明如表11.19所示
11.5：日期时间类
11.6.1：执行本地命令:exec（）方法会返回一个Proocess对象。就是进程类，process类的常用方法如表11.22所示
11.6.2：查看内存:Runtime类可以通过freememory方法查看当前java虚拟机可用内存的剩余量
11.6:Runtime类:Runtime类的常用方法如表11.21所示
import java.io.BufferedReader;import java.io.IOException;import java.io.InputStream;import java.io.InputStreamReader; public class RuntimeExecDemo { public static void main(String[] args) { Runtime r = Runtime.getRuntime(); // 获取本地Runtime对象 try { Process p = r.exec(\"help\"); // 执行help命令，获取进程对象 InputStream is = p.getInputStream(); // 获取进程的字节输入流 // 将字节输入流转化为字符输入流 BufferedReader br = new BufferedReader(new InputStreamReader(is)); String str = null; // 创建null字符串 while ((str = br.readLine()) != null) { // 如果字符流中可以获取非空内容 System.out.println(str); // 打印获取的内容 } } catch (IOException e) { e.printStackTrace(); } }}//例题11.19
public class MemoryDemo { public static void main(String[] args) { // TODO Auto-generated method stub Runtime r = Runtime.getRuntime(); // 获取本地Runtime对象 Integer ints[] = new Integer[10000]; // 创建长度为一万的整型数组 long before = r.freeMemory(); // 获取当前空闲内存数 System.out.println(\"赋值前空闲内存字节数：\
第11章：常用类库
import java.util.Random;import java.util.Scanner; public class ScannerDemo { public static void main(String[] args) { // TODO Auto-generated method stub Random r = new Random(); int num =r.nextInt(100); int input=-1; Scanner sc =new Scanner(System.in); while(true) { System.out.println(\"猜一猜随机数字多少？\"); input=sc.nextInt(); if(input>num) { System.out.println(\"你输入的数字大了！\"); }else if(input<num) { System.out.println(\"你输入的数字小了！\"); }else if(input==num) { break; }else { System.out.println(\"你输入的数字有误！\"); } } System.out.println(\"恭喜你答对了！\"); sc.close(); } }//例题11.15
12.1：集合类概述：java.util包中提供了一些集合类，这些集合类又被称为容器，提到容器不难想到数组。集合类与数组的不同之处在于：数组长度是固定的，集合的长度是可变的。数组用来存放基本数据类型，集合用来存放对象引用。常用的集合有List集合、Set集合和Map集合，其中List集合继承了Collection接口，各接口还提供了不同的实现类。上述集合类的继承关系如图12.1所示
12.2：Collection接口：Collection接口是层次结构中的根接口，构成Collection的单位称为元素。Collection接口通常不也能直接使用，但该接口提供了添加元素、删除元素、管理数据的方法。由于List接口与Set接口都继承了Collection接口，因此这些方法对List集合与Set集合是通用的。Collection接口的常用方法如表12.1所示。
12.3.1：List接口：List集合包括List接口继承了Collection接口，因此包含Collection接口中的所有方法。此外List接口还定义了以下两个非常重要的方法：get（int index）：获得指定索引位置的元素set（int index，Object obj): 将集合中指定索引的位置的对象修改为指定的对象。
12.3.2：List接口的实现类：ArrayList类与LinkedList类。
12.3：List集合
package twlveth; import java.util.ArrayList;//导入ArrayList类 import java.util.List;//导入List类public class Gather { public static void main(String[] args) { // TODO Auto-generated method stub List<String> list = new ArrayList<>(); //创建集合对象 list.add(\"a\"); //向集合添加元素，字符或者字母，数字均可。不过创建对象时要看清类型 list.add(\"b\"); list.add(\"c\"); int i = (int) (Math.random()*list.size()); //获得0~2之间的随机数，Math方法 System.out.println(\"随机获取集合中的元素：\" + list.get(i)); list.remove(2); //将指定索引位置的元素从集合中移除 System.out.println(\"将索引是'2'的元素从集合移除后，集合中的元素是：\"); for (int j = 0; j < list.size(); j++) { //循环遍历集合 System.out.println(list.get(j)); } } } //例题12.2
1.HashSet类实现Set接口，由哈希表（实际上是一个HashMap实例）支持。它不保证Set集合的迭代顺序，特别是它不保证该顺序恒久不变。此类允许使用null元素。
TreeSet类不仅实现了Set接口，还实现了java.util.SortedSet接口，因此TreeSet类实现的Set集合在遍历集合时按照自然顺序递增排序，也可以按照指定比较器递增排序，即可以通过比较器对用TreeSet类实现的Set集合中的对象进行排序。TreeSet类的新增方法如表12.2所示
12.4：Set集合：Set集合中的对象不按特定的方式排序，只是简单地把对象加入集合中，但Set集合中不能包含重复对象。Set集合由Set接口的实现类组成。Set接口继承了collection接口，因此包含Collection接口的所有方法。
12.5.1：Map接口Map接口提供了将key映射到值的对象。一个映射不能包含重复的key，每个key最多只能映射到一个值。除集合的常用方法外，Map接口还提供了如表12.3所所示的特殊方法。
12.5.2：Map接口的实现类Map接口常用的实现类有HashMap类和TreeMap类1.HashMap类是基于哈希表的Map接口的实现，此实现提供所有可选的映射操作。并允许使用null值和null件，但必须保证键的唯一性。HashMap类通过哈希表对其内部的映射关系进行快速查找。此类不保证映射的顺序，但特别是它不保证该顺序恒久不变。2. Tree map类不仅实现了map接口，还实现了Java.utill.Sorted map接口，因此集合中的映射关系具有一定的顺序。但在添加、删除和定位映射关系时，Tree map类比Hashmap类性能稍差。由于Tree map类实现了Map接口集合中的映射关系，是根据键对象按照一定的顺序排列的，因此不允许键对象是null。
12.5：map集合Map集合没有继承Collection接口，其提供的是key到value的映射。Map集合中不能包含相同的key，每个key只能映射一个value。key还决定了存储对象在映射中的存储位置，但不是由key对象本身决定的，而是通过一种“散列技术”进行处理，产生一个散列码的整数值。散列码通常用作一个偏移量，该偏移量对应分配给影射的内存区域的起始位置，从而确定存储对象在映射中的存储位置。Map集合包括Map接口以及Map接口所有的实现类。
第12章：集合类
package twlveth;import java.util.*; //导入java.util包，其他实例都要添加该语句public class Muster { // 创建Muster类 public static void main(String args[]) { Collection<String> list = new ArrayList<>(); // 实例化集合类对象 list.add(\"《Java从入门到精通》\"); // 向集合添加数据 list.add(\"《零基础学Java》\"); list.add(\"《Java精彩编程200例》\"); Iterator<String> it = list.iterator(); // 创建迭代器，以此来遍历集合的对象 while (it.hasNext()) { // 判断是否有下一个元素 String str = (String) it.next(); // 获取集合中元素 System.out.println(str); } }}//例题12.1
13.2：泛型泛型实质上就是使程序员定义安全的类型。在没有出现泛型之前，Java也提供了对object类型的引用“任意化” 操作，这种“任意化”操作就是对object类型引用进行向下转型及向下转型操作，但某些强制类型转换的错误也许不会被编译器捕捉，而在运行后出现异常，可见强制类型转换存在安全隐患，所以在此提供了泛型机制。
第13章：枚举类型与泛型
Java从入门到精通
收藏
收藏
0 条评论
回复 删除
下一页
