1、面试题：
  第一题：
  byte b1=3,b2=4,b;
  b=b1+b2;
  b=3+4;
  哪句是编译失败的呢？为什么呢？

  第二题：
  byte  by = 130;有没有问题?有问题如何解决?结果是多少呢?

  第三题:
  byte b = 10;
  b++;
  b = b + 1;
  哪句是编译失败的呢？为什么呢？

2、short s = 1; s = s + 1;有没有问题?如果有怎么解决?
   short s = 1; s += 1;有没有问题?如果有怎么解决?

3、需求：
  int a = 10;
  int b = 20;
  请用代码实现交换两个变量，
  即结果为： a = 20;  b = 10;  (3种)


答案：  int a = 1;
  int b = 2;
  int temp = a;
      a = b;
      b = temp;
  System.out.println("a= "+a+", b= "+b);
  System.out.println("--------------------------------");
  int x = 1;
  int y = 2;
  x = x + y;
  y = x - y;
  x = x - y;
  System.out.println("x= "+x+", y= "+y);
  System.out.println("--------------------------------");
  int i = 1;
  int j = 2;
  i = i ^ j;
  j = i ^ j;
  i = i ^ j;
  System.out.println("i= "+i+", j= "+j);
  System.out.println("--------------------------------");
  
class Demo2_Operator {
public static void main(String[] args) {
  /*
  * 位异或运算符的特点

  * ^的特点：一个数据对另一个数据位异或两次，该数本身不变。
  */

  //System.out.println(5 ^ 10 ^ 10);
  //System.out.println(5 ^ 10 ^ 5);

  /*
  * 请自己实现两个整数变量的交换(不需要定义第三方变量)
  * 注意：以后讲课的过程中，我没有明确指定数据的类型，默认int类型。
  */

  int x = 10;
  int y = 5;

  //需要第三方变量,开发推荐用这种
  /*int temp;
  temp = x;
  x = y;
  y = temp;*/

  //不需要定义第三方变量,有弊端,有可能会超出int的取值范围
  /*x = x + y;    //10 + 5 = 15
  y = x - y;    //15 - 5 = 10
  x = x - y;    //15 - 10 = 5*/

  //不需要第三方变量,通过^来做
  x = x ^ y;    // 10 ^ 5
  y = x ^ y;    // 10 ^ 5 ^ 5 y = 10
  x = x ^ y;    // 10 ^ 5 ^ 10  x = 5

  System.out.println("x = " + x + ",y = " + y);
}
}

4、最有效率的算出2 * 8的结果
class Demo3_Operator {
public static void main(String[] args) {
  /*
  *  <<:左移 左边最高位丢弃，右边补齐0
  *  >>:右移 最高位是0，左边补齐0;最高为是1，左边补齐1
  *  >>>:无符号右移 无论最高位是0还是1，左边补齐0
  *  最有效率的算出2 * 8的结果
  */

  //左移,向左移动几位就是乘以2的几次幂
  //System.out.println(12 << 1);  //24
  //System.out.println(12 << 2);  //48

  /*
  00000000 00000000 00000000 00001100  12的补码
  (0)0000000 00000000 00000000 000011000  24的补码
(00)000000 00000000 00000000 0000110000  48的补码
  */

  //右移,向右移动几位就是除以2的几次幂
  //System.out.println(12 >> 1);
  //System.out.println(12 >> 2);

  /*
  00000000 00000000 00000000 00001100  12的补码
  000000000 00000000 00000000 0000110(0) 6
  0000000000 00000000 00000000 000011(00) 3
  */

  //最有效率的算出2 * 8的结果
  System.out.println(2 << 3);
}
}

5、
* byte可以作为switch的表达式吗?
* long可以作为switch的表达式吗?
* String可以作为switch的表达式吗?

给力，必须赞，加油

  第一题：
  byte b1=3,b2=4,b;
  b=b1+b2;
  b=3+4;
  哪句是编译失败的呢？为什么呢？

b=b1+b2失败  数据类型不一样，必须强转

看程序写结果：main方法是入口
第一题：
class Test
{
        private static int x =  10;

        public void show(int x)  
        {
                x++;
                System.out.println(x); //21
        }

        public static void main(String[] args)
        {
                int x = 20;       
                Test t = new Test();
                t.show(x);
        }
}  

第二题：
        class Fu{
                public int num = 10;
                public Fu(){
                        System.out.println("fu");
                }
        }
        class Zi extends Fu{
                public int num = 20;
                public Zi(){
                        System.out.println("zi");
                }
                public void show(){
                        int num = 30;
                        System.out.println(num);
                        System.out.println(this.num);
                        System.out.println(super.num);
                }
        }
        class Test {
                public static void main(String[] args) {
                        Zi z = new Zi();
                        z.show();
                }
        }

        fu
        zi
        30
        20
        10

