Head First Java笔记

⼀句话的事⼉，Headfirst设计模式head first 设计模式，是⽐较有趣的⼀本设计模式的书。

在学校⾥看书和在⼯作时看书，意义是不⼀样的。

在学校时是为读书⽽读书，我们可以从0到1，我们有的是时间。

但是⼯作后就不⼀样。

我觉得这时的书更像是打通⾃⼰任督⼆脉的武功秘诀。

在平时⼯作中，杂七杂⼋地学了⼀些东西，但是却不能融会贯通。

所以还需要通过书来厘清你的思路。

这是写本⽂的出发点，也是我的碎碎念！看完该书后，转换成⾃⼰的语⾔，再表达出来，可能有错（那是⼀定的），但是，有总⽐没有好。

如果有同学能够从中得到些启发，也算是⾃⼰的⼀种幸运吧！我竟试图以⼀句话来描述⼀个设计模式！1. 策略模式！将统⼀的东西作为基类，可变的东西⾏为独⽴出来，在基类中通过变量进⾏引⽤，通过委托变量的⽅式，使⽤setter⽅法将委托变量改变，使其具有⾏为可变性。

⾯向接⼝编程，⽽⾮⾯向类编程。

其好处是，⽤同样的接⼝，通过不同⾏为类的传⼊产⽣不同的效果，便以改变⾏为变得容易。

2. 观察者模式！类似于发布-订阅模式。

存在注册服务，通知的过程。

其实现⽅式可以理解为，注册服务时，将观察者加⼊到队列当中，当主题发⽣变更时，由主题主动依次从观察者队列中依次调⽤，从⽽达到通知主动推送的作⽤。

其好处是，观察者随时注册观察可以实时收到消息，⽽被观察者对此⼀⽆所知，从⽽在达到通知的同时也解藕了。

3. 装饰者模式！以某对象为主要对象，⽣成后，将其传⼊装饰者构造函数中，经过装饰后，再⾏输出的模式。

该模式，可以许多散乱的⽅法独⽴组装出来，⽽不会影响其他变化，该模式是通过继承来实现的。

典型的装饰者模式运⽤，java io 类的继承，有多个主类，及多个装饰类，从⽽⽅便⽤户操作想要的⽅法。

其好处是，在⼤⽅向不变的情况下，可以反复更改主要的⾏为结果，对于⼀些附加类的变化，可以很⽅便地通过该模式进⾏数据再加⼯。

4. ⼯⼚模式！分为简单⼯⼚模式-⼯⼚模式-抽象⼯⼚模式。

《HeadFirst设计模式》阅读笔记.第七章...2010-01-21《Head First设计模式》阅读笔记.第七章文章分类:Java编程1.适配器（Adapter）模式部分*OO适配器和真实世界的适配器扮演者同样的角色：将一个接口转换成另一个接口，以符合客户的期望。

*适配器（Adapter）类看起来很像命令（Command）模式中命令接口的实现类，只不过它不被作为参数传递。

Java代码1.----DuckAdapter类----2.public class DuckAdapter implements Turkey {3.private Duck duck;4.5.public DuckAdapter(Duck duck) {6.this.duck = duck;7.}8.9.public void goggle() {10.duck.quack();11.}12.13.public void fly() {14.duck.fly();15.}16.}17.------------适配器模式：将一个类的接口，转换成客户希望的另一个接口。

适配器让原本接口不兼容的类合作无间。

*适配器模式可以让客户从实现的接口解耦。

*适配器（Adapter）模式充满着良好的OO设计原则：使用对象组合，以修改的接口包装被适配者；这种做法还有额外的优点，那就是被适配者的任何子类都可以搭配着适配器使用。

*适配器（Adapter）分为“对象（Object）”适配器和“类（Class）”适配器两种。

*在类适配器中，适配器继承了目标（Target）和被适配者（Adaptee）；而对象适配器中，适配器利用组合的方式将请求传送给被适配者。

*类适配器是基于多重继承实现的，因为Java不支持多重继承，因此无法做到。

*由于类适配器使用了继承的方式，所以它的优点是不需要整个实现被适配者，必要的时候还可以覆盖被适配者的行为。

Java代码1.----练习。

