Java暑期学习第十三天日报

一、今日学习的内容：

今天学习了5.1和5.2的内容。5.1是类的继承，5.2是Java中的多态变化。

二、遇到的问题：

对于Java中对象的克隆理解和应用上存在一些问题，其主要问题在深层克隆，我对此需要在这方面的例题上多练习。另外关于object类中的常用方法不是很熟悉。

三、明日计划：

明天计划学习5.3和5.4的内容。

今天具体学习的内容如下：

1.Object类及其方法：

（1）Object类是所有Java类的父类，定义如下 public class Object ，Object类是类层次结构的根类。

Object类的常用方法如下：

Object常用方法	说明
protected Object clone() throws CloneNotSupportedException	创建并返回此对象的一个副本
public boolean equal(Object obj)	指示其他某个对象是否与该对象相等
public final Class<?>getClass()	返回此Object类的运行时类，返回的Class对象是由 static synchronized方法锁定的对象
public final void notify()	唤醒在此对象监视器上等待的单个线程，如果所有线程都在此对象上等待，咋会选择唤醒其中一个线程，选择是任意性的，并在对实现做出决定时发生县城通过调用其中一个wait的方法，在对象的监视器上等待
public final void notifyAll()	唤醒在此对象监视器上等待的所有线程,并在对实现做出决定时发生县城通过调用其中一个wait的方法，在对象的监视器上等待
public String toString()	返回该对象的字符串表示通常to string方法会返回一个以“文本方式表示”此对象的字符串，结果应是一个简明但易于读懂信息表达式，建议所有子类都重写该方法

2.对象的克隆

（1）克隆的限制

克隆的限制

被克隆的类必须自己实现Cloneable接口，以指示

Object.clone()方法可以合法的对该实例进行按字

段复制，其中Cloneable只是个标识接口，并没有任何接口方法

实现Cloneable接口的类应该使用公共方法重写Object.clone()。

在Java.lang.Object类中克隆方法如下：

protected Object clone()

throws CloneNotSupportedException

创建并返回此对象的一个副本，按照惯例返回的类应该通过super.clone调用

（2）Java克隆的分类

浅层克隆

主要复制基本对象的值

深层克隆

当类存在聚合关系时，克隆时就必须考虑

聚合对象的克隆。可复制引用类型的字段

浅层克隆实例：

public class clone1 {
    public static void main(String [] args) throws CloneNotSupportedException{
        Person p=new Person(21,"小明");
        Person p2=(Person)p.clone();
        System.out.println("克隆前："+p.getName()+","+p.getAge());
        System.out.println("克隆后："+p2.getName()+","+p2.getAge());
        
        if(p==p2)
            System.out.println("p和p2的地址相同");
        else
            System.out.println("p和p2的地址不同");
            
    }

}

 class Person implements Cloneable{
    private int age;
    private String name;
    public Person(int a,String s) {
        age=a;
        name=s;
    }
    public void setAge(int age) {
        this.age=age;
    }
    public int getAge() {
        return age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name=name;
    }
    @Override
    protected Object clone() throws CloneNotSupportedException{
        return super.clone();
    }
    
}

测试截图

深层克隆实例：

public class clone2 {
    public static void main(String [] args) throws CloneNotSupportedException{
        Person per=new Person(13,"小力");
        P p=new P(per);
        P p2=(P)p.clone();
        
        System.out.println("克隆前："+p.getper().getName()+","+p.getper().getAge());
        System.out.println("克隆后："+p2.getper().getName()+","+p2.getper().getAge());
        
        if(p==p2)
            System.out.println("p和p2的地址相同");
        else
            System.out.println("p和p2的地址不同");
        if(p.getper()==p2.getper())
            System.out.println("p中的Person对象和p2中的Person对象相等！");
        else
            System.out.println("p中的Person对象和p2中的Person对象不相等！");
            
    }

}

 class P implements Cloneable{
    Person per;
    public P(Person per) {
        this.per=per;
    }
    public Person getper() {
        return per;
    }
    public void setper(Person per) {
        this.per=per;
    }
    @Override
    protected Object clone() throws CloneNotSupportedException{
        P p=(P)super.clone();
        p.per=(Person)this.per.clone();
        return p;
    }
    
}

测试截图：

3.Java的继承

Java中的继承使用关键字extends，形式为：class 子类 extends 父类 { }

子类可以享有父类中的非私有方法和非私有属性。

实例如下：

package atm;

public class person {
    public String name;
    public int age;
    public String sex;
    public void setName(String name) {
        this.name=name;
    }
    public void setAge(int age) {
        this.age=age;
    }
    public void setSex(String sex) {
        this.sex=sex;
    }
    public String getName() {
        return name;
    }
    public int getAge() {
        return age;
    }
    public String getSex() {
        return sex;
    }

}

public class student extends person {
    private String department;
    private String specialty;
    public static void main(String []args) {
        student s=new student();
        s.setName("小飞");   //调用父类中的方法
        s.setAge(17);         //调用父类中的方法
        s.setSex("男");        //调用父类中的方法
        String A=s.getSex();   //调用父类中的方法
        int n=s.getAge();
        String str=s.name;  //调用父类中的属性
        System.out.println("姓名:"+str);
        System.out.println("性别:"+A);
        System.out.println("年龄:"+n);
    }

}

测试截图：

4.super关键字

子类可以使用super关键字对父类的非私有属性和方法进行访问，还可以调用父类的构造函数。

super关键字调用父类的属性和方法：

package atm;

public class person {
    public String name;
    public int age;
    public String sex;
    public void setName(String name) {
        this.name=name;
    }
    public void setAge(int age) {
        this.age=age;
    }
    public void setSex(String sex) {
        this.sex=sex;
    }
    public String getName() {
        return name;
    }
    public int getAge() {
        return age;
    }
    public String getSex() {
        return sex;
    }

}
public class student extends person {
    private String department;
    private String specialty;
    String name=super.name ; //调用父类的属性name
    String sexl=sex;
    public void test() {
        super.getAge();     //调用父类的方法
        getName();
    }


}

使用super关键字调用父类的构造函数

super() 调用的是父类的无参构造函数，super（参数）调用的是含参构造函数

public class person2 {
    public String name;
    public int age;
    public person2() {
        
    }
    public person2(String name,int age) {
        this.name=name;
        this.age=age;
    }
    
    
}
public class student2 extends person2{
    public student2() {
        super("小米",15);
        
    }
    public static void main(String[] args) {
        student2 s=new student2();
        String str=s.name;
        int a=s.age;
        System.out.println("姓名："+str);
        System.out.println("年龄："+a);
    }

}

5.多态

（1）Java中多态的的体现具体表现在重载和覆盖。覆盖是指子类重写了父类的方法，但子类方法重写时修饰符的权限要大于或等于父类的修饰符权限。

（2）类型检测：

向上转型

父类对象=new 子类（）;

向下转型

父类对象1=new 子类（）;

子类对象2=（子类）对象1；

当子类中特有一个方法时，使用向上转型会丢掉子类中特有的方法，此时需要用到向下转型。

6.动态绑定

（1）动态绑定具体体现在向上转型上。而关于静态绑定，Java中的变量都是静态绑定的，只有private，static，final是静态绑定的。