本文目錄一覽：
用java編寫一個簡單例子，題目如下
package test;
public class Student {
private String name;
private String id;
private String clazz;
private int age;
private String address;
/**
* sayHello方法
*/
public void sayHello() {
System.out.println(“學號為” + this.id + “的同學的具體信息如下：”);
System.out.println(“姓名：” + this.name);
System.out.println(“班級：” + this.clazz);
System.out.println(“年齡：” + this.age);
System.out.println(“家庭住址：” + this.address);
}
/**
* 測試方法
*
* @param args
*/
public static void main(String[] args) {
// 第一問
Student student = new Student();
student.setAddress(“百度知道”);
student.setAge(1);
student.setClazz(“一班”);
student.setId(“071251000”);
student.setName(“lsy605604013”);
student.sayHello();
// 第二問
Student studentNew = new Student();
studentNew.setAddress(“搜搜知道”);
studentNew.setAge(2);
studentNew.setClazz(“二班”);
studentNew.setId(“071251001”);
studentNew.setName(“lady”);
if (student.getAge() studentNew.getAge())
studentNew.sayHello();
else if (student.getAge() studentNew.getAge())
student.sayHello();
else
System.out.println(“兩人一樣大”);
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getClazz() {
return clazz;
}
public void setClazz(String clazz) {
this.clazz = clazz;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
}
java遞歸演算法的例子。
階乘：
要求：給定一個數值，計算出它的階乘值，例如5的階乘為5*4*3*2*1
實現：
[html] view plaincopy
span style=”font-size:12px;” // 利用遞歸實現一個數的階乘值 private static BigDecimal getNum(BigDecimal inNum) { if (inNum.compareTo(BigDecimal.ONE) == 0) { return inNum; } return inNum.multiply(getNum(inNum.subtract(BigDecimal.ONE))); }/span
（2）Fibonacci數列：1，1，2，3，5，8，13……
要求：找出數列中指定index位置的數值
實現：
[html] view plaincopy
span style=”font-size:12px;” // 利用遞歸實現了Fibonacci數列 private static int fab(int index) { if (index == 1 || index == 2) { return 1; } else { return fab(index – 1) + fab(index – 2); } }/span
（3）漢諾塔
要求：漢諾塔挪動
實現：
[html] view plaincopy
span style=”font-size:12px;” span style=”white-space:pre;” /spanprivate static final String DISK_B = “diskB”; span style=”white-space:pre;” /spanprivate static final String DISK_C = “diskC”; span style=”white-space:pre;” /spanprivate static final String DISK_A = “diskA”; span style=”white-space:pre;” /spanstatic String from=DISK_A; span style=”white-space:pre;” /span static String to=DISK_C; span style=”white-space:pre;” /span static String mid=DISK_B; span style=”white-space:pre;” /span public static void main(String[] args) { span style=”white-space:pre;” /span String input=JOptionPane.showInputDialog(“please input the number of the disks you want me move.”); span style=”white-space:pre;” /span int num=Integer.parseInt(input); span style=”white-space:pre;” /span move(num,from,mid,to); span style=”white-space:pre;” /span }/span
[html] view plaincopy
span style=”font-size:12px;” // 利用遞歸實現漢諾塔 private static void move(int num, String from2, String mid2, String to2) { if (num == 1) { System.out.println(“move disk 1 from ” + from2 + ” to ” + to2); } else { move(num – 1, from2, to2, mid2); System.out.println(“move disk ” + num + ” from ” + from2 + ” to ” + to2); move(num – 1, mid2, from2, to2); } }/span
（4）排列組合
要求：將輸入的一個字元串中的所有元素進行排序並輸出，例如：你給出的參數是”abc”，
則程序會輸出
abc
acb
bac
bca
cab
cba
實現：
[html] view plaincopy
span style=”font-size:12px;”span style=”white-space:pre;” /spanpublic static void permute(String str) { span style=”white-space:pre;” /span char[] strArray = str.toCharArray(); span style=”white-space:pre;” /span permute(strArray, 0, strArray.length – 1); span style=”white-space:pre;” /span}/span
[html] view plaincopy
span style=”font-size:12px;” // 利用遞歸實現，將輸入的一個字元串中的所有元素進行排序並輸出 public static void permute(char[] list, int low, int high) { int i; if (low == high) { String cout = “”; for (i = 0; i = high; i++) { cout += list[i]; } System.out.println(cout); } else { for (i = low; i = high; i++) { char temp = list[low]; list[low] = list[i]; list[i] = temp; permute(list, low + 1, high); temp = list[low];
java 中 單實例和多實例是指的什麼?
簡單的說單例就是
只能有一個實例，所以地方用到的實例都是同一個。
就好像家人吃飯，桌子是單例的，大家用的是同一個。而碗是多例的，每人都有自幾的。
下面是具體的例子：
Java模式之單例模式：
單例模式確保一個類只有一個實例，自行提供這個實例並向整個系統提供這個實例。
特點：
1，一個類只能有一個實例
2，自己創建這個實例
3，整個系統都要使用這個實例
例:
在下面的對象圖中，有一個”單例對象”，而”客戶甲”、”客戶乙”
和”客戶丙”是單例對象的三個客戶對象。可以看到，所有的客戶對象共享一個單例對象。而且從單例對象到自身的連接線可以看出，單例對象持有對自己的引用。
Singleton模式主要作用是保證在Java應用程序中，一個類Class只有一個實例存在。在很多操作中，比如建立目錄
資料庫連接都需要這樣的單線程操作。一些資源治理器經常設計成單例模式。
外部資源：譬如每台計算機可以有若干個印表機，但只能有一個Printer
Spooler,以避免兩個列印作業同時輸出到印表機中。每台計算機可以有若干個通信埠，系統應當集中治理這些通信埠，以避免一個通信埠被兩個請求同時調用。內部資源，譬如，大多數的軟體都有一個（甚至多個）屬性文件存放系統配置。這樣的系統應當由一個對象來治理這些屬性文件。一個例子：Windows
回收站。
在整個視窗系統中，回收站只能有一個實例，整個系統都使用這個惟一的實例，而且回收站自行提供自己的實例。因此，回收站是單例模式的應用。
兩種形式：
1，餓漢式單例類
public
class
Singleton
{
private
Singleton(){}
//在自己內部定義自己一個實例，是不是很希奇？
//注重這是private
只供內部調用
private
static
Singleton
instance
=
new
Singleton();
//這裡提供了一個供外部訪問本class的靜態方法，可以直接訪問
public
static
Singleton
getInstance()
{
return
instance;
}
}
2，懶漢式單例類
public
class
Singleton
{
private
static
Singleton
instance
=
null;
public
static
synchronized
Singleton
getInstance()
{
//這個方法比上面有所改進，不用每次都進行生成對象，只是第一次
//使用時生成實例，提高了效率！
if
(instance==null)
instance＝new
Singleton();
return
instance;
}
}
第二中形式是lazy
initialization，也就是說第一次調用時初始Singleton，以後就不用再生成了。
注重到lazy
initialization形式中的synchronized，這個synchronized很重要，假如沒有synchronized，那麼使用getInstance()是有可能得到多個Singleton實例。
一般來說第一種比較安全。進入討論組討論。
java幾個小數取整例子
（要學會百度啊）
Math類中提供的三個與取整有關的方法:
第一個: ceil
ceil的意思就是: 天花板的意思;該方法表示的是向上取整Math.ceil(11.3)的值是12 ; Math.ceil.(-11.6)的結果是-11;
第二個是: floor
首先他的英文含義就是地板的含義,該方法就表示的是向下取整,
Math.floor(11.6)的結果就是11 ;
Math.floor(-11.4);的結果就是-12
第三個是: round
他表示的是四捨五入,演算法為 Math.floor(x+0.5);也就是在原來的數字上加上0.5之後再進行向下取整;
Math.round(11.5);也就是 Math.floor(11.5+0.5)= Math.floor(12)=12;
同理: Math.round(-11.5)= Math.floor(-11.5+0.5)=Math.floor(-11.0)= -11;
原文地址：網頁鏈接
java方法重載和方法重寫的例子
下面將分別講解重載與重寫：
1、重載overloading
1) 方法重載是讓類以統一的方式處理不同類型數據的一種手段。多個同名函數同時存在，具有不同的參數個數/類型。重載是一個類中多態性的一種表現。
2) Java的方法重載，就是在類中可以創建多個方法，它們具有相同的名字，但具有不同的參數和不同的定義。調用方法時通過傳遞給它們的不同參數個數和參數類型給它們的不同參數個數和參數類型給它們的不同參數個數和參數類型來決定具體使用哪個方法, 這就是多態性。
3) 重載的時候，方法名要一樣，但是參數類型和個數不一樣，返回值類型可以相同也可以不相同。無法以返回型別作為重載函數的區分標準。
示例代碼：
public class Dog {
Dog()
{
this.bark();
}
void bark()//bark()方法是重載方法
{
System.out.println(“no barking!”);
this.bark(“female”, 3.4);
}
void bark(String m,double l)//注意：重載的方法的返回值都是一樣的，
{
System.out.println(“a barking dog!”);
this.bark(5, “China”);
}
void bark(int a,String n)//不能以返回值區分重載方法，而只能以「參數類型」和「類名」來區分
{
System.out.println(“a howling dog”);
}
public static void main(String[] args)
{
Dog dog = new Dog();
//dog.bark();
//dog.bark(“male”, “yellow”);
//dog.bark(5, “China”);
}
}
2、重寫overriding
1) 父類與子類之間的多態性，對父類的函數進行重新定義。如果在子類中定義某方法與其父類有相同的名稱和參數，我們說該方法被重寫 (Overriding)。在Java中，子類可繼承父類中的方法，而不需要重新編寫相同的方法。但有時子類並不想原封不動地繼承父類的方法，而是想作一定的修改，這就需要採用方法的重寫。方法重寫又稱方法覆蓋。
2) 若子類中的方法與父類中的某一方法具有相同的方法名、返回類型和參數表，則新方法將覆蓋原有的方法。如需父類中原有的方法，可使用super關鍵字，該關鍵字引用了當前類的父類。
3) 子類函數的訪問修飾許可權不能少於父類的；
示例代碼：
public class Base
{
void test(int i)
{
System.out.print(i);
}
void test(byte b)
{
System.out.print(b);
}
}
public class TestOverriding extends Base
{
void test(int i)
{
i++;
System.out.println(i);
}
public static void main(String[]agrs)
{
Base b=new TestOverriding();
b.test(0)
b.test((byte)0)
}
}
這時的輸出結果是1 0，這是運行時動態綁定的結果。
原創文章，作者：KKBOB，如若轉載，請註明出處：https://www.506064.com/zh-tw/n/329948.html
微信掃一掃 
支付寶掃一掃 