head first java读后感
《Head First Java》读后感
《Head First Java》是一本非常值得推荐给想要学习Java编程的读者的书籍。

在阅读过程中，我感受到了作者真诚的教学态度和丰富的编程经验。

首先，这本书以轻松幽默的方式向读者介绍了Java编程的基础知识。

不同于其他枯燥乏味的编程教材，本书采用了大量有趣的图片、插图和漫画，使得学习过程变得有趣又易懂。

通过生动的场景和形象的比喻，读者能够更容易地理解抽象的编程概念。

其次，本书的学习方法也非常实用。

每个章节都以问题和挑战开始，通过解答这些问题和挑战来逐步学习和掌握Java编程技巧。

这种基于问题驱动的学习方法让读者能够更加深入地理解和应用所学知识，而不仅仅是被动地接受语法和规则。

另外，本书还有很多实用的实例和案例，让读者能够将所学知识应用到实际的项目中。

这些案例涵盖了各种不同的应用场景，从简单的Hello World程序到复杂的图形界面和网络应用程序，读者可以通过实践来提高自己的编程能力。

总体而言，我认为《Head First Java》是一本非常好的Java入门书籍。

无论是初学者还是有一定编程基础的读者，都可以从中受益匪浅。

这本书不仅教授了Java的语法和规则，更重要的是培养了读者良好的编程思维和解决问题的能力。

我强烈推荐给所有对Java编程感兴趣的读者阅读这本书。

Java-课堂笔记-第一章至第八章知识点梳理1.控制台程序开发1.1 开发Java程序的步骤（1）编写源程序：Java源程序文件后缀名.java（2）编译源程序：使用javac命令编译源程序，编译之后的文件后缀名.class （3）运行使用java命令运行编译之后的.class文件1.2 程序开发环境记事本、Eclipse或MyEclipse1.3 控制台输入/输出（1）从控制台输入信息使用Scanner对象第一步：创建一个Scanner扫描器对象Scanner input = new Scanner(System.in);第二步：导入Scanner包import java.util.Scanner;第三步：获取从控制台输入的整数int num = input.nextInt();获取从控制台输入的小数double num = input.nextDouble();获取从控制台输入的字符char ziFu = input.next().charAt(0);获取从控制台输入的字符串String str = input.next();（2）从控制台输出信息使用System.out.print();System.out.println();转义字符：\n：换行\t：一个制表符（8个空格）1.4 程序注释Java中的注释有3种：（1）单行注释：//这里是注释内容（2）多行注释：/*这里是注释内容*/（3）文档注释：/**这里是注释内容*/1.5 程序调试2.变量和运算符2.1 变量变量：变量就是变化的量，是数据存储空间的表示，即数据在内存空间地址的别名（1）变量的声明语法：数据类型变量名;举例：int score;//声明一个int类型的变量score，保存成绩（2）变量的赋值（初始化）基本数据类型的赋值使用“=”赋值语法：变量名 = 值；举例：score = 98；引用数据类型使用new关键字语法：数据类型变量名 = new 数据类型（）；举例：Scanner input = new Scanner(System.in);2.2 常量2.3 运算符（1）赋值运算符：=、+=、-=、*=、/=、%=举例：sum += i;//相当于sum = sum + i;（2）算术运算符：+、-、*、/、%（3）关系运算符：>、<、>=、<=、==、!=（4）逻辑运算符：&&、||、!（5）自增运算符：i++或++ii++ 相当于 i = i + 1;（6）自减运算符：i--或--ii-- 相当于 i = i - 1;（7）三目运算符：?:3.数据类型与数组3.1 数据类型（1）基本数据类型整型：byte、short、int、long浮点型：float、double字符型：char布尔型：boolean（2）引用数据类型String、数组、类（class）、接口（3）数据类型转换自动数据类型转换自动数据类型转换的条件1.目标类型和源类型数据类型要兼容，数值类型（整型和浮点型）相互兼容2.目标类型要大于源类型，double型可以存放int型数据，因为double型变量分配的空间宽度足够存储int型变量强制数据类型转换语法：（数据类型）表达式；3.2 数组（1）数组的基本用法数组声明语法：数据类型[] 数组名;或数据类型数组名[];数组分配空间语法：数组名 = new 数据类型[数组长度];数组赋值静态赋值：给数组元素单个赋值如：scores[0] = 98;scores[1] = 87;动态赋值：使用for循环动态给数组元素赋值如：for(int i=0;i<scores.length;i++){ //每次循环把输入的数值赋值给数组元素scores[i] = input.nextDouble();}直接创建数组：方式一：数据类型[] 数组名={值1，值2，值3，....}；方式二：数据类型[] 数组名=new 数据类型[]{值1，值2，值3，..};访问数组元素：语法：数组名[下标值];获取数组长度：语法：数组名.length;（2）数组应用数组排序：1.import java.util.Arrays;//导入Arrays工具包2.Arrays.sort(数组名);求最大值：（见第七章数组课堂笔记）求最小值：（见第七章数组课堂笔记）4.流程控制语句4.1 分支结构（选择结构）（1）if选择结构if(判断条件){执行语句；}（2）if-else选择结构if(判断条件){执行语句1；}else{执行语句2；}（3）多重if选择结构if(判断条件1){执行语句1；}else if(判断条件2){执行语句2；}else if(判断条件3){执行语句3；}else{执行语句4；}（4）嵌套if选择结构if(判断条件1){if(判断条件2){执行语句1；}else{执行语句2；}}else{执行语句3；}（5）switch选择结构switch(表达式){case 常量1:代码块1；break;case 常量2:代码块2；break;case 常量3:代码块3；break;.......default:代码块n；break;}4.2 循环结构（1）while循环while(循环条件){循环操作；}特点：先判断，后执行（2）do-while循环do{循环操作；}while(循环条件);特点：先执行，后判断（3）for循环for(循环初始变量;循环条件;循环变量的更新){循环操作；}循环次数固定的时候，优先选用for循环while、do-while、for三种循环的对比，需要重点看下4.3 跳转语句（1）break用在switch选择结构中，表示跳出switch选择结构用在循环结构中，表示跳出整个循环或结束整个循环用在二重循环结构中，表示结束内层循环，继续执行外层循环（2）continuecontinue只能用在循环结构中，表示结束本次循环，进入下一次循环用在二重循环结构中，表示结束内层循环的本次循环，进入下一次循环（3）return。

