本文目录一览：
用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，这是运行时动态绑定的结果。
