Java基础

标签：

*多用组合，少用继承这句话的优点是组合比继承更灵活，组合常常利用接口，实现了所谓的“多继承”效果。

继承：

package test;

//假设我们有一个名为Insect（昆虫）的类，这个类包含两个方法：1）移动move()； 2）攻击attack()。代码如下：
class Insect {
	private int size;
	private String color;

	// 构造函数
	public Insect(int size, String color) {
		this.size = size;
		this.color = color;
	}

	public int getSize() {
		return size;
	}

	public void setSize(int size) {
		this.size = size;
	}

	public String getColor() {
		return color;
	}

	public void setColor(String color) {
		this.color = color;
	}

	public void move() {
		System.out.println("Fly");
	}

	public void attack() {
		move(); // 假设昆虫在攻击前必须要先移动一次
		System.out.println("Attack");
	}
}

<pre name="code" class="java">package test;

//现在，你想要定义一个名为Bee（蜜蜂）的类。Bee（蜜蜂）是Insect（昆虫）的一种，
//但实现了不同于Insect（昆虫）的attack()和move方法。这时候我们可以用继承的设计机制来实现Bee类，就像下面的代码一样：
class Bee extends Insect {
    public Bee(int size, String color) {
        super(size, color);
    }
 
    public void move() {
        System.out.println("Fly2");
    }
 
    public void attack() {
        move();
        super.attack();
    }
}

package test;

public class InheritanceVSComposition {
	public static void main(String[] args) {
		Insect i = new Bee(1, "red");
		i.attack();
	}
}

<pre name="code" class="java">输出结果：
Fly2
Fly2
Attack

使用继承，子类覆盖父类属性和方法。

package test2;
//attack这一功能不再是一个方法，而是被抽象为一个接口。
public interface Attack {
	public void move();

	public void attack();
}

package test2;

//通过对Attack接口的实现，就可以在实现类当中定义不同类型的attack。
class AttackImpl implements Attack {
	private String move;
	private String attack;

	public AttackImpl(String move, String attack) {
		this.move = move;
		this.attack = attack;
	}

	@Override
	public void move() {
		System.out.println(move);
	}

	@Override
	public void attack() {
		move();
		System.out.println(attack);
	}
}

package test2;
//因为attack功能已经被抽象为一个接口，所以Insect类不再需要有attack方法。
class Insect {
  private int size;
  private String color;

  public Insect(int size, String color) {
      this.size = size;
      this.color = color;
  }

  public int getSize() {
      return size;
  }

  public void setSize(int size) {
      this.size = size;
  }

  public String getColor() {
      return color;
  }

  public void setColor(String color) {
      this.color = color;
  }
}

package test2;

public class Bee extends Insect implements Attack {

	private Attack attack;

	public Bee(int size, String color, Attack attack) {
		super(size, color);
		this.attack = attack;
	}

	public void move() {
		attack.move();
	}

	public void attack() {
		attack.attack();
	}

}

package test2;


public class InheritanceVSComposition2 {
  public static void main(String[] args) {
      Bee a = new Bee(1, "black", new AttackImpl("fly", "move"));
      a.attack();


      // if you need another implementation of move()
      // there is no need to change Insect, we can quickly use new method to attack


      Bee b = new Bee(1, "black", new AttackImpl("fly2", "sting"));
      b.attack();
  }
}

输出结果：
fly
move
fly2
sting

*Java中continue用于处理循环中遇到例外情况跳出当前循环进行下一循环，处理此类情况有其原生的优势。

* 实体类命名规则：驼峰法；数据库命名规则：下划线法

也就是说 List 是一个有序的、可重复的对象容器接口，Set是一个无序的、不可重复的对象容器接口 。

后面都讲了 Set 是如何实现不重复的 ：为了避免多次重复的使用 equal 方法带来的系统负担 ，

set 首先调用hashCode 方法来检测 是否被占用 如果被占用 然后调用 equal 方法判断被占用的是否相同

Java基础

标签：

原文地址：http://blog.csdn.net/u011971132/article/details/51498145