第三题：(面试题)
        class Fu {
                static {
                        System.out.println("静态代码块Fu");
                }

                {
                        System.out.println("构造代码块Fu");
                }

                public Fu() {
                        System.out.println("构造方法Fu");
                }
        }

        class Zi extends Fu {
                static {
                        System.out.println("静态代码块Zi");
                }

                {
                        System.out.println("构造代码块Zi");
                }

                public Zi() {
                        System.out.println("构造方法Zi");
                }
        }

        Zi z = new Zi(); 请执行结果。

        A:静态随着类的加载而加载。
        B:静态代码块 -- 构造代码块 -- 构造方法的执行流程
                静态代码块 -- 构造代码块 -- 构造方法
        C:只要有子父关系，肯定先初始化父亲的数据，然后初始化子类的数据。

        结果：
                静态代码块Fu
                静态代码块Zi
                构造代码块Fu
                构造方法Fu
                构造代码块Zi
                构造方法Zi

第四题：
        class X {
                Y b = new Y();
                X() {
                        System.out.print("X");
                }
        }
        class Y {
                Y() {
                        System.out.print("Y");
                }
        }
        public class Z extends X {
                Y y = new Y();
                Z() {
                        System.out.print("Z");
                }
                public static void main(String[] args) {
                        new Z(); //yxyz
                }
        }


        铺垫的小知识：
                第一个：成员变量有基本类型和引用类型的。
                class Demo {
                        //基本类型
                        int x = 10;
                        //引用类型
                        Student s = new Student();
                }
       
                第二个：类的初始化过程
                        加载class文件
                        堆中开辟空间
                        变量的默认初始化
                        变量的显示初始化
                        构造代码块初始化
                        构造方法初始化

                第三个：遇到extends，就要知道，先初始化父类数据，然后初始化子类数据。
                        分层初始化。

第五题：
        class X {
                Y b = new Y();
                X() {
                        System.out.print("X");
                }
        }
        class Y {
                Y() {
                        System.out.print("Y");
                }
        }
        public class Z extends X {
                Y y = new Y();
                Z() {
                        //super(); 内存中的做法，就是分层初始化，不会因为这里的super改变。
                        //super在这里仅仅表示要先初始化父类数据。
                        System.out.print("Z");
                }
                public static void main(String[] args) {
                        new Z();
                }
        }

嗯十一点晚安 发表于 2015-8-29 08:20
第一题：
  byte b1=3,b2=4,b;
  b=b1+b2;

是的

好贴，顶！

好东西，战略性马克！

Integer的面试题

                看程序写结果
               
                Integer i1 = new Integer(97);
                Integer i2 = new Integer(97);
                System.out.println(i1 == i2);
                System.out.println(i1.equals(i2));
                System.out.println("-----------");
       
                Integer i3 = new Integer(197);
                Integer i4 = new Integer(197);
                System.out.println(i3 == i4);
                System.out.println(i3.equals(i4));
                System.out.println("-----------");
       
                Integer i5 = 97;
                Integer i6 = 97;
                System.out.println(i5 == i6);
                System.out.println(i5.equals(i6));
                System.out.println("-----------");
       
                Integer i7 = 197;
                Integer i8 = 197;
                System.out.println(i7 == i8);
                System.out.println(i7.equals(i8));

每天都有收获。越来越有信心。

很好，不错

顶一下已关注

楼主好人一路平安

1.判断定义为String类型的s1和s2是否相等
                        * String s1 = "abc";
                        * String s2 = "abc";
                        * System.out.println(s1 == s2);                                        
                        * System.out.println(s1.equals(s2));                
                * 2.下面这句话在内存中创建了几个对象?
                        * String s1 = new String("abc");                       
                * 3.判断定义为String类型的s1和s2是否相等
                        * String s1 = new String("abc");                       
                        * String s2 = "abc";
                        * System.out.println(s1 == s2); ?                       
                        * System.out.println(s1.equals(s2)); ?       
                * 4.判断定义为String类型的s1和s2是否相等
                        * String s1 = "a" + "b" + "c";
                        * String s2 = "abc";
                        * System.out.println(s1 == s2); ?                       
                        * System.out.println(s1.equals(s2)); ?       
                * 5.判断定义为String类型的s1和s2是否相等
                        * String s1 = "ab";
                        * String s2 = "abc";
                        * String s3 = s1 + "c";
                        * System.out.println(s3 == s2);
                        * System.out.println(s3.equals(s2)); ?       



                结果分析：true、true   2个   false、true   true、true    false、true
                                1：equals重写了object的equals方法，比较的是字符序列。关于 == ，常量池中如果
                                没有这个字符串对象,就创建一个,如果有直接用即可，所以是两个引用指向同一个地址。
                                2：先存入常量值，因为一旦初始化就不能被改变，然后因为是new，所以在堆内存中创建新的。
                                3：同1分析，一个地址是堆内存的，一个常量池的。
                                4：Java有常量优化机制，a b c先拼接然后判断是否在常量池中存在，存在就直接用，不存在就创建新的。
                                5：变量与常量相加，字符串在底层是先通过创建StringBuffer或者StringBuild对象，将String转成该类，
                                然后通过append方法实现拼接，最后通过toString方法再转为String。

好东西  学习了

马上面试了，收藏了

多谢分享啊。一定认真看看。

二个运行都正常

太好啦 这些

看看。了解下

mark~~~!!!