默认构造器

    类中一定有构造器

    如果类没有声明构造器，java编译器提供默认构造器

    如果类中声明了构造器,java不在提供默认构造器

java 根据 参数 去找 对应构造器 

package day16;

public class Demo01 {

	public static void main(String[] args) {
		dog wangcai = new dog();// 调用 java默认给dog 分的构造器
		// cat tom2= new cat(); //编译错误，没有构造器cat（）
		cat tom = new cat("tom");// 只有构造器cat（String），因为自己手动创建了构造器
	}

}

class dog {

}

class cat {
	public cat(String name) {
		System.out.println(name);
	}
}

继承：

    子类型 父类型

    子类型 继承父类型的属性和方法

    子类型是多找多样的。

    父类型定义的变量可以引用子类型实例

多态：

    多种多样

向上造型：

    

继承时候的构造器

    类一定有构造器

     构造器不能被继承

    子类的构造器中一定调用父类的构造器

    子类默认调用父类无参数构造器

    可以使用super()调用在子类构造器中父类构造器   

        super() 调用父类的无参构造器。不管你添不添加都有，父类中没有无参数构造器，就要在子类中使用spuer(参数)，不然就会有编译错误 

            只能在子类构造器中使用

            只能在子类构造器的第一行

package day16;
public class Demo02 {
	public static void main(String[] args) {
		new s();//main开始执行 使用 new 调用 s（） 子类的构造器， 子类默认调用父类无参构造器执行输出f() 然后在执行下一步 回到 子类 输出s() 
	}（）
}
class s extends f {
	public s() {
		//super();//你加或者不加 他都在这里。
		System.out.println("s()");
	}
}
class f {
	public f() {
		System.out.println("f()");
	}
}

package day16;
public class Demo03 {
	public static void main(String[] args) {
		new s();
	}
}
class s extends f {
	public s() {
		super(10);//需要明确的写出来
		System.out.println("s()");
	}
}
class f {
	public f(int f) {
		System.out.println("f()");
	}
}

子类中定义与父类型同名属性:

    java支持子类型和父类型定义同名属性

    属性的访问是绑定到变量的类型    

    很少使用

方法的重写: 功能的修改

    在子类中修改父类的行为，重写就是为了修改。

    语法： 子类中定义与父类星泪相同的方法（方法名一样，参数一样）

        调用时调用对戏那个的方法

    

重写也叫做覆盖

重写和 重载的区别： 他们两个就没有关系！！！！

重写：

    子类型中修改 父类型的方法

    在子类型中定义与父类型方法名和参数一样的方法

    在调用时候 根据对象的类型 来调用相应的方法

重载：

    方法名一样参数不同的方法 一般的功能相近的不同的方法

    调用时候根据调用参数的类型来识别方法 

package day17;

public class Demo04 {
	public static void main(String[] args) {
		F obj = new S();// 根据对象 调用重写的方法
		A a = new A();
		a.print(obj);// print F 根据参数 obj 的类型 F 去调用重载的方法。
	}
}

class A {
	public void print(F obj) {
		System.out.println("print F");
		obj.print();
	}

	public void print(S obj) {
		System.out.println("print S");
		obj.print();
	}
}

class F {
	public void print() {
		System.out.println("F");
	}
}

class S extends F {
	public void print() {
		System.out.println("S");
	}
}

package test02;
public class Two {
	public static void main(String[] args) {
		// 使用继承可以实现代码的重用，
		// 在java语言中，需要通过extends关键字实现类的继承。
		// 继承完成后，子类（Sub class）可以继承父类（Super class）的成员变量及成员方法，
		// 同时子类也可以定义自己的成员变量和成员方法。
		// 届时，子类将具有父类的成员及本类的成员。需要注意的是，Java语言不支持多重继承，
		// 一个类只能继承一个父类，但一个父类可以有多个子类。	
		animal tom = new Cat("tom",5,"male");//定义父类型的引用可以指向子类的对想  向上造型
		System.out.println(tom.kind + ":" + tom.name + ":" + tom.age + ":" + tom.sex);
		//子类可以重写（覆盖）继承自父类的方法，即方法名和参数列表与父类的方法相同，但是方法的实现不同。
		tom.print();//调用 tom 引用对象的方法
		animal k = new animal("cat");
		k.print();
	}
}       
class animal {
	String kind;
	String name;
	String sex;
	int age;
	public animal(String kind) {//类一定有构造器, 构造器不能被继承
		this.kind = kind;
	}
	public void print(){//父类中的print 方法
		System.out.println(kind);
	}
	public void print
}

class Dog extends animal {
	//只能在子类构造器中使用,只能在子类构造器的第一行
	public Dog() {//子类的构造器中一定调用父类的构造器可以使用super()调用在子类构造器中父类构造器 
		super("dog");//事实上，子类的构造方法中是必须要通过super关键字来调用父类的构造方法的，这样才可以保证妥善的初始化继承自父类的成员变量		
	}
}
class Cat extends animal {
	public Cat(String name,int age,String sex) {
		super("cat");
		this.sex = sex;
		this.name = name;
		this.age = age;
		
	}
	//在java语言中，子类可以重写（覆盖）继承自父类的方法，即方法名和参数列表与父类的方法相同，但是方法的实现不同。
	public void print(){//子类中重写的方法
		System.out.println(this.kind + this.name + this.age + this.sex);
	}
}
class MaleDog extends Dog{
	public MaleDog(){//子类默认调用父类无参数构造器
		//如果子类的构造方法中没有调用父类的构造方法，则java编译器会自动的加入对父类无参构造方法的调用
		//父类中没有无参数构造器，就要在子类中使用spuer(参数)，不然就会有编译错误
		super();//你不写 编译器也会帮你加上
		
	}
}
class Bitch extends Dog {
	public Bitch(){
	}
}