java 基础，

java 基础，

1 java 三大特性

     1 封装 

        定义： 把对象的属性和操作结合为一个独立的整体，并尽量隐藏对象内部实现的细节。

        好处： ① 对象的数据封装特性彻底消除了传统结构方法中数据与操作分离所带来的种种问题，提高了程序的可复用性和可维护性，降低了程序员保持数据与操作内容的负担。

                     ②对象的数据封装特性还可以把对象的私有数据和公共数据分离开，保护了私有数据，减少了可能的模块间干扰，达到降低程序复杂性、提高可控性的目的。

                       封装确实可以使我们容易地修改类的内部实现，而无需修改使用了该类的客户代码。

                

      2 继承

             定义：继承是面向对象最显著的一个特性, 继承是从已有的类中派生出新的类，新的类吸收继承类的属性和行为，并能扩展新的能力。

             好处：复用以前代码，提高开发效率。 

             缺点： 父类变，子类必须变， 继承是一种强耦合，父类对子类来说是完全透明的

             继承注意事项：  子类拥有父类非private 属性和方法。子类拥有自己的属性和方法。子类用自己的方式实现父类的方法。父类构造器不能被子类继承，子类构造器必须调用父类构造器，以便对父类初始化，

             protect关键字： 对类的用户而言，他是private，对子类和同一个包的类是public 

             继承关系是is a的关系，这决定了子类可以向上转型为父类，

     3 多态

            在面向对象语言中，接口的多种不同的实现方式即为多态。多态性是允许你将父对象设置成为一个或更多的他的子对象相等的技术，赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。有类的继承和接口的实现两种方式实现多态

            好处：把不同的子类对象都看做父类，屏蔽不同子类对象之间的差异，做出通用的编程，适应需求不断变化

            注意：子类由于向上转型为父类，只能访问父类拥有的方法和属性，并且可以调用子类重写的父类方法。

                     编译时多态：指重载，类内部的多态，同一个方法名不同参数，

                     运行时多态： 指重写，父类和子类间多态，

                   Java实现多态有三个必要条件：继承、重写、向上转型

                多态 优先级：this.show(O)、super.show(O)、this.show((super)O)、super.show((super)O)。查找本类中是否有重写了的父类方法show（O），因为子  类拥有父类方法，查找父类是否拥有方法show(O)，而子类没有重写，

          2 接口和抽象类

               接口和抽象类是Java语言对抽象的两种支持，这两种机制赋予Java面向对象强大能力。

              接口是对动作的抽象，抽象类是对根源的抽象。抽象类表示的是，这个对象是什么。接口表示的是，这个对象能做什么。

              接口里定义的变量只能是公共的静态的常量，抽象类中的变量是普通变量

            3 浅拷贝和深拷贝

                   浅拷贝：对象的浅拷贝会对“主”对象进行拷贝，但不会复制主对象里面的对象。"里面的对象“会在原来的对象和它的副本之间共享。

                  

public class Person {
    private Name name;
    private Address address;

    public Person(Person originalPerson) {
         this.name = originalPerson.name;
         this.address = originalPerson.address;
    }
[…]
}

               深拷贝：深拷贝是一个整个独立的对象拷贝。如果我们对整个 Person对象进行深拷贝，我们会对整个对象的结构都进行拷贝。

              

public class Person {
    private Name name;
    private Address address;

    public Person(Person otherPerson) {
         this.name    =  new Name(otherPerson.name);
         this.address =  new Address(otherPerson.address);
    }
[…]
}

class Clas implements Cloneable{
    private String name;
    private Date date;

    public Date getDate() {
        return date;
    }

    public void setDate(Date date) {
        this.date = date;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    @Override
    protected Object clone() throws CloneNotSupportedException {
        // TODO Auto-generated method stub
        return super.clone();
    }
}

          object.clone方法是浅复制，可以修改clone方法变为深复制。

 

	@Override
	protected Clas clone()  {
		// TODO Auto-generated method stub
		Clas c = null;
		try {
			c = (Clas) super.clone();
			c.setDate(new Date(date.getTime()));
		} catch (CloneNotSupportedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return c;
	}

利用序列化实现对象的拷贝

public class CloneUtils {
    @SuppressWarnings("unchecked")
    public static <T extends Serializable> T clone(T obj){
        T cloneObj = null;
        try {
            //写入字节流
            ByteArrayOutputStream out = new ByteArrayOutputStream();
            ObjectOutputStream obs = new ObjectOutputStream(out);
            obs.writeObject(obj);
            obs.close();
            
            //分配内存，写入原始对象，生成新对象
            ByteArrayInputStream ios = new ByteArrayInputStream(out.toByteArray());
            ObjectInputStream ois = new ObjectInputStream(ios);
            //返回生成的新对象
            cloneObj = (T) ois.readObject();
            ois.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return cloneObj;
    }
}