StringBuffer s1 = new StringBuffer("a");

StringBuffer s2 = new StringBuffer("a");

s1.equals(s2)//为什么是false

String s1 = new String("a");

String s2 = new String("a");

s1.equals(s2)//为什么是true

StringBuffer类中没有重新定义equals这个方法，因此这个方法就来自Object类，

而Object类中的equals方法是用来比较地址的，所以等于false.

String类中重新定义了equals这个方法，而且比较的是值，而不是地址。所以会是

true。

分享个小技巧，
if判断语句的时候可以把常量放在前面，防止出现==写成=的错误。
比如
int aa= 10;
if(10==aa)
{
  //to do
}

自增自减不具有原子性，在并发操作时，不安全，需要同步！

public class IntegerTest {
        public static void main(String[] args) {
                Integer a=121;  // a=new Integer(121);
                Integer b=121;  //b=new Integer(121);
                //同一个对象, 使用的都是内部的cache 维护的Integer 对象.
               //是同一个对象，地址值是相同的
                System.out.println(a==b);// true
               
                Integer c=129;
                Integer d=129;
                // 两个对象. 129 超出了cache的范围.  new 两次对象. 所有== 比较对象内存地址为false .
                System.out.println(c==d);// false
        }

当我们使用多态，父类的引用指向了子类的对象，这实际上是将子类的引用向上自动转型为父类的引用类型；
向上转型：将子类的对象引用，可以自动转换为父类的引用；
向下转型：多态中，可以将父类的引用，强制转换为它所指向的那个子类的类型。
                    注意：要保证强制转换时，所转换的类型一定要是之前父类所指向那个类型;
                        class A
{
        void show(){
                System.out.println("A-->show()");
        }
}
class B extends A
{
        void fun(){
                System.out.println("B-->fun()");
        }
}
class C extends A
{
}
class Demo
{
        public static void main(String[] args)
        {
                A a = new B();//自动的、向上转型
                a.show();//访问的是父类的
        //        a.fun();//编译错误。不能访问子类自有的成员；

                //显示的向下转型，强制转换
                B b = (B)a;
                b.show();//OK
                b.fun();//OK
                A a1 = new B();
        //        C c = (C)a1;//运行时异常

关于代码String str = new String(“abc”);  
注意  是创建了"两个对象 "  一个是new String( ) 对象  存在于堆内存中,  另一个是"abc"保存在常量池中

注意  String  是一个特别的类   String的常量存在于常量池中  常量池在方法区中 ------------  图解  去看视频  老师讲的很清楚

注意          str.equals(“abc”);将返回true
                 (str =="abc")将返回:false   
   解释:   equals   比较的是真正的代表的  东西 而   ==  比较的是地址值

equals  的源代码
  public boolean equals(Object anObject) {
        if (this == anObject) {
            return true;
        }
        if (anObject instanceof String) {
            String anotherString = (String) anObject;
            int n = value.length;
            if (n == anotherString.value.length) {
                char v1[] = value;
                char v2[] = anotherString.value;
                int i = 0;
                while (n-- != 0) {
                    if (v1[i] != v2[i])
                            return false;
                    i++;
                }
                return true;
            }
        }
        return false;
    }

并且  String类在调用时  不用倒包   是一个  特殊的  引用类型类  

还有一点  输出语句System.out.println("++");你会发现输出的都是双引号引起来的东西哎
解释:  因为输出语句  默认重写了toString()  方法   而且  输出引用类型变量时  为地址值  
   但是   输出char数组时   是输出   数组的第一个元素   因为  char数组  直接执行原代码   不经过重写的toString语句


以上  是我的  部分总结   

kenfine 发表于 2015-2-7 07:34
这个问题问的好！

好吧！我是听了去看的迭代器，但是这个增强for的内部实现确实是通过迭代器来实现的。

对象初始化：
子类初始化必须访问父类
先加载成员变量，后加载成员函数
（但是通过super初始化父类内容时，子类的成员变量并未显示初始化；           
等super父类初始化完毕后才进行子类的成员变量显示初始化。）  

Piaget 发表于 2015-2-7 22:52
对象初始化：
子类初始化必须访问父类
先加载成员变量，后加载成员函数

恩恩。今天还看到先加载静态的，后加载构造函数~~~

对象new一个两个礼拜，基础打牢了，才能学好新东西。

彭春晓 发表于 2015-2-8 12:01
对象new一个两个礼拜，基础打牢了，才能学好新东西。

是的  我现在在双元的java基础班  深有体会   面向对象这一块很重要  直接影响你后面的学习   特别是 new  很多人都跪在了这里 包括我在内


所以   一定要搞清楚   不过  我今天恶补了一下   感觉清楚多了  那个  数组中刚出现new的时候  把内存图搞懂   然后  后面的存储和内在原理  你就明白的多  轻松很多   

作为过来人的建议:)

是的  我现在在双元的java基础班  深有体会   面向对象这一块很重要  直接影响你后面的学习   特别是 new  很多人都跪在了这里 包括我在内


所以   一定要搞清楚   不过  我今天恶补了一下   感觉清楚多了  那个  数组中刚出现new的时候  把内存图搞懂   然后  后面的存储和内在原理  你就明白的多  轻松很多   

作为过来人的建议:)

Java中a++与++a的区别：
a++是先调用再自加，++a是先自加再调用，举例说明：
int a = 1;
int b = a++ + 1;
此时b是等于2的（a的值本来就等于1，1+1=2，a先调用完才进行自增）
int a = 1;
int b = ++a + 1;
此时b是等于3的（a先自增1，等于2，然后2+1=3）
再举一个例子：
int a = 1;
int b = a++ + 1;
int c = a+1;
此时b等于2，c等于3，（在int b = a++ + 1操作完成后，a已经执行了自增操作，所以在第二次调用时，a的值已经变化了）

Aily 发表于 2015-2-8 13:24
是的  我现在在双元的java基础班  深有体会   面向对象这一块很重要  直接影响你后面的学习   特别是 new ...

谢谢，其实也有觉得，这个特别重要。

----别停下追逐梦想的脚步

赞！！！！

昨天看到一个问字符串类型怎么转换成int型，今天再找没找到，就把总结的String和int相互转换的方法发在这吧！希望大家一起交流
一.int到String:
  1.使用0长度字符串进行字符串连接
    String str = "" + num;
  2.String.valueOf(int i);
二.String到int:
   1.Integer的构造方法；
    Integer a = new Integer(str2);
        int num1 = a.intValue();
   2.Integer的static valueOf(String s);
Integer b = Integer.valueOf(str2);
                int num2 = b.intValue();
  3.Integer的static parseInt(String s);
int num3 = Integer.parseInt(str2);

import java.util.ArrayList;

public class ListStudent {
        public static void main(String[] args) {
                // 创建集合对象
                List list = new ArrayList();
                // 创建元素对象
                Student s = new Student("赵默笙", 24);
                Student s1 = new Student("何以琛", 25);
                Student s2 = new Student("路远风", 23);
                Student s3 = new Student("林少梅", 24);
                // 存储元素
                list.add(s);
                list.add(s1);
                list.add(s2);
                list.add(s3);
                // 遍历集合
                ListIterator lt = list.listIterator();
                while (lt.hasNext()) {
                        Student s4 = (Student) lt.next();
                        System.out.println(s4.getName() + "***" + s4.getAge());
                }
                //反向遍历
                while(lt.hasPrevious()){
                        Student s5 = (Student) lt.previous();
                        System.out.println(s5.getName()+"***"+s5.getAge());
                }
        }
}

集合中的ListIteratoer中的小知识（ 上面没有写出学生类，只写了个测试类。）
ListIterator迭代器中有反向迭代的方法
判断是否有前一个元素boolean hasPrevious()
返回前一个元素Object previous()
但是必须通过ListIterator迭代器正向遍历之后才能使用反向遍历。        个人感觉没什么用处。               

出现空指针异常的原因是null调用类方法。

刚学到反射，说说自己对反射的理解吧。
总的来说反射就是逆向操作。
先拿到类的字节码，然后通过字节码获取构造函数，字段，方法。然后再来操作这些构造函数，字段，方法。这种操作是反向的，跟我们写代码的时候思路是反着的，所以刚开始学反射的时候都觉得挺难，把思想转过来，倒着走会感觉好多，个人想法有不对的地方希望大神们指出来，多多学习

qiuyuhuaihua 发表于 2015-2-6 22:57
Java 中的参数传递 值传递？or 引用传递？

Java中都是引用传递的，只有地址值被传递了