构造方法 方法的重载、重写 继承

    1）构造方法：

        构造方法是方法的一种特殊显示，它有两个特征：1）无返回类型（注意，不是返回类型为void，而是根本就没有返回类型）。2）方法名与类名相同。

        当我们定义一个类的对象时，eg：我们已经有了一个Dog类，当定义一个Dog的对象时，Dog dog = new Dog();在这个语句中，new Dog(),就是创建了一个类的对象，同时也调用了该类的构造方法，（对于构造方法，我们只能用new 关键字调用）。

        当一个类没有构造方法时，那么JVM在执行时会默认添加一个没有参数没有方法体的构造方法。但是一旦当我们自己给出了构造方法后，JVM将不会在提供默认的构造方法。

        对于一个类，可以定义多个构造方法，构造方法之间可以相互调用，但是最多只能调用一个构造方法。

        之所有要用到构造方法，是因为，对于有的类，需要设置多个实例变量的值，引入构造方法，方便了多次设置实例变量。eg：

public class Dog {
	
	private String name;
	private int age;
	private float color;
	
	public Dog(String name,float color){
		this.name = name;
		this.color = color;
	}
		
	public Dog(String name,int age,float color){
		this(name, color);//调用构造方法
		//在构造方法上完成一定的封装
		if(age < 0){
			this.age = 10;
		}else{
			this.age = age;	
		}			
	}
	
	public String getName() {
		return name;
	}

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

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		if(age < 0){
			this.age = 10;
		}else{
			this.age = age;	
		}
	}
	public float getColor() {
		return color;
	}
	public void setColor(float color) {
		this.color = color;
	}
		
}

     在该类中，定义了，两个构造方法，其中第二个构造方法调用了第一个构造方法，区别调用的是哪一个构造方法时，是以该方法的参数列表为依据的。

 

    2）方法的重载和重写：

        方法的重载是指几个方法具有相同的访问修饰符、返回类型，方法名，只是方法的参数列表不同而已(这里的不同指的是参数的数量，顺序和类型)，比如上面代码中的两个构造方法就是方法的一种重载。

public class Person {
	public void add(int num1,int num2){
		System.out.println(num1 + num2);
	}
	
	public void add(float num1,float num2){
		System.out.println(num1 + num2);
	}
	
	public void add(int num,int...nums){
		int total = 0;
		for (int i = 0; i < nums.length; i++) {
			total += nums[i];
		}
		System.out.println(total);
	}
}

public class Test {
	public static void main(String[] args) {
		
		Person p = new Person();
		p.add(5,2,2,45);
		p.add(5, 4);
		p.add(8.5f, 7.4f);
         }
}

     在Person类中定义的三个add()方法，相互构成方法的重载，在Test中，通过参数列表的不同，JVM确定调用的是哪一个add()方法。

     从JDK5之后，引入了不定项参数，就是Person类中的第三个add()方法，对于一个方法，其参数列表只能有一个不定项参数，且不定项参数是参数列表中的最后一个参数。对于不定项参数，可以传入一个或多个参数，也可以不传入参数。

 

    3)类的继承：

        被继承的类称为父类（超类/基类），实现继承的类称为子类，子类有父类的属性和方法，也可以在子类中定义自己特有的方法和属性。

        类的继承具有传递性，且是单继承。

 

        继承中的构造，对于一个子类对象的创建，首先会先创建父类对象，即在调用子类构造方法时，先构造父类的构造方法。如果父类的构造方法不是默认的，而是重写的，那么在子类的构造方法的方法体中的第一句应该是调用父类的构造方法，使用super关键字调用。

 

    4)方法的重写：

        子类重写从父类继承过来的方法，在子类中，方法签名(访问修饰符，方法名，参数列表)与父类的相同，不同的仅仅好似方法体，再次，注意与方法的重载的区别。

public class Animal {
	
	private String name;
	private int age;
	
	public Animal(String name){
		System.out.println(name+"我是动物");
	}
	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	
	public void eat(){
		System.out.println("吃食物");
	}
}


public class Cat extends Animal {
	
	public Cat(){
		super("nihao");
		System.out.println("我是猫");
	}
	//@Override 用于确认重写的正确性
	public void eat(){
		super.eat();//重写的基础上，调用父类的eat()方法
		System.out.println("猫吃食物");
	}
	
	public void eatFather(){
		super.eat();
	}
}

public class Test {
	public static void main(String[] args) {
		
		/*Cat c = new Cat();//先执行父类的构造方法，再执行子类的构造方法
		c.eat();
		c.eatFather();
        }
}

 执行结果如图：

 在此例中，应注意父类与子类构造方法的参数类型。