headfirst设计模式java_吐血整理HeadFirst设计模式大全首先，要理解Head First设计模式，需要明白设计模式的概念。

设计模式是在软件开发中经过实践验证的解决方案，它们是解决特定问题的经验总结。

Head First系列是一本非常经典的计算机科学图书系列，其中《Head First设计模式》专门介绍了23种常见的设计模式，并以Java语言进行讲解。

本书从实际问题出发，用生动形象的方式讲解设计模式，以帮助读者更好地理解和应用这些设计模式。

下面将介绍一些书中提到的设计模式和其在Java编程中的应用。

1. 策略模式（Strategy Pattern）：策略模式将一组行为封装成策略类，使其在运行时可以相互替换。

在Java中，可以使用接口来定义策略，不同的策略类实现相同的接口，根据不同情况选择不同的策略。

2. 观察者模式（Observer Pattern）：观察者模式定义了对象间的一种一对多的关系，当一个对象状态改变时，所有依赖它的对象都会被通知并自动更新。

在Java中，可以使用java.util.Observable类和java.util.Observer接口来实现观察者模式。

3. 装饰者模式（Decorator Pattern）：装饰者模式动态地将责任附加到对象上，通过创建一个装饰者类来包装原始对象，以提供额外的功能。

在Java中，可以通过继承原始对象并添加额外功能的方式来实现装饰者模式。

4. 工厂模式（Factory Pattern）：工厂模式定义了一个创建对象的接口，但由子类决定要实例化的类是哪一个。

在Java中，可以使用工厂方法模式来实现，通过定义一个工厂接口和具体的工厂类来创建实例。

5. 单例模式（Singleton Pattern）：单例模式确保一个类只有一个实例，并提供一个全局访问点。

在Java中，可以使用私有构造函数和静态方法来实现单例模式。

以上只是其中一部分介绍的设计模式，还有其他如适配器模式、迭代器模式、模板方法模式等。

