Java学习笔记 （继承、this、super）
继承的概念:
- 一种类与类之间的关系
- 使用已存在的类的定义作为基础建立新类
- 新类的定义可以增加新的数据或新的功能，也可以用父类的功能，但不能选择性的继承父类
- 满足“A is a B”的关系
语法
1、使用extends实现继承 2、单一继承，只能有一个父类
public class Animal {
private String name;
private String month;
}package animal;
public class Cat extends Animal{
private double weight;
//public int temp = 300;
public Cat() {
System.out.println("我是猫猫父类无参构造方法");
}
}继承的特性
- 子类拥有父类非 private 的属性、方法。
- 子类可以拥有自己的属性和方法，即子类可以对父类进行扩展。
- 子类可以用自己的方式实现父类的方法。
- 提高了类之间的耦合性（继承的缺点，耦合度高就会造成代码之间的联系越紧密，代码独立性越差）。
- Java 的继承是单继承，但是可以多重继承，单继承就是一个子类只能继承一个父类，多重继承就是，例如 A 类继承 B 类，B 类继承 C 类，所以按照关系就是 C 类是 B 类的父类，B 类是 A 类的父类，这是 Java 继承区别于 C++ 继承的一个特性。
方法重写与方法重载
重写
重写（Overiding) ： 子类继承父类的方法，并重新实现该方法。重写体现了Java优越性，重写是建立在继承关系上，它使语言结构更加丰富。在Java中的继承中，子类既可以隐藏和访问父类的方法，也可以覆盖继承父类的方法。
重写规则：
1.方法重写时，必须存在继承关系 2.方法重写时，方法名和形式参数必须一致。 3.方法重写时 ，子类的权限修饰符需要大于或等于父类的权限修饰符。 4.方法重写时 ，子类的返回值类型必须小于或等于父类的返回值类型 5.方法重写时 , 子类的异常类型要小于等于父类的异常类型。
class Animals {
public void call() {
System.out.println("heehhehehe");
}
}
public class Cat extends Animals {
@Override
public void call() {
System.out.println("喵喵喵喵喵");
}
}
public class Dog extends Animals {
@Override
public void call() {
System.out.println("汪汪汪汪汪汪");
}
public static void main(String[] args) {
Animals animals = new Animals();
animals.call();
Cat cat = new Cat();
cat.call();
Dog dog = new Dog();
dog.call();
}
}重载
重载(Overloading)：方法名相同，但是参数必须有区别（参数不同可以使类型不同，顺序不同，个数不同）。重载是指我们可以定义一些名称相同的方法，通过定义不同的参数来区分这些方法，然后再调用时，Java虚拟机就会根据不同的参数列表来选择合适的方法执行。也就是说，当一个重载方法被调用时，Java用参数的类型或个数来决定实际调用的重载方法。因此，每个重载方法的参数的类型或个数必须是不同。
重载规则： 1.在使用重载时只能通过不同的参数列表，必须具有不同的参数列表。 2.不能通过访问权限、返回类型、抛出的异常进行重载。 3.方法的异常类型和数目不会对重载造成影响。 4.可以有不同的返回类型，只要参数列表不同就可以了。 5.可以有不同的访问修饰符。 6.可以抛出不同的异常。 7.方法能够在同一个类中或者在一个子类中被重载。
public class Compare {
public void max(int a, int b) {
System.out.println(a>b?a:b);
}
public void max(float a, float b) {
System.out.println(a>b?a:b);
}
public void max() {
/**
* 无参重载
* */
System.out.println("Coding...");
}
public static void main(String[] args) {
// TODO Auto-generated method stub
Compare compare = new Compare();
compare.max(102, 23);
compare.max(2.0f, 3.0f);
compare.max();
}
}总结：
重写是外壳不变，核心变。也就是说方法名不变，参数不变，具体实现可以改变。一般是在父类中声明方法，在子类中重写。 重载是方法名不变，但参数一定要变。而且重载的方法一般都写在一个类中。用一张图来表示区别如下：
super和this关键字
实例化顺序
package animal;
public class Animal {
/*
private:只允许在本类中进行访问
public:允许在任意位置访问
protected:允许在当前类、同包子类、同包非子类、跨包子类访问;跨包非子类不允许
默认:允许在当前类、同包子类/非子类调用; 跨包子类/非子类不允许调用
*/
//父类构造方法不能被继承,但是会影响子类对象实例化过程
private String name;
private String species;
private int month;
public int temp = 15;
private static int st1 = 22;
private static int st2 = 33;
static {
System.out.println("我是动物父类静态代码块");
}
{
System.out.println("我是动物父类构造代码块");
}
public Animal(){
System.out.println("我动物父类无参构造方法");
}
public Animal(String name, int month) {
System.out.println("父类双参构造方法");
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getSpecies() {
return species;
}
public void setSpecies(String species) {
this.species = species;
}
public int getMonth() {
return month;
}
public void setMonth(int month) {
this.month = month;
}
public void eat(){
System.out.println(this.getName() + "在吃东西");
}
}package animal;
public class Cat extends Animal{
private double weight;
//public int temp = 300;
public Cat() {
System.out.println("我是猫猫父类无参构造方法");
}
public Cat(String name, int month) {
/*
1、子类默认调用父类无参构造方法
2、可以通过super()调用父类允许被访问的其他构造方法
3、super()必须放在子类构造方法有效代码第一行
*/
super(name, month);
System.out.println("子类双参构造方法");
}
static {
System.out.println("我是猫猫父类静态代码块");
}
{
System.out.println("我是猫猫父类构造代码块");
}
public double getWeight() {
return weight;
}
public void setWeight(double weight) {
this.weight = weight;
}
public void run(){
System.out.println(this.getName() + "是一支品种为" + this.getSpecies() + "的猫，她在跑");
}
}package 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() + "现在是" + this.getMonth() + "个月大的狗，他在睡觉" );
}
/*
方法重载
1、方法重载要满足在同一个类中
2、方法名相同，参数列表不同
3、方法返回值、访问修饰符任意
4、与方法的参数名无关
private void sleep(String name, int month){
}
方法重写
1、有继承关系的子类中
2、方法名相同，参数列表相同（参数个数、顺序、类型）
3、访问修饰符
4、与方法参数名无关
*/
public void eat(){
System.out.println(this.getName() + "最近没有食欲");
}
public void eat(String name){
System.out.println(name + "最近没有食欲");
}
}
super关键字
- 子类的构造过程中必须调用其父类的构造方法
- 如果子类的构造方法中没有显示调用父类的构造方法，则系统默认调用父类无参的构造方法
- 如果子类构造方法中既没有显示调用父类的构造方法，而父类又没有无参的构造方法，则编译出错
- 使用super调用父类指定构造方法，必须在子类的构造方法的第一行
this关键字
this表示一个对象的引用,它指向正在执行方法的对象. 特别的, 在构造方法中,通过this关键字调用其他构造方法时,必须放在第一行,否则编译器会报错. 且在构造方法中, 只能通过this调用一次其他构造方法.
区别
1、super（参数）：调用基类中的某一个构造函数（应该为构造函数中的第一条语句） this（参数）：调用本类中另一种形成的构造函数（应该为构造函数中的第一条语句） 2、super: 它引用当前对象的直接父类中的成员（用来访问直接父类中被隐藏的父类中成员数据或函数，基类与派生类中有相同成员定义时如：super.变量名 super.成员函数据名（实参） this：它代表当前对象名（在程序中易产生二义性之处，应使用this来指明当前对象；如果函数的形参与类中的成员数据同名，这时需用this来指明成员变量名） 3、调用super()必须写在子类构造方法的第一行，否则编译不通过。每个子类构造方法的第一条语句，都是隐含地调用super()，如果父类没有这种形式的构造函数，那么在编译的时候就会报错。 4、super()和this()类似,区别是，super()从子类中调用父类的构造方法，this()在同一类内调用其它方法。 5、super()和this()均需放在构造方法内第一行。 6、尽管可以用this调用一个构造器，但却不能调用两个。 7、this和super不能同时出现在一个构造函数里面，因为this必然会调用其它的构造函数，其它的构造函数必然也会有super语句的存在，所以在同一个构造函数里面有相同的语句，就失去了语句的意义，编译器也不会通过。 8、this()和super()都指的是对象，所以，均不可以在static环境中使用。包括：static变量,static方法，static语句块。 9、从本质上讲，this是一个指向本对象的指针, 然而super是一个Java关键字。
腾讯云开发者
