java基础-1.面向对象

面向对象/语法/异常/常用api/数据类型/io/集合/多线程/高并发

一、面向对象：

1.继承；封装；多态（抽象）
实现多态的机制
靠的是父类或接口定义的引用变量可以指向子类或具体实现类的实例对象，而程序调用的方法在运行期才动态绑定，就是引用变量所指向的具体实例对象的方法，也就是内存里正在运行的那个对象的方法，而不是引用变量的类型中定义的方法。
2.修饰符public ； protected； default； private
3.clone对象
（1.clone深拷贝地址不同，值相同；Cloneable接口，实现clone方法。2. 浅拷贝地址同，值相同）

 System.out.println("深拷贝");
    try {
        p1 = (Dog) p.clone();
    } catch (CloneNotSupportedException e) {
        e.printStackTrace();
    }
    System.out.println(p);
    System.out.println(p1);

打印结果：

 深拷贝
Dog@4554617c
Dog@74a14482

图1-深拷贝（复制对象）

 System.out.println("浅拷贝");
        p1 = p;
        System.out.println(p);
        System.out.println(p1);

打印结果：

           浅拷贝
Dog@4554617c
Dog@4554617c

图2-浅拷贝（复制引用）

具体代码：

//实现Cloneable接口（）。
public class CloneDemo {
}
class Dog implements Cloneable {
    private int age;
    private String name;

    public Dog( int age, String name ) {
        this.age = age;
        this.name = name;
    }
    public Dog() {
    }
    public int getAge() {
        return age;
    }
    public String getName() {
        return name;
    }
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return (Dog) super.clone();
    }
}
class Dome1 {
    public static void main( String[] args ) throws InterruptedException {
        Dog p = new Dog(23, "zhang");
        Dog p1 = null;
//        System.out.println("深拷贝");
//        try {
//            p1 = (Dog) p.clone();//克隆
//        } catch (CloneNotSupportedException e) {
//            e.printStackTrace();
//        }
//        System.out.println(p);
//        System.out.println(p1);
        System.out.println("浅拷贝");
        p1 = p;//赋值
        System.out.println(p);
        System.out.println(p1);
    }

}

//序列化和反序列化(简单方便)深拷贝2
import java.io.*;

public class CloneDemo {
    public static void main( String[] args ) {
        Student student = new Student( "liyu", 22 );

        System.out.println( "name==" + student.getName() );
        System.out.println( "age==" + student.getAge() );
        System.out.println( "class==" + student.getClass() );
        System.out.println( "toString==" + student.toString() );
    }
}


class Student implements Serializable {
    private String name;
    private Integer age;

    public Student( String name, Integer age ) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName( String name ) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge( Integer age ) {
        this.age = age;
    }
    //重写toString
    @Override
    public String toString() {
        return "我的名字是" + name + "年龄是" + age;
    }

    public Student myClone() {

        Student stu = null;
        try {
            //将对象序列化到流里
            ByteArrayOutputStream os = new ByteArrayOutputStream();
            ObjectOutputStream oos = new ObjectOutputStream( os );
            oos.writeObject( this );
            //将流反序列化成对象
            ByteArrayInputStream is = new ByteArrayInputStream( os.toByteArray() );
            ObjectInputStream ois = new ObjectInputStream( is );
            stu = (Student) ois.readObject();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        return stu;

    }

}

> java内部类

内部类可以直接访问外部类中的成员(包括私有成员),
而外部类要访问内部类中的成员必须要建立内部类的对象

总结：克隆可分为深拷贝和浅拷贝,实际应用中一般使用深拷贝
深拷贝有两种实现方法1.实现Cloneable接口（）2.利用序列化和反序列化(简单方便)
参考：1.Java的JVM的内存分为3个区：堆(Heap)、栈(Stack)和方法区(Method Area)。