第⼀章-Java基础笔记Java语⾔的概述Java是⼀门⾯向对象的语⾔,Java相对于C语⾔来说学习相对简单,它主要的三⼤特点就是:封装、继承、多态,并且只需要进⾏⼀次源码编译,在任何装有对应版本的JVM 虚拟机环境的计算机下运⾏;Java的三个版本JavaSE主要⽤于桌⾯应⽤的开发JavaME主要⽤于嵌⼊式系统的开发JavaEE主要⽤于企业级的WEB端开发和服务器开发Java环境介绍JDK - 提供了开发者的⼀些⼯具包,并包含了[JRE和JVM]JRE - Java的运⾏环境,提供了运⾏时需要的类库,并包含了[JVM]JVM - Java的虚拟⼀块内存区域,⽤于执⾏Java的代码Java跨平台交互图Java代码的运⾏机制后缀点java的⽂件会通过 javac命令进⾏⽂件的编译成⼀个能够被JVM读懂的字节码⽂件,通过加载、校验、初始化的过程都内存中，通过JVM寄存器读取⽂件中的⾏号，进⾏执⾏相关代码；注释注释是为了在编写程序时对某个类、⽅法或是⼀段代码进⾏功能作⽤的说明，它不会被编译成代码执⾏，只是起到⼀个描述作⽤，便于对代码的理解；Java中的注释分为3种：单⾏注释：//多⾏注释：/* */⽂档注释：/** */对注解的内容⽣成JavaDoc⽂档DOS命令进⼊到要⽣成Doc⽂档的层级⽬录,执⾏:javadoc -encoding UTF-8 -charset UTF-8 ⽂件名称/*** @Author JavaCat7* @Description 这是⼀个⽂档注释*/public class Demo{/*** @Parameter args 对参数的描述* @Description 这是⼀个⽂档注释*/public static void main(String[] args){//这是⼀个单⾏注释System.out.println("Hello Java");/*这是多⾏注释这是多⾏注释*/}}标识符每个⼈都有名字,⽽标识符是为了给代码中的类、接⼝、⽅法、变量取⼀个名字，但它们的明⽩是有着严格规范的；规范：每个⼈都有名字,⽽标识符是为了给代码中的类、接⼝、⽅法、变量取⼀个名字，但它们的明⽩是有着严格规范的；**规范：**1.严格区分⼤⼩写；2.开头可以是$ 或 _ 或 A-Z a-z的字母组成,也可以汉字(不会这么⼲);3.可以由数字、字母或者是 $ 或 _ 组成，但数字不能⽤于开始；4.不可以包含特殊字符；5.不能以Java语⾔中的保留字作为命名；6.类名采取⼤驼峰命名法;7.⽅法和变量采取⼩驼峰命名法;8.常量采取⼤学加_进⾏命名;基本数据类型Java是强类型计算机语⾔,所有的变量必须先定义才能使⽤,对于强类型⽽⾔主要就是指的数据安全,强类型的语⾔有很多,⽐如C、C++、python...计算机存储单位换算bit(位) - 是计算内部数据存储的最⼩单元,通过8个⼆进制位进⾏表⽰;byte(字节) - 是计算机中数据处理的基本单位,通常使⽤B来表⽰;8个bit(位) = 1B(字节)1024个B(字节) = 1KB1024个KB = 1MB1024个MB = 1GB....//整数类型byte a = 1;short b = 2;int c = 3;long d = 4L;//⼩数类型float e = 5.0f;duble f = 6.0d;//字符类型char g = 'a';//布尔类型boolean h = true;boolean i = false;数据类型的转换各数值相关数据类型⽀持类型上的转换,既可以把排序级别较低的类型转换成排序级别较⼤的类型,也可以把排序级别较⾼的类型转换成级别较低的类型(但会造成数据的丢失);数据的转换强制类型转换 - 在要转换的变量前使⽤:要转换的对应数据类型如- (int)⾃动类型转换 - 在不同的数值数据类型运算中,它会以排序级别较⾼的数据类型作为基础⾃动转换int number1 = 128;//正常byte的值是 -128 - 127,强制把int类型转换成byte会造成数据的不精确byte number2 = (byte)number1;int number3 = 519;float number4 = 1.0f;//在运算过程中因为float的排序级别⽐int⾼,那么它会⾃动转换成float类型在完成运算float number5 = number3 + number4;变量,静态变量,常量及作⽤域变量是指可以变化的值,通过数据类型和变量名可以在内存中申请⼀块存储的空间,通过内存的引⽤地址可以设置改变内存中存储的值或者修改值,所有的变量必须先赋值才可以使⽤;成员变量成员变量是指在类中与⽅法同级的位置中定义的成员变量,在该位置定义的变量可以不⽤设置值就可以使⽤,因为它会对类进⾏初始化,并完成初始化赋值,就算不给他们赋值也会有默认的初始值,他们的默认初始值都是最⼩的单元;作⽤域成员位置的变量,可以在⾮静态⽅法的所有位置使⽤,如果要在静态⽅法中使⽤,需要先创建对象;public class Variable{int a; //默认为:0float b; //默认为:0.0char c; //默认为:''boolean d; //默认为:false}局部变量局部变量是指在⽅法内部定义的变量,必须要先完成初始化后,才可以被使⽤;作⽤域局部位置的变量,外部⽆法使⽤,只能在⽅法内部使⽤,可以和外部的变量名称相同;public class Variable{int number;public void method(){int number = 3;//可以和成员位置的变量名称相同}}静态变量静态变量是指被static关键字修饰的变量,被修饰的变量⼜称为类变量;作⽤域静态变量可以作⽤域与所有⽅法中,静态变量只能定义在类的成员位置;public class Variable{static int number ;public static void main(String[] arags){System.out.println(number);}public void method(){System.out.println(numbe);}}常量常量是指不能被改变的值,它在创建到成员位置必须要先完成赋值,⼀旦被创建它的值是不允许被更改的;作⽤域它的作⽤域和成员变量相同public class Variable{final int NUMBER = 3.1415926;}静态常量静态常量是指从属于类的常量,在完成初始化以后是不可以被修改的,并且被public所进⾏修饰;作⽤域它的作⽤域和静态变量相同运算符算术运算符int a = 5;int b = 2;int number = a + b; //number = 7;int number = b - a; //number = 3;int number = a * b; //number = 10;int number = a / b; //number = 2,只取整数;double number = a / (double)b; //number = 2.5int number = a % b; //number = 1;⾃增⾃减运算符int a = 1;int b;b = a++; //b = 1; 先把a的值赋值给b,后a进⾏ +1 操作;b = a--; //b = 2; a前⾯进⾏了⾃增那么就是2,先把2赋值给b,然后进⾏ -1 操作;b = ++a; //b = 2; 前⾯a进⾏了⾃减那么就是1,先对a进⾏⾃增加1,然后在赋值给b;b = --a; //b = 1; 前⾯a是2,先对a进⾏⾃减1,在赋值给b;赋值运算符int a = 5;//把 5 赋值给 a;int b = 2;//把 2 赋值给 b;a += b; // a = 7(a+b的结果在赋值给a);a -= b; // a = 3;a *= b; // a = 10;a /= b; // a = 2;a %= b; // a = 1;关系运算符int a = 5;int b = 2;a > b; //truea < b; //falsea >= b; //falsea <= b; //truea == b; //falsea != b; //true逻辑运算符boolean a = true;boolean b = false;a &&b = false;//都true则true,第⼀个条件为false就不会在看第⼆个条件,直接返回falsea ||b = true;//⼀个条件为true则true,第⼀个条件为tre就不看第⼆个条件,直接返回true! a = false;//取反a &b = false;//2个条件都要执⾏a |b = true;三元运算符int a = 5;int b = 5;a ==b ? "等于":"不等于"; //为true返回第⼀个,为false返回第⼆个流程控制语句If语句if语句就是判断条件是否成⽴,成⽴就执⾏if中的代码,不成⽴就不进⼊;boolean flag = true;if(flag){System.out.println("...");}if...else语句if...else语句就是根据判断的条件是否成⽴,成⽴⾛if语句,不成⽴⾛else语句;boolean flag = true;if(flag){System.out.println("成⽴");}else{System.out.println("不成⽴");}if...else if语句if...else if⽀持多条件的判断,只会进⼊⼀个匹配的条件;boolean flag = true;boolean fail = false;if(flag){System.out.println("条件匹配");}else if(fail){System.out.println("条件匹配");}else{System.out.println("条件都不匹配");}switch条件控制语句witch语句从JDK1.7开始可以⽀持匹配:String字符串；注意事项:每个case 后⾯必须跟⼀个数值常量或字符串常量⽤于匹配;匹配的语句后⾯需要加上break关键字,防⽌case穿透;String week = "星期⼀";switch(week){case "星期⼀":System.out.println("今天是星期⼀");break;case "星期⼆":System.out.println("今天是星期⼆");break;case "星期三":System.out.println("今天是星期⼆");break;default:System.out.println("今天星期⼏都不是");}循环控制语句for循环语句for(初始值,条件表达式,更新)for(int i = 1 ; i <= 10 ; i++){System.out.println(i);}增强for循环for(接收类型的变量,表达式)int [] arrays = {1,2,3,4,5,6,7,8,9,10};for(int i : arrays){System.out.println(arrays);}while循环语句while(条件表达式)int number = 1;while(number <= 100){System.out.println(number);number ++;}do...while循环语句do{先把语句执⾏⼀遍}while(条件表达式);boolean flag = true;do{System.out.println("先执⾏⼀遍");flag = false;}while(flag);break和continue关键字break关键字结束循环的意思;for(int i = 1; i <= 100; i++){if(i == 10){System.out.println("打印10后结束循环");break;}}continue关键字跳过当前循环,进⼊下⼀次循环;for(int i = 1 ; i <= 10; i ++){if(i % 2 == 1){continue;}System.out.println("打印:"+i);}⽅法概述:⽅法就相当于使⽤多⾏代码进⾏组合去实现的⼀个功能⽚段,对代码进⾏封装利⽤,可实现多次调⽤;⽅法的定义修饰符返回值⽅法名称(形参形参名称){⽅法体}public class Function{public static void main(String[] arags){}public void method1(){}public void method2(String name,int age){}public static void method3(){}public int method03(){int a = 3;return a;}public int method04(int a,int b){if(a == b){System.out.println(a + "和" + b + "相等");return -1;}return a > b ? a : b;}}⽅法的重载⽅法的重载是指⽅法名称相同,传递的参数类型不同,个数不同,顺序不同与返回值⽆关;这样的⽅法被称为⽅法的重载;public class Function{public int max(int a,int b) {return a > b ? a : b;}public double max(double a,double b){return a > b ? a : b;}}形参和实参形参是指在()内部的参数,实参是指被真实传递的参数;public class Function{public static vid main(String[] args){Function function = new Function();function.max(3,5);}public int max(int a,int b) {return a > b ? a : b;}}可变参数在⽅法的()中我们有时候不知道要传递多少参数,那么我们可以传递⼀个数据类型紧跟后⾯加上...来表⽰;但需要注意的是⼀个⽅法中指允许⼀个可变参,如果有其他类型的参数,那么可变参数需要写在最后⾯;可变参数本质上就是⼀个数组;public class Function{public void method(String name,int... numbers){for(int num : numbers){System.out.println(num);}}}递归递归的本质就是⾃⼰调⽤⾃⼰,它可以解决⼀些业务,但效率和开销较⼤,对⼀些⽐较⼩的运算可以使⽤;//递归求3的阶乘public class Founction{public static void main(String[] args){}public int founction(int number){int result = 1;if(number == result){return result;}return number * founction(number - 1);}}数组数组就是⼀组数据的集合,Java中的数组必须存储和数据类型相符合的值,不允许与定义的数据类型不匹配;⼀旦数组被创建出来,它的长度就不允许被改变,数组有下标(索引)的概念,都是从0开始,如果操作的数据超过数组的长度那么就会报出下标索引越界异常[ IndexOutofBoundsException ];数组的定义int[] array = new int[3];int array[] = new int[3];int array[] = {1,2,3};数组的内存模型图数组的遍历⽅式int[] arr = new int[10];//⽅式⼀for (int i = 0; i < arr.length ; i ++) {System.out.println(arr[i]);}//⽅式⼆for (int num : arr) {System.out.println(num);}⼆维数组int[][] arr = new int[3][2];String[][] strArr = {{"hello","hello"},{"hi","hi","hi",{"java","java","java","java"}}Arrays⼯具类Arrays数组的⼯具类,是jdk已经帮我们提供好的⼀套数据⼯具类,⽅便我们对数据相关进⾏⼀些操作;int[] arr = {3,51,1,33,82,22,55,53};Arrays.toString(arr);//把数组变成⼀个字符串Arrays.sort(arr);//对数组内容进⾏升序排列Arrays.fill(arr,0);//把数组的内容全部进⾏替换为0常见算法冒泡排序public static int[] arr = new int[]{5, 2, 7, 4, 6, 9, 8, 13, 19, 11, 17, 15};//冒泡排序算法public static void popArithmetic(int[] arr) {//⽐较的轮数是数组长度-1for (int i = 0; i < arr.length - 1; i++) {//每次⽐较⼀轮,需要减少1次⽐较的次数for (int j = 0; j < arr.length - i - 1; j++) {//如果前⾯的数据⽐后⾯⼤,那么就交换位置if (arr[j] > arr[j + 1]) {int temp = arr[j];arr[j] = arr[j + 1];arr[j + 1] = temp;}}}System.out.println("最终结果是:" + Arrays.toString(arr));}选择排序public static int[] arr = new int[]{5, 2, 7, 4, 6, 9, 8, 13, 19, 11, 17, 15};//选择排序public static void selectOrderArithmetic(int[] arr) {//⽐较的轮数是数组长度-1for (int i = 0; i < arr.length - 1; i++) {//每⽐较⼀次,需要减少1次⽐较的次数,会把⼩的先往前排for(int j = i+1;j<arr.length;j++){if(arr[i]>arr[j]){int temp = arr[i];arr[i] = arr[j];arr[j] = temp;}}}System.out.println("最终结果是:" + Arrays.toString(arr));}⼆分查找public static int[] arr = new int[]{1, 2, 3 , 4, 6, 7, 8, 13, 19};//2分查找法public static void branchFind(int [] arr,int number){int startNode = 0;int endNode = arr.length-1;int middle = 0;while (startNode <= endNode){//中间的指针由开始节点和结束节点计算得来middle = (startNode+endNode)/2;if(number == arr[middle]){System.out.println("找到了");break;}else if(number < arr[middle]){endNode=middle-1;System.out.println(number+"⼩于中间值,结束节点变更为中间节点-1"); }else if(number > arr[middle]){startNode = middle+1;System.out.println(number+"⼤于中间值,开始节点变更为中间节点+1"); }else{System.out.println("没有找到该元素");break;}}}。

