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面向对象设计有哪些原则
甚至还有经验丰富的Java程序员没有听说过OOPS和SOLID设计原则，他们根本不知道设计原则的好处，也不知道如何依照这些原则来进行编程。众所周知，Java编程最基本的原则就是要追求高内聚和低耦合的解决方案和代码模块设计。查看Apache和Sun的开放源代码能帮助你发现其他Java设计原则在这些代码中的实际运用。Java DevelopmentKit则遵循以下模式：BorderFactory类中的工厂模式、Runtime类中的单件模式。原则1:DRY（Don'trepeatyourself）即不要写重复的代码，而是用"abstraction"类来抽象公有的东西。如果你需要多次用到一个硬编码值，那么可以设为公共常量；如果你要在两个以上的地方使用一个代码块，那么可以将它设为一个独立的方法。SOLID设计原则的优点是易于维护，但要注意，不要滥用，duplicate不是针对代码，而是针对功能。这意味着，即使用公共代码来验证OrderID和SSN,二者也不会是相同的。使用公共代码来实现两个不同的功能，其实就是近似地把这两个功能永远捆绑到了一起，如果OrderID改变了其格式，SSN验证代码也会中断。因此要慎用这种组合，不要随意捆绑类似但不相关的功能。原则2:封装变化在软件领域中唯一不变的就是"Change",因此封装你认为或猜测未来将发生变化的代码。OOPS设计模式的优点在于易于测试和维护封装的代码。如果你使用Java编码，可以默认私有化变量和方法，并逐步增加访问权限，比如从private到protected和notpublic.有几种Java设计模式也使用封装，比如Factory设计模式是封装"对象创建",其灵活性使得之后引进新代码不会对现有的代码造成影响。原则3:开闭原则即对扩展开放，对修改关闭。这是另一种非常棒的设计原则，可以防止其他人更改已经测试好的代码。理论上，可以在不修改原有的模块的基础上，扩展功能。这也是开闭原则的宗旨。原则4:单一职责原则类被修改的几率很大，因此应该专注于单一的功能。如果你把多个功能放在同一个类中，功能之间就形成了关联，改变其中一个功能，有可能中止另一个功能，这时就需要新一轮的测试来避免可能出现的问题。原则5:依赖注入或倒置原则这个设计原则的亮点在于任何被DI框架注入的类很容易用mock对象进行测试和维护，因为对象创建代码集中在框架中，客户端代码也不混乱。有很多方式可以实现依赖倒置，比如像AspectJ等的AOP（AspectOrientedprogramming）框架使用的字节码技术，或Spring框架使用的代理等。原则6:优先利用组合而非继承如果可能的话，优先利用组合而不是继承。一些人可能会质疑，但我发现，组合比继承灵活得多。组合允许在运行期间通过设置类的属性来改变类的行为，也可以通过使用接口来组合一个类，它提供了更高的灵活性，并可以随时实现。《EffectiveJava》也推荐此原则。原则7:里氏代换原则（LSP）根据该原则，子类必须能够替换掉它们的基类，也就是说使用基类的方法或函数能够顺利地引用子类对象。LSP原则与单一职责原则和接口分离原则密切相关，如果一个类比子类具备更多功能，很有可能某些功能会失效，这就违反了LSP原则。为了遵循该设计原则，派生类或子类必须增强功能。原则8:接口分离原则采用多个与特定客户类有关的接口比采用一个通用的涵盖多个业务方法的接口要好。设计接口很棘手，因为一旦释放接口，你就无法在不中断执行的情况下改变它。在Java中，该原则的另一个优势在于，在任何类使用接口之前，接口不利于实现所有的方法，所以单一的功能意味着更少的实现方法。原则9:针对接口编程，而不是针对实现编程该原则可以使代码更加灵活，以便可以在任何接口实现中使用。因此，在Java中最好使用变量接口类型、方法返回类型、方法参数类型等。《EffectiveJava》和《headfirstdesignpattern》书中也有提到。原则10:委托原则该原则最典型的例子是Java中的equals（）和hashCode（）方法。为了平等地比较两个对象，我们用类本身而不是客户端类来做比较。这个设计原则的好处是没有重复的代码，而且很容易对其进行修改。总之，希望这些面向对象的设计原则能帮助你写出更灵活更好的代码。理论是第一步，更重要的是需要开发者在实践中去运用和体会。
END，本文到此结束，如果可以帮助到大家，还望关注本站哦！