BlogJava-Annybaby-文章分类-关于Java作业

Super与this区别

和贝贝 — Tue, 19 Oct 2010 15:35:00 GMT

区别 super this

范围是由子类访问父类的内容是直接访问本类中的内容

访问属性             super.父类属性，如果属性没有被覆写，则也可以                                    this本类属性
                                 不写super

访问方法            super.父类方法(),如果方法没有被覆写，则可以                                       this.本类方法(),可以不写this,也表示调用本类的
                                不用加super也表示调用父类中的方法

访问构造           super是访问父类中的构造方法，必须放在首行                                            this 是访问本类中的其他构造，必须放在首行

比如：
class People{
    String name;
    int age;
    public People(String name,int age){
        this.name=name;
        this.age=age;
    }
    public String fun(){
       return ""+name+age;
    }
}
class Student extends People{
    String school;
    public Student(String name,int age,String school){
        super(name,age);
        this.school=school;
    }
   public void print(){
        System.out.println(fun()+this.school);
    }

}
public class Demo(){
public ststic void main(String[] args){
    Student s = new Student("Lucy",21,"理工");
    s.print();
    }
}

和贝贝 2010-10-19 23:35 发表评论

String类的一些用法

和贝贝 — Sun, 17 Oct 2010 14:22:00 GMT

1.String 类中的内容一旦声明则不可改变
2.String有两种赋值方式（直接赋值和用new开辟空间）
3.String是Java中共享模式的一种应用

在这里举一个例子：
public class Text{
          public static void main(String[] args){
            String st="abc";
            System.out.println("abd".equals(st));
       }
}
其中“abc”就是String的匿名对象，String类中的内容一旦声明则不可改变。比如：
public class Text{
          public static void main(String[] args){
            String str1="abc";
            str1+="def";
            System.out.println(str1);
       }
}

        运行结果为abcdeg,过程如下：String str1="abc",证明栈内存中有个str1，在堆内存中的内容是str1+="def";首先是先有“def”在堆内存中开辟空间；然后再进行str1+"def"运算所得的字符串“abcdef”又在堆内存开辟一个空间。原来str1所占的堆内存空间，现在str1+"def"运算所得的字符又赋给str1,所以str1先断开指向“abc”的连接，最后就指向“abcdef”新的空间与其建立连接。
        虽然以上显示String的内容改变了，但是实际上而言，String改变的只是其内存地址的指向，而其本身的内容没有被改变。所以说这样写代码影响程序的性能。

问题：只要是字符串就是一个String匿名对象吗？
            在String类中如果一个字符串已经明确了一个对象的指向，则以后其他的String对象如果声明的内容是一样的，则自动指向同一个空间。
比如:
public class Text{
          public static void main(String[] args){
            String str1="abc";
            String str2="abc";
           System.out.println(str1==str2);
       }
}

原来的“abc”有没被引用到，我们知道原来的“abc”已经被str1引用，那么就不可能再生成另外一个“abc”, 只会将原来的“abc”地址指向str2，那现在str1和str2都指向同一个内存空间地址，比如“abc”内存空间地址为0x1000哈，我们进行System.out.println(str1==str2);

代码中进行“==”比较时得到的运算结果就是true了，所以说如果内存中已经有相同内容的地址话，我们就不要再开辟新的空间了，如果没有的话，那我们就要重新声明开辟新的空间。

在String str1 = new String(“abc”) ;代码中我们知道“abc”是匿名对象，那么在堆内存中就会有块空间是“abc”，紧接着new String("abc") 使用new在堆内存中又开辟了一个空间“abc”,最后String str1 = new String("abc") ;代码将最后生成的“abc”内存地址指向str1,最早的一个“abc”就没使用上。

和贝贝 2010-10-17 22:22 发表评论

方法的覆写与方法的重载的区别：

和贝贝 — Sun, 17 Oct 2010 13:25:00 GMT

重载 (Overloading  ):         放生在一个类中;方法名称相同，参数的类型或个数不同;

重写   / 覆写( Override ): 是发生在继承关系之中，是由子类进行覆写的;方法名称相同，参数的类型或个数相同，方法的访问权限不严格.

方法的复写举例：
class A
{
public void fun(){}
}
class B extends A
{
     public void fun(){}
}
fun被子类复写了注意：子类复写父类的方法时，被复写的方法不能比父类拥有更严格的访问权限。即如果我们把A类中fun()方法的访问权限修改成default，则此时B类中fun()方法的访问权限比A类大。被复写后父类中的方法被子类方法覆盖。一个特殊情况，如果父类中fun()方法访问权限为private，子类的访问权限为default，明确说：这不叫复写，因为父类中的fun()方法子类看不见即父类被重写的方法被覆盖。

和贝贝 2010-10-17 21:25 发表评论

类和对象的联系

和贝贝 — Thu, 14 Oct 2010 11:42:00 GMT

       类与对象是进行面向对象编程的基础。类是具有相同属性特征和行为的多个对象的一种抽象描述。对象是对类的实例化，是类的一个具体体现者。

      总结：类是一个抽象的，一个共性的东西；对象是类的一个具体应用，是一个个性的东西。
      比如人一个People类,在类中描述人具有的某种特征和行为。人都有姓名年龄等属性，人会吃饭睡觉跑步等行为，这是对人的一个抽象的描述。如果对于张三，这是针对具体某个人的，他们有具体的姓名年龄，也有People类所具有的行为，所以他是People的一个对象。

和贝贝 2010-10-14 19:42 发表评论