继承
继承：减少冗余（重复） 如果很多类的属性，方法 重复出现，重复--->父类，继承
严格继承：
is a是一个
子类 是一个 父类
例： dog 是一个pet penguin 是一个pet house 是一个pet （这就不能继承，因为读不通）
注意：如果一个方法，方法名相同，但方法体不同，也不能提取到父类
只有完全相同的属性，方法，能提取到父类
总结： a() this.a() : 当前类a()，如果没 去父类找a()；
super.a() ：直接去父类中找a()
this：当前类
super：父类
this/super:构造方法 ：this()调用本类构造；super()调用父类构造
构造方法：
无惨构造方法：
public 类名(){
}
如果类中 没有任何构造方法，则系统自动提供一个 无参构造。
public Dog(){}
如果类中 已经存在了任何构造方法，则系统不再提供无惨构造
一般建议：如果给类中 编写构造方法，则手动编写一个无惨构造，防止报错
含参构造的作用：一次性给多个属性赋值
作用：1. 实例化（产生对象） Dog dog=new Dog();
2. 一次性给多个属性赋值
3. 互补
多个构造方法之间 不能循环调用
如果在构造方法中，通过this(...)/super()调用其他的构造方法，
则this()必须放在第一行。（两个不能共存）
子类继承父类时，private，构造方法是不能被继承的。但是 子类可以显示的调用父类构造super dog-->pet
package pet;
public class Dog extends Pet
{
//真正无返回值
// public Dog()
// {
// System.out.println("dog的构造方法....");
// }
private String strain;
private String other;
//通过两个方法才能赋两个值 ，但构造方法可以一次性赋多个值
public Dog(String strain,String other)
{
//this(); 死循环
System.out.println("2个参数的构造方法："+strain+"\t"+other);
this.strain=strain;
this.other=other;
}
public Dog(String strain)
{
this("a","b");
System.out.println("1个参数的构造方法");
this.strain=strain;
}
//0-->1-->2 2-->0(会死循环，所以可以删一个调用)
/*
结果为：
2个参数的构造方法：a b
1个参数的构造方法
无惨构造
*/
public Dog()
{
// super();//调用父类无惨构造
super("a",2,1);
//this("a");
System.out.println("子类无惨构造");
//构造方法 不能通过方法名 直接调 Dog dog=new Dog();
//非构造方法（普通方法） 通过方法名 直接调
//构造方法直接 可以相互调用，this
//Dog("abc");错误的
setStrain("abc");
}
public String getStrain() {
return strain;
}
//子类重写父类的方法：父类中已经存在了a()，子类又重写了一个a()
public void a()
{
System.out.println("子类Dog......");
}
//无返回值，返回值为空
//访问修饰符 返回值类型 方法名(参数列表){方法体}
public void setStrain(String strain) {
this.strain = strain;
}
public void print()
{
System.out.println("print..");
System.out.println(getName()+"\n"+getHealth()+"\t"+getLove()+"\n"+this.strain+"\n"+this.other);
// //a()：先在当前类中a(),如果有则直接使用；如果没有，去父类中寻找
// a();
// this.a(); //先在当前类里面找，如果没有，在去父类中寻找
// //如果只想调父亲的：super
// super.a(); //跨过子类，直接去父类里面找a();
}
}
![]()
package pet;
public class Penguin extends Pet
{
private String strain;
private boolean sex;
public String getStrain() {
return strain;
}
public void setStrain(String strain) {
this.strain = strain;
}
public boolean getSex() {
return sex;
}
public void setSex(boolean sex) {
this.sex = sex;
}
public void print()
{
System.out.print(getName()+"\n"+getStrain()+"\t"+getLove()+"\n"+this.sex);
}
}
package pet;
public class Pet
{
private String name;
private int health;
private int love;
public Pet()
{
System.out.println("父类无惨构造...");
}
public Pet(String name, int health, int love)
{
System.out.println("父类3个参数的构造方法");
this.name = name;
this.health = health;
this.love = love;
}
public void a()
{
System.out.println("父类 pet....");
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getHealth() {
return health;
}
public void setHealth(int health) {
this.health = health;
}
public int getLove() {
return love;
}
public void setLove(int love) {
this.love = love;
}
}
package pet;
import java.util.Date;
public class TestPet
{
public static void main(String[] args)
{
// Dog dog=new Dog(); //print..
//Dog dog=new Dog("哈士奇","other123...");
//dog.setHealth(98); //互补 构造方法赋一半，set赋一半
// dog.setName("wc");
// dog.setLove(99);
// dog.setHealth(98);
// dog.setStrain("哈士奇");
//dog.print();
Dog dog=new Dog();
}
}
浙公网安备 33010602011771号