head first javaHead First Java: Unleashing the Power of Java ProgrammingIntroductionHead First Java is a refreshing take on learning Java programming. Written by Kathy Sierra and Bert Bates, this book aims to make learning Java fun and engaging through its unique instructional approach. The book covers essential concepts and fundamentals of Java programming, making it suitable for beginners looking to explore the world of Java. In this document, we will dive deeper into the content and structure of Head First Java, highlighting its key features and benefits.Chapter 1: Breaking the SurfaceThe first chapter of Head First Java sets the tone by introducing the Java programming language and its importance in today's software development industry. It emphasizes the power and versatility of Java, which can run on virtually any device. The chapter also outlines the maintopics covered in the book, such as object-oriented programming, GUI development, and network programming.Chapter 2: A Trip to ObjectvilleThis chapter serves as an introduction to object-oriented programming (OOP), a crucial aspect of Java programming. Through relatable examples and analogies, the authors explain the core concepts, such as classes, objects, attributes, and methods. The chapter also covers the importance of encapsulation and how to create and use objects in Java.Chapter 3: Know Your VariablesIn this chapter, readers are introduced to the concept of variables in Java programming. The authors explain different data types, such as int, double, and boolean, and how to declare and initialize variables. The chapter further explores the scope of variables and the importance of the stack and heap memory.Chapter 4: How Objects BehaveThis chapter delves deeper into how objects behave in Java. Readers learn about reference variables and how objects interact with one another through method calls. The authors also introduce the concept of instance variables and demonstrate how to work with arrays.Chapter 5: Extra-Strength MethodsChapter 5 focuses on methods, which are essential building blocks in Java programming. The authors explain the significance of method parameters, return types, and method overloading. The chapter also covers method calls and demonstrates how to use flow control statements to control the program's execution.Chapter 6: Using the Java LibraryIn this chapter, readers explore the vast collection of pre-built classes and methods provided by the Java Library. The authors guide readers on how to use these classes effectively to solve common programming problems. They cover various topics, including working with strings, using the Math class, and handling exceptions.Chapter 7: Better Living in ObjectvilleThis chapter focuses on enhancing the functionality of objects by creating and working with multiple classes. The authors introduce object-oriented design principles, such as inheritance and polymorphism. Readers also learn how to use interfaces and abstract classes to create flexible and reusable code.Chapter 8: Serious PolymorphismChapter 8 delves deeper into polymorphism, a key aspect of object-oriented programming. The authors explain how polymorphism allows objects of different types to be treated as objects of a common base class. Readers learn about method overriding, dynamic binding, and the power of interfaces in achieving polymorphic behavior.Chapter 9: Life and Death of an ObjectThis chapter explores the lifecycle of objects in Java. The authors explain how objects are created, used, and eventually garbage collected. Readers learn about the importance of constructors, the finalize() method, and object equality. Thechapter also covers memory management and tips for efficient object creation.Chapter 10: Numbers MatterIn Chapter 10, the focus shifts to numerical data and how to work with numbers in Java. The authors explain the different numeric data types, such as byte, short, and long, and how to perform mathematical operations. Readers also learn about type conversion and formatting numbers using the DecimalFormat class.Chapter 11: Risky BehaviorThis chapter addresses an important aspect of programming: handling errors and exceptions. The authors explain what exceptions are, how they occur, and how to handle them effectively using try-catch blocks. Readers also learn about exception propagation, creating custom exceptions, and best practices for exception handling.Chapter 12: Network SoupThe final chapter of Head First Java explores the world of network programming. The authors introduce the Socket class and teach readers how to create client-server applications. Topics covered include TCP/IP, HTTP, and using URLs. The chapter concludes by discussing the importance of threads in network programming.ConclusionHead First Java provides an immersive and interactive learning experience for aspiring Java programmers. Through its unique instructional approach, the book makes it easier to understand complex concepts while keeping readers actively engaged. By covering essential topics such as object-oriented programming, GUI development, and network programming, the book equips readers with the knowledge and skills necessary to begin their journey into the world of Java programming. Whether you're a beginner or an experienced programmer looking to refresh your Java skills, Head First Java is a must-read resource.。

