java16:构造器 继承

默认构造器
类中一定有构造器

如果类没有声明构造器，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(){
}
}

本文出自 “浪漫的偷笑” 博客，请务必保留此出处http://lmdtx.blog.51cto.com/6942028/1700050