java继承
1.方法继承
animal类
package com.imooc.animal; public class Animal { protected String name; //名字 private int month; //月份 private String species; //品种 //如果这里没有定义构造方法，编译器会自动生成 public Animal(){} public String getName() { return name; } public void setName(String name) { this.name = name; } public int getMonth() { return month; } public void setMonth(int month) { this.month = month; } public String getSpecies() { return species; } public void setSpecies(String species) { this.species = species; } public void eat(){ //子类只能继承父类的非私有成员，protected可以允许系内继承。 System.out.println(this.getName() + " eating"); } }
cat类
package com.imooc.animal; public class Dog extends Animal { private String sex; //性别 public Dog() {} public String getSex() { return sex; } public void setSex(String sex) { this.sex = sex; } //睡觉 public void sleep(){ //以下几种打印方式都是可行的 System.out.println(this.getName() + " sleep"); // System.out.println(getName() + " sleep"); //下面方式必须是属性可继承。public/protected // System.out.println(super.name + " sleep"); // System.out.println(this.name + " sleep"); // System.out.println(name + " sleep"); //使用this.name和name都可以的原因，编译器会寻找这个 //现在本实例空间内寻找，然后去父类空间寻找 } }
Dog类
package com.imooc.animal; public class Cat extends Animal { private double weight; //体重 public Cat() {} public double getWeight() { return weight; } public void setWeight(double weight) { this.weight = weight; } //跑动方法 public void run() { System.out.println(this.getName()+" Running"); } }
Test测试方法
package com.imooc.test; import com.imooc.animal.Cat; import com.imooc.animal.Dog; public class Test { public static void main(String[] args) { Cat one = new Cat(); one.setName("花花"); one.setSpecies("中华田园猫"); one.eat(); one.run(); System.out.println("---------------------------------"); Dog two = new Dog(); two.setName("妞妞"); two.setMonth(1); two.eat(); two.sleep(); } }
2.方法的重写
animal类
package com.imooc.animal; public class Animal { protected String name; //名字 private int month; //月份 private String species; //品种 public int temp = 15; //如果这里没有定义构造方法，编译器会自动生成 public Animal(){} public String getName() { return name; } public void setName(String name) { this.name = name; } public int getMonth() { return month; } public void setMonth(int month) { this.month = month; } public String getSpecies() { return species; } public void setSpecies(String species) { this.species = species; } public void eat(){ //子类只能继承父类的非私有成员，protected可以允许系内继承。 System.out.println(this.getName() + " eating"); } public void eat(String name){ System.out.println(name + " eating"); } }
Dog类
package com.imooc.animal; public class Dog extends Animal { private String sex; //性别 // 属性值也是可以重写的，不过必须是public的访问类型 public int temp = 300; public Dog() {} public String getSex() { return sex; } public void setSex(String sex) { this.sex = sex; } //睡觉 public void sleep(){ System.out.println(this.getName() + " sleep"); } /* * 方法重载 * 1、同一个类中 * 2、方法名相同，参数列表不同（参数顺序、个数、类型） * 3、方法返回值、访问修饰符任意 * 4、与方法的参数名无关 * */ private String sleep(String name) { return name; } /* * 方法重写（覆写） * 1、有继承关系的子类中 * 2、方法名相同，参数列表相同（参数顺序、个数、类型），方法返回值相同 * 3、访问修饰符，访问范围需要大于等于父类的访问范围 * 4、与参数名无关 * */ public void eat(){ System.out.println(this.name + " 最近没有食欲，Dog重写"); } //方法重写，与参数名无关，与参数顺序、个数、类型有关 public void eat(String dogName) { System.out.println(dogName + "Dog被重写"); } }
3.访问修饰符
Java中的访问修饰符主要有以下几类：
• 公有的：public 允许在任意位置访问
• 私有的：private 只允许在本类中进行访问
• 受保护的：protected 允许在当前类、同包子类/非子类、跨包子类调用、跨包非子类不允许
• 默认：允许在当前类、同包子类调用；跨包子类不允许调用
访问修饰符的作用域范围：
4.super关键字——调用父类的方法和属性
当子类继承父类的时候，如果子类将一个方法进行重写了，
那么在调用的时候，是调用子类的方法还是调用的父类的方法了？
animal类
package com.imooc.animal; public class Animal { protected String name; //名字 public Animal(){} public String getName() { return name; } public void setName(String name) { this.name = name; } //父类定义了eat方法 public void eat(){ System.out.println(this.getName() + " eating"); } public void eat(String name){ System.out.println(name + " eating"); } }
Dog类
package com.imooc.animal; public class Dog extends Animal { public Dog() {} public void eat(){ System.out.println(this.name + " 最近没有食欲，Dog重写"); } public void eat(String dogName) { System.out.println(dogName + "Dog被重写"); } public void sleep(){ eat(); } }
测试代码：
package com.imooc.test; import com.imooc.animal.Dog; public class Test { public static void main(String[] args) { Dog two = new Dog(); two.setName("妞妞"); two.eat(); //妞妞 最近没有食欲，Dog重写 } }
我们发现，默认会调用子类的方法，这也符合调用顺序。
那如果我就想调用父类的方法，该如何了？可以使用super关键字。
super.eat();
不仅是方法，父类中允许子类派生的属性，也可以通过super来继承。
父类的构造方法不允许被继承、不允许被重写。
5.继承的初始化顺序
（1）静态优先
（2）父类优先
（3）非静态块优于构造函数
写出下面代码的执行结果：
public class ExecutionSequence { public static void main(String[] args) { new GeneralClass(); } } class ParentClass{ //静态代码块 static { System.out.println("①我是父类静态块"); } //非静态块 { System.out.println("②我是父类非静态块"); } //父类构造方法 public ParentClass(){ System.out.println("③我是父类构造函数"); } } class GeneralClass extends ParentClass { //子类静态代码块 static { System.out.println("④我是子类静态块"); } { System.out.println("⑤我是子类非静态块"); } public GeneralClass(){ System.out.println("⑥我是子类构造函数"); } } /* ①我是父类静态块 ④我是子类静态块 ②我是父类非静态块 ③我是父类构造函数 ⑤我是子类非静态块 ⑥我是子类构造函数 */
为什么父类的构造函数在子类的非静态代码块之前？
“父类优先的原则”优于“非静态块优于构造函数的原则”。
6.super继承父类的构造方法
public class Animal { String name; //名字 } public class Cat extends Animal { private double weight; //体重 } public class Test { public static void main(String[] args) { Cat one = new Cat(); } }
如果都不定义给构造方法，那么编译器会默认创建无参构造
public class Animal { String name; //名字 public Animal(){ System.out.println("我是父类的无参构造，方法Animal"); } public Animal(String name){ this.name = name; System.out.println("我是父类的带参构造，方法名Animal,参数name"); } } public class Cat extends Animal { private double weight; //体重 public Cat(){ System.out.println("我是子类的无参构造，方法Cat"); } public Cat(String name,double weight) { this.name = name; this.weight = weight; System.out.println("我是子类的带参构造，方法名Cat，参数name、weight"); } }
情况一：
public class Test { public static void main(String[] args) { Cat one = new Cat(); } }
结果：
我是父类的无参构造，方法Animal
我是子类的无参构造，方法Cat
情况二：
public class Test { public static void main(String[] args) { Cat one = new Cat("ke",58); } }
结果：
我是父类的无参构造，方法Animal
我是子类的带参构造，方法名Cat，参数name、weight
虽然构造方法不允许被继承、被重写，但是会影响子类的构造。
子类构造默认调用父类的无参构造方法。
如果你重新定义了有参构造方法，那么构造的时候就必须带参，所以一般都需要写上无参构造。
如果子类希望调用父类的有参构造方法，可以使用super显式继承。
同时super()必须放在子类构造方法有效代码的第一行。
public class Cat extends Animal { private double weight; //体重 public Cat(){ System.out.println("我是子类的无参构造，方法Cat"); } public Cat(String name,double weight) { super(name); this.name = name; this.weight = weight; System.out.println("我是子类的带参构造，方法名Cat，参数name、weight"); } } public class Test { public static void main(String[] args) { Cat one = new Cat("mao",68); } }
结果：
我是父类的带参构造，方法名Animal,参数name
我是子类的带参构造，方法名Cat，参数name、weight
下面是一个常见问题：
public class Animal { String name; //名字 public Animal(String name){ this.name = name; System.out.println("我是父类的带参构造，方法名Animal,参数name"); } } public class Cat extends Animal { private double weight; //体重 public Cat(){ System.out.println("我是子类的无参构造，方法Cat"); //报错 } public Cat(String name,double weight) { this.name = name; this.weight = weight; System.out.println("我是子类的带参构造，方法名Cat，参数name、weight"); } }
上面会直接报错。
子类会默认调用父类的无参构造，但是父类只有有参构造，所以就会报错。
需要super()显式继承或者定义父类的无参构造。
super代表父类对象，this代表当前对象。
当然构造方法也是可以调用同类中的构造方法。
public class Cat extends Animal { private double weight; //体重 public Cat(){ System.out.println("我是子类的无参构造，方法Cat"); } public Cat(String name,double weight) { this(); this.name = name; this.weight = weight; System.out.println("我是子类的带参构造，方法名Cat，参数name、weight"); } }
结果：
我是子类的无参构造，方法Cat
我是子类的带参构造，方法名Cat，参数name、weight
既然super和this都可以调用构造方法，那么二者可以共存吗？
当你在调用构造方法的时候，super和this只能使用一个。
7.Object类
Object类是所有类的父类。
一个类没有使用extends关键字明确标识继承关系，则默认继承Object类（包括数组）
Java中的每个类都可以使用Object中定义的方法。
Object类官网：https://docs.oracle.com/javase/8/docs/api/
Object类中定义的方法：
上面都是Object类内置的方法，所以Java中所有的对象都可以调用这些方法。以equals为例：
下面是其源码，主要是比较两个对象是否是同一个对象。
public boolean equals(Object obj) { return (this == obj); }
示例：
public class Test { public static void main(String[] args) { Animal one = new Animal("mao"); Animal two = new Animal("mao"); //equals：比较两个引用是否指向同一个对象 boolean flag = one.equals(two); System.out.println("one和two的equals比较: "+flag); System.out.println("one和two的==比较："+(one==two)); } } //one和two的equals比较: false //one和two的==比较：false
那如果，我们需要比较两个对象的值该怎么做了？我们可以重写equals方法
public boolean equals(Object obj){ if (obj == null){ return false; } Animal temp = (Animal) obj; //对象类型强制转换 if (this.getName().equals(temp.getName())){ return true; }else { return false; } }
上面这种写法，可以在类型转换的时候会报错，改进方式是直接传入Animal对象：
public boolean equals(Animal obj){ if (obj == null){ return false; } if (this.getName().equals(obj.getName())){ return true; }else { return false; } }
需要说明的是toString这个方法：
public class Test { public static void main(String[] args) { Animal one = new Animal("mao"); System.out.println(one); System.out.println(one.toString()); } } //com.imooc.animal.Animal@1b6d3586 //com.imooc.animal.Animal@1b6d3586
可以看出，输出对象名时，默认会直接调用类中的toString。
继承Object中的toString方法时，输出对象的字符串表示形式：类型信息+@+内存地址。
但是对字符串类型例外：
String str1 = new String("hello"); System.out.println(str1); //hello
很多时候我们会重写对象的toString方法，这样可以改变对象的默认打印。
8.final关键字
如果你希望一个类不被别人继承，那么可以定义final关键字：
public final class Animal { String name; //名字 public Animal(){} }
final class：该类没有子类
final 方法：该方法不允许被子类重写，但是可以被子类继承使用。
final 方法内局部变量：只要在具体被使用之前进行赋值即可，一旦赋值不允许被修改
final 类中成员属性：赋值过程：1.定义直接初始化 2.构造方法 3.构造代码块
可配合static使用，来定义只需要设置一次的内容
