在Java语言中，在一个类的内部静态方法是无法直接访问该类的非静态成员的，这一点和C++一致。比如下面的代码：
import javax.swing.JOptionPane;
public class Count {
public static void main(String[] args) {
// TODO Auto-generated method stub
fun();
}
void fun(){
JOptionPane.showMessageDialog(null, "调用而非静态函数！");
}
}
这时，编译器是会报错的：“Cannot make a static reference to the non-static method fun() from the type Count”。但是，并非没有办法让静态方法访问该类的静态成员，看下面的代码：
import javax.swing.JOptionPane;
public class Count {
public static void main(String[] args) {
// TODO Auto-generated method stub
Count t = new Count();
t.fun();
}
void fun(){
JOptionPane.showMessageDialog(null, "调用而非静态函数！");
}
}
这段代码执行是没有问题的，结果如下：
由以上两个实例可以看出，在一个类的非静态方法中，如果想要访问该类的非静态成员，必须先在该方法内部声明该类的对象，然后通过对象访问非静态成员。
生成随机数，数学公式为xn+1 = (a*xn + c) mod m;所以自己写随机数生成代码的时候，要自己指定一个x，还要手动输入三个值，这里用a,c,m代替。这三个数中，m应该尽量较大，因为m的值决定了随机数的范围。而且如果m太小，则随机数重复的概率就会增大。而且每次输入的a,c，m的值应该用所不同，如果每次输入的这三个值都相同，那么每次生成的随机数也都相同。
Java中方法的重载，方法重载是指多个方法可以使用相同的方法名。虽然方法名可以相同，但这些方法参数必须不同，或者是参数个数不同，或者是参数类型不同，或者是参数排列不同。参数表完全相同，而只用返回值不同的同名方法会发生编译错误。重载虽然表面上没有减少编写程序的工作，但实际上重载使得程序实现方式边的简单。只需要记住一个方法名，就可以根据不同的输入类型来选择方法的不同版本。
计算组合数：在中学的时候我们都学过排列组合。从n个数选择k个人的方法有Ckn，它的计算方式为是用n!除以k!(n-k)!，那么在它在计算机中实现又该是如何呢？这里我们可以用两种方法来计算，一是用组合数公式应用循环递推或者递归的方式计算一个数的阶乘，然后计算组合方法。二就是应用杨辉三角的方法。两种方法都是可取的，都可以用递归或者循环递推来实现。
方法一：用递归求阶乘
import javax.swing.JOptionPane;
public class Test1_1 {
public static void main(String[] args) {
// TODO Auto-generated method stub
String str = JOptionPane.showInputDialog(null,"总数","n");
int n = Integer.parseInt(str);
String sss = JOptionPane.showInputDialog(null,"选择个数","k");
int k = Integer.parseInt(sss);
int sum = fun(n)/(fun(n-k)*fun(k));
String message = "从"+n+"个中选择"+k+"个的组合数为："+sum;
JOptionPane.showMessageDialog(null, message,"求组合数",JOptionPane.INFORMATION_MESSAGE);
}
public static int fun(int n){
if(n < 0)
{
System.out.println("错误！");
System.exit(n);
}
if(n == 0 || n == 1)
return 1;
else
return n*fun(n-1);
}
}
方法二：用杨辉三角的方式
import javax.swing.JOptionPane;
public class Test1_2 {
public static void main(String[] args) {
// TODO Auto-generated method stub
String str = JOptionPane.showInputDialog(null,"总数","n");
int n = Integer.parseInt(str);
String sss = JOptionPane.showInputDialog(null,"选择个数","k");
int k = Integer.parseInt(sss);
int sum = fun(n,k);
String message = "从"+n+"个中选择"+k+"个的组合数为："+sum;
JOptionPane.showMessageDialog(null, message,"求组合数",JOptionPane.INFORMATION_MESSAGE);
}
public static int fun(int i,int j)
{
if(j == 0 || i == j)
return 1;
else
return fun(i-1,j-1)+fun(i-1,j);
}
}
这两种方式虽然截然不同，但都可以用递归的方式完成，运行结果都一样。
汉诺塔问题。把一个柱子上的大小不同的盘子移动到另一个柱子上，规定大的盘子不能放到小的盘子上。有一个柱子可以借用，问当有n个盘子的时候，一共要移动几次。一共就有3个柱子。我们可以简单的看一看，将这三个柱子编号为A,B,C，假设将A上的盘子移到C柱子上。当只有一个盘子的时候，就是直接从A到C，一共移动1次。当有2个盘子的时候，现将小的移动到B上，然后将大的移动到C上，最后将小的从B上移动到C上，一共3次。那么有3个盘子的时候，移动方法为先将上面的2个盘子，移动到B上，方法和前面将2个盘子移动到C上相同，然后将下面的1个盘子移动到C上，最后将B上的2个盘移动到C上，一共是2*2+1=7次。那么移动n个盘子的时候，就是先将n-1个盘子移动到B盘上，然后将1个盘子移动到C上，最后将N-1个B上的盘子移动到C上。所以我们可以设计如下程序：
import javax.swing.JOptionPane;
public class Task3 {
public static void main(String[] args) {
// TODO Auto-generated method stub
String str = JOptionPane.showInputDialog(null,"输入汉罗塔盘数：","1");
int n = Integer.parseInt(str);
JOptionPane.showMessageDialog(null, "挪动次数为"+fun(n));
}
public static int fun(int n){
int count = 0;
if(n == 1){
count = 1;
}
else if(n == 2){
count = 3;
}else{
count = 2*fun(n-1)+1;
}
return count;
}
}
回文字符的问题，当只有一个字符的时候，这个字符是回文字符串；当有两个字符的时候，如果这个两个字符相同，则这个字符串是回文字符串，否则不是；当有3个字符的时候，第一个和第三个字符相同，则这个字符串是回文字符串，否则不是。当有n个字符的首后，如果第一个和最后一字符相同，且去掉首位字符后的字符串是回文字符串，那么这个字符便是回文的，否则不是。所以可以设计如下算法：
import javax.swing.JOptionPane;
public class Test3 {
/**************用递归判断某个字串是否是回文***************/
public static void main(String[] args) {
// TODO Auto-generated method stub
String str = JOptionPane.showInputDialog(null,"输入一个字符串：");
String sss = new String(str+"不是回文字符串");
if(ispalindrome(str))
sss = str+"是回文字符串";
JOptionPane.showMessageDialog(null,sss);
}
public static boolean ispalindrome(String s){
boolean flag = false;
if(s.length()==1)
flag = true;
else if(s.length()==2 && s.charAt(0)==s.charAt(1))
flag = true;
else if(s.length()>2)
flag = ispalindrome(s.substring(1,s.length()-1));
return flag;
}
}