java实例

1.汉诺塔算法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public class MainClass {
    public static void main(String[] args) {
        int nDisks = 3;//杆子数
        doTowers(nDisks, 'A', 'B', 'C');
        //       碟子数/起点/中转点/终点
    }
    //递归 分而治之，减而治之
    public static void doTowers(int topN, char from, char inter, char to) {
        if (topN == 1){//如果杆子上只剩一个碟子，即最小的碟子
            System.out.println("Disk 1 from "+ from + " to " + to);
            //不再递归
        }else {
            doTowers(topN - 1, from, to, inter);
            //完成一个移动碟子数量n-1/A/C/B
            System.out.println("Disk "+ topN + " from " + from + " to " + to);
            doTowers(topN - 1, inter, from, to);
            //          n-1/B/A/C
        }
    }
}

A上有n到C必须经历的操作就是：

(1)使n-1个圆盘整体移动到B柱（中转位置）上

(2)再使第n个圆盘移动到C柱（目的位置）上

(3)再将n-1个圆盘整体移动到C柱（目的位置）上

上一操作中的第(1)步又可以细分到：

(1)将n-2个圆盘通过 (1)使n-2个圆盘整体移动到C柱（中转位置）上，

(2)再使第n-1个圆盘移动到B柱（目的位置）上，

(3)再将n-2个圆盘整体移动到B柱（目的位置）上。

上一操作中的第(3)步又可以细分到：

(1)将n-2个圆盘通过 (1)使n-2个圆盘整体移动到A柱（中转位置）上，

(2)再使第n-1个圆盘移动到C柱（目的位置）上，

(3)再将n-2个圆盘整体移动到C柱（目的位置）上。

逐步缩小，终止条件为杆子上只剩一个碟子需要移动

  1. 打印结果为false

1
2
3
4
5
6
7
8
9
public class Test {
    public static void main(String[] args) {
        String s1 = "nowcoder";
        String s2 = "nowcoder";
        System.out.println("s1 == s2 is:" + s1 == s2);
    }
}
/*输出结果为 false。
因为在 Java 中 + 操作法的优先级大于 ==，所以输出部分表达式等于 “s1 == s2 is:nowcoder” == “nowcoder”，该表达式计算结果为 false。*/

  1. ​ c=A

    1
    2
    3
    4
    5
    6
    7
    public class Test {
        public static void main(String[] args) {
            char c = 65;
            System.out.println("c = "+c);
        }
    }
    //c 变量为 char 类型，65 对应的 ASCII 码为 A。

    4.delete

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    class Test
    {
        public static void main(String[] args)
        {
            StringBuffer a = new StringBuffer("Nowcoder");
            StringBuffer b = new StringBuffer("Google");
            a.delete(1,3);
            a.append(b);
            System.out.println(a);
        }
    }
    //delete(x, y) 删除从字符串 x 的索引位置开始到 y-1 的位置，append() 函数用于连接字符串。

5.子类可以访问所有（子类与超类）的 public 和 protected 方法

protected为保护类型，同一个包里和public一样，都可以访问到。 但在不同包里protected类型的成员变量只能通过子类来访问，方法可通过super.方法名调用。

6.private修饰符定义了方法与属性只能在同一个类中访问

7.Java 中 float 类型的在内存中的大小为4字节

8.Java 中变量一定要初始化

9.所有异常类的基类是Java.Lang.throwable

10.public static void main(String[] args)

11.is 开头的命名方式一般用于布尔值判断。

12.Java 是区分大小写的 ，java关键字也不例外。

13.空引用可用于访问静态变量或方法

当我们通过一个对象的引用访问静态成员属性或者方法时 ，访问操作只与所声明的引用类型相关 ；与引用对象是否为 null 无关 ，因为访问静态成员不需要实例化对象 ；即便引用不为 null ，也与运行时多态无关 ，因为静态成员是类相关的 。

14.double a=(float) a

double的范围要比float的范围大，float要比int的范围大

类型转换分两种：

自动类型转换（隐式）

特点： 代码不需要进行特殊处理，自动完成
规则： 数据范围从小到大
安全性：安全

强制类型转换

特点：代码需要进行特殊的格式处理，不能自动完成
格式：范围小的类型 范围小的变量名 = (范围小的类型) 原本范围大的数据
安全性：不安全

15.基本类型类型以及对象的引用变量是存储在栈内存中 ；而对象本身的值或者说 new 创建的对象和数组是存储在堆内存中。

16.三种表达式

1、中缀表达式：

    操作符以中缀形式位于运算数中间（如：3+2），是我们日常通用的算术和逻辑公式表示方法。

2、后缀表达式：

    又称逆波兰式（Reverse Polish Notation - RPN），操作符以后缀形式位于两个运算数后（如：3+2的后缀表达形式就是3 2 +）。

3、前缀表达式：

    又称波兰式（Polish Notation），操作符以前缀形式位于两个运算数前（如：3+2的前缀表达形式就是+ 3 2）。

17.求输出结果

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
class TestIt
{
    public static void main ( String[] args )
    {
        int[] myArray = {1, 2, 3, 4, 5};
        ChangeIt.doIt( myArray );
        for(int j=0; j<myArray.length; j++)
            System.out.print( myArray[j] + " " );
    }
}
class ChangeIt
{
    static void doIt( int[] z ) 
    {
        z = null ;
    }
}
//打印结果12345

java 基本数据类型传递参数时是值传递 ；引用类型传递参数时是引用传递 。然而数组虽然是引用传递 ，但是将引用 z = null 只是将引用z不指向任何对象 ，并不会对原先指向的对象数据进行修改 。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
class ChangeIt
{
    static void doIt( int[] z )
    {
        int[] A = z;
        A[0] = 99;
    }
}
 
class TestIt
{
    public static void main( String[] args )
    {
        int[] myArray = {1, 2, 3, 4, 5};
        ChangeIt.doIt(myArray);
        for (int i = 0; i < myArray.length; i++)
        {
            System.out.print(myArray[i] + " ");
        }
    }
}
//打印结果99 2 3 4 5

引用的是地址

18.

1
2
3
4
&lt; //小于(<)
&gt; //大于(>)
&le; //小于或等于(≤)
&ge; // 大于或等于(≥)

19.错误! 索引超出范围

1
2
int[] arr = new int[9];
System.out.println(arr[9]);//arr[8]=0