java基础教程书籍
1.《Head First Java》java入门书籍
《Head First Java》是本完整的面向对象（object-oriented，OO）程序设计和Java的学习指导。

此书是根据学习理论所设计的，
让你可以从学习程序语言的基础开始一直到包括线程、网络与分布式程序等项目。

最重要的，你会学会如何像个面向对象开发者一样去思考。

但如果你真地想要好好地学习Java，你会需要《Head First Java》。

这本书可是Amazon编辑推荐的十大好书之一！强烈推荐学习此书，
非常适合初学者入门。

2.《Java从入门到精通》适合自学者
《Java从入门到精通》这本书主要针对java基础，对于没有学过java的人才说，是一个不错的选择。

通过这本书，大家可以从零
开始，慢慢来学习，而且实操很多，不会让你看到最后出现只会理论的情况。

为什么说培训的人不用看呢？因为这本书上的内容和许多培训机构的书籍有很多重复的地方，所以参加培训的同学就可以不看了。

3.《Thinking in java》(中文名：《Java编程思想》）适合中级自学者和培训者
《Java编程思想》可以说是最经典的java著作，是所有java
程序员必备教科书。

这本书不管是正在学习还是已经工作许多年的程序员，都可以从这本书中得到你想要的东西。

这本书具有教材和工具书的作用，就像一本字典，想知道什么都可以从中查询。

虽然这本书很好，但并不建议初学者学习，对于初学者难度较大。