java面向对象程序设计电子书 java编程思想pdf下载
大家好，关于java面向对象程序设计电子书很多朋友都还不太明白，不过没关系，因为今天小编就来为大家分享关于java编程思想pdf下载的知识点，相信应该可以解决大家的一些困惑和问题，如果碰巧可以解决您的问题，还望关注下本站哦，希望对各位有所帮助！
用JAVA面向对象方法进行程序设计
public class QuickSort{
private int[] data;
QuickSort(int[] data){
this.data= data;
}
public void quickSort(){
recQuickSort(data, 0, data.length- 1);
}
private void recQuickSort(int[] data, int low, int high){
//设置两个滑标
int lowCursor= low+ 1;
int highCursor= high;
//交换时的临时变量
int temp= 0;
//比较枢值,设为数组的第一个值
int medi= data[low];
while(true){
//从低端开始查找，确定大于数 data[low]所在的位置
while(lowCursor< high&& data[lowCursor]< medi){
lowCursor++;
}
//从高端开始查找，确定小于数 data[low]所在的位置。这里要使用>=判断确定小于值
while(highCursor> low&& data[highCursor]>= medi){
highCursor--;
}
//两游标位置出现越界，退出循环
if(lowCursor>= highCursor){
break;
}
//交换 data[highCursor]和 data[lowCursor]位置数据
temp= data[highCursor];
data[highCursor]= data[lowCursor];
data[lowCursor]= temp;
}
//由 while循环退出条件可知：lowCursor> highCursor
//当前 lowCursor指向右侧大于 data[low]的第一个位置;
//而 highCursor指向左侧小于 data[low]的第一个位置，所以需要交换 data[low]和
// data[highCursor]的值
data[low]= data[highCursor];
data[highCursor]= medi;
//递归运算左半部分
if(low< highCursor){
recQuickSort(data, low, highCursor);
}
//递归运算右半部分
if(lowCursor< high){
recQuickSort(data, lowCursor, high);
}
}
//打印数组
public void display(){
for(int i= 0; i< data.length; i++){
System.out.print(data[i]+"");
}
System.out.println();
}
//产生一个包含size个随机数的数组
public static int[] getData(int size){
int data[]=new int[size];
for(int i= 0; i< data.length; i++){
data[i]=(int)(1+Math.random()*54);//产生一个1-54的随机数,Math.random()是产生0-1的数.
}
return data;
}
//测试
public static void main(String[] args){
int data[]=getData(10);
QuickSort sort= new QuickSort(data);
sort.display();
sort.quickSort();
sort.display();
}
}
Java语言与面向对象程序设计
第一次写插入排序的，写得有点乱，但是加了注释后应该是比较容易理解的：
public class InsertSort{
public static void main(String[] args){
int[] nums={15, 5, 56, 8, 2};
sort(nums,0);
}
public static int[] sort(int[] nums,int start){
//定义新的数组，用来存储每一次排序后的结果
int[] result=new int[nums.length];
//如果开始的下标大于0，则先把之前已排序好的元素拷贝进来
if(start>0){
for(int i=0;i<start;i++){
result[i]=nums[i];
}
}
int tag=start;//定义用来存储该次最小元素的下标
int min=nums[start];
//从当前下标开始，查找数组中的最小元素，并更新下标
for(int i=start;i<nums.length;i++){
for(int j=i+1;j<nums.length;j++){
if(min>nums[j]){
min=nums[j];
tag=j;
}
}
}
//将该次排序后最小的元素存储在开始下标处的位置
result[start]=min;
for(int i=start;i<tag;i++){
result[i+1]=nums[i];
}
//将从当前开始下标处到最后的所有元素原样保存到新数组
for(int i=tag+1;i<nums.length;i++){
result[i]=nums[i];
}
//-----------遍历每一次排序后的数组----------
String split="";
for(int i=0;i<result.length;i++){
System.out.print(split+result[i]);
split=",";
}
System.out.println();
//---------遍历结束------------
//将这一次开始的下标自加，作为下一个排序要开始的下标
start++;
//如果当前开始的下标已经达到最大值，则返回结果数组，否则将该次排序后的数组递归排序
if(start==nums.length-1){
return result;
}else{
return sort(result,start);
}
}
}
顺便说一下，一楼的，你写的不是插入法排序的啊，而且你也没有输出每一次的排序结果。
北大青鸟java培训:程序员需要了解的10个面向对象设计
面向对象设计原则是OOPS编程的核心，学习面向对象编程像“抽象”、“封装”、“多态”、“继承”等基础知识是重要的，但同时为了创建简洁、模块化的设计，了解这些设计原则也同等重要。
(设计原则)底线是永远追求高内聚、低耦合的编码或设计。
Apache和Sun的开源代码是学习和OOPS设计原则的良好范例。
它们向我们展示了，设计原则在编程中是如何使用的。
JDK使用了一些设计原则：BorderFactory类中的工厂模式、Runtime类中的单例模式、.io类中的装饰器模式。
顺便说一句，如果您真的对编码原则感兴趣，请阅读JoshuaBloch的Effective，他编写过API。
我个人最喜欢的关于面向对象设计模式的是KathySierra的HeadFirstDesignPattern(深入浅出设计模式)，以及其它的关于深入浅出面向对象分析和设计。
这些书对编写更好的代码有很大帮助，充分利用各种面向对象和SOLID的设计模式。
虽然学习设计模式(原则)最好的方法是现实中的例子和理解违反设计原则带来的不便，本文的宗旨是向那些没有接触过或正处于学习阶段的程序员介绍面向对象设计原则。
DRY_Don’trepeatyourself我们第一个面向对象设计原则是：DRY，从名称可以看出DRY(don’trepeatyourself)意思是不写重复代码，而是抽象成可复用的代码块。
如果您有两处以上相同的代码块，请考虑把它们抽象成一个单独的方法；或者您多次使用了硬编码的值，请把它们设置成公共常量。
这种面向对象设计原则的优点是易于维护。
重要的是不要滥用此原则，重复不是针对代码而是针对功能来说。
它的意思是，如果您使用通用代码来验证OrderID和SSN，这并不意味着它们是相同的或者他们今后将保持不变。
通过把通用代码用于实现两种不同的功能，或者您把这两种不同的功能密切地联系在一起；当您的OrderID格式改变时，您的SSN验证代码将会中断。
所以要当心这种耦合，而且不要把彼此之间没有任何关系却类似的代码组合在一起。
封装经常修改的代码EncapsulateWhatChanges在软件领域永远不变的是“变化”，所以把您认为或怀疑将来要被修改的代码封装起来。
这种面向对象设计模式的优点是：易于测试和维护恰当封装的代码。
如果您在用编程，那么请遵守以下原则：变量和方法的访问权限默认设置为私有，并且逐步放开它们的访问权限，例如从“private”到“protected”、“notpublic”。
中的一些设计模式使用了封装，工厂设计模式就是一个例子，它封装了创建对象的代码而且提供了以下灵活性：后续生成新对象不影响现有的代码。
打开/关闭设计原则OpenClosedDesignPrinciple类、方法/函数应当是对扩展(新功能)开放，对修改闭合。
这是另外一个优雅的SOLID设计原则，以防止有人修改通过测试的代码。
理想情况下假如您添加了新功能，那么您的代码要经过测试，这就是打开/关闭设计原则的目标。
顺便说一句，SOLID中的字母“O”指的是打开/关闭设计原则。
单一职责原则SingleResponsibilityPrinciple(SRP)单一职责原则是另外一个SOLID设计原则，SOLID中的字母“S”指的就是它。
按照SRP，一个类修改的原因应当有且只有一个，或者一个类应当总是实现单一功能。
如果您在中的一个类实现了多个功能，那么这些功能之间便产生了耦合关系；如果您修改其中的一个功能，您有可能就打破了这种耦合关系，那么就要进行另一轮测试以避免产生新的问题。
依赖注入/反转原则DependencyInjectionorInversionprinciple不要问框架的依赖注入功能将会给你带来什么益处，依赖注入功能在spring框架里已经很好的得到了实现，这一设计原则的优雅之处在于：DI框架注入的任何一个类都易于用模拟对象进行测试，并且更易于维护，因为创建对象的代码在框架里是集中的而且和客户端代码是隔离的。
有多种方法可以实现依赖注入，例如使用字节码工具，其中一些AOP(面向切面编程)框架如切入点表达式或者spring里使用的代理。
想对这种SOLID设计原则了解更多，请看IOC和DI设计模式中的例子。
SOLID中的字母“D”指的就是这种设计原则。
优先使用组合而非继承ForCompositionoverInheritance如果可以的话，要优先使用组合而非继承。
你们中的一些人可能为此争论，但我发现组合比继承更有灵活性。
组合允许在运行时通过设置属性修改一个类的行为，通过使用多态即以接口的形式实现类之间的组合关系，并且为修改组合关系提供了灵活性。
甚至Effective也建议优先使用组合而非继承。
里氏替换原则LiskovSubstitutionPrincipleLSP根据里氏替换原则，父类出现的地方可以用子类来替换，例如父类的方法或函数被子类对象替换应该没有任何问题。
LSP和单一职责原则、接口隔离原则密切相关。
如果一个父类的功能比其子类还要多，那么它可能不支持这一功能，而且也违反了LSP设计原则。
为了遵循LSPSOLID设计原则，派生类或子类(相对父类比较)必须增强功能，而非减少。
SOLID中的字母“L”指的就是LSP设计原则。
接口隔离原则接口隔离原则指，如果不需要一个接口的功能，那么就不要实现此接口。
这大多在以下情况发生：一个接口包含多种功能，而实现类只需要其中一种功能。
接口设计是一种棘手的工作，因为一旦发布了接口，您就不能修改它否则会影响实现该接口的类。
在中这种设计原则的另一个好处是：接口有一个特点，任何类使用它之前都要实现该接口所有的方法，所以使用功能单一的接口意味着实现更少的方法。
编程以接口(而非实现对象)为中心编程总是以接口(而非实现对象)为中心，这会使代码的结构灵活，而且任何一个新的接口实现对象都能兼容现有代码结构。
所以在中，变量、方法返回值、方法参数的数据类型请使用接口。
这是许多程序员的建议，Effective以及headfirstdesignpattern等书也这样建议。
代理原则不要期望一个类完成所有的功能，电脑培训认为可以适当地把一些功能交给代理类实现。
代理原则的典范是：中的equals()和hashCode()方法。
为了比较两个对象的内容是否相同，我们让用于比较的类本身完成对比工作而非它们的调用方。
这种设计原则的好处是：没有重复编码而且很容易修改类的行为。
关于java面向对象程序设计电子书的内容到此结束，希望对大家有所帮助。