Java基础之继承

Java中的继承体现的是类和类之间的关系。继承的好处在于，实现了代码的重复利用。

1.B继承了A，则B是A的子类，A是B的父类（超类，基类）。
2.Java中只能是单继承，即一个子类只能有一个父类，不能有多个。但可以多重继承，即可以C继承B，B继承A。

//B继承了A
class B extends A {

}

代码示例：

class Father {
	String name;
	int age;
	//行为
	public void eat () {
		System.out.println("吃大盘鸡拌面");
	}
}

//使用了extends以后  Son 类就继承了Father这个类
//就意味着Son类可以使用Father类下面的某些属性和某些方法
class Son extends Father{
	
}

public class Demo1 {
	public static void main(String[] args) {
		//创建一个Son类对象
        Son son = new Son();
		
        //继承之后，子类可以使用父类一些属性
		son.name = "奇奇";
		son.age = 1;
		System.out.println(son.name); //奇奇
		System.out.println(son.age); //1
		son.eat(); //吃大盘鸡拌面		
	}
}

注意事项：

1.成员变量（属性）
对于父类中公开的（public）和默认的（不加权限修饰符）成员变量，子类可以直接继承使用。
对于父类中私有的（private）的成员变量，子类不可使用。
2.成员方法
对于父类中公开的和默认的成员方法，子类可以直接拿来用。
对于父类中私有的的成员方法，子类不可以使用。
3.构造方法
构造器谈不上继承，每个类中所需要的构造方法都需要重新写。（因为每个类的类名都不同，而构造器的名字是与类名一致的）
先执行父类的构造方法，再执行子类中的构造方法。
父类中如果只有有参构造，子类中的无参构造方法的定义和使用都会报错。解决方法是在父类中写一个对应的无参构造方法。

代码示例：

class Father {
	//只要是公开的或者默认的属性，子类可以使用的
	public String name; //公开的一个属性
	int age; //默认的一个属性
	private int id; //private修饰的私有属性，子类不能使用
	
    //无参构造方法
	public Father () {
		System.out.println("父类的构造方法");
	}
    //有参构造方法
	public Father (String name) {
		this.name = name;
	}
	
    //使用public修饰的eat方法，子类可以直接调用
	public void eat () {
		System.out.println("吃窝窝头");
	}
	//默认的方法，子类可以直接调用
	void work () {
		System.out.println("开拖拉机耕地");
	}
	// 使用private修饰的私有的方法，子类不能直接调用
	private void smoking () {
		System.out.println("抽旱烟");
	}	
}

class Son extends Father {
	
}

public class Demo1 {
	public static void main(String[] args) {
		Son son = new Son();
		//验证name  age在子类中可以使用的
		son.name = "狗蛋";
		son.age = 12;
		//son.id = 12; //报错
		son.eat();//可以使用父类的公开的方法
		son.work();
		//不可以使用父类私有化的方法
		//son.smoking(); //报错	
	}
}

在父类中写一个公开的方法来调用私有的属性和方法，然后在子类中直接继承使用这个公开的方法。

代码示例：

class Father1 {
	private String name;
    
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	
    //私有的方法
	private void smoking () {
		System.out.println("抽旱烟");
	}
    //在公开的方法中调用私有的方法即可
	public void test () {
		smoking();
	}	
}

class Son1 extends Father1 {
	
}

public class Demo2 {
	public static void main(String[] args) {
		Son1 son1 = new Son1();
		//使用setter和getter方法赋值取值
		son1.setName("狗蛋");
		System.out.println(son1.getName());
		son1.test(); //可以调用smoking方法
	}

}

目的：子类可以继承父类非私有化的成员方法，但有时父类的方法不能满足子类的需求，此时可以进行重写。在不改变父类方法的需求的基础之上，可以在子类中重写父类的方法。其特点是，除了方法体不一样，其他一模一样。
注意事项：
1.@Override 是重写的严格限定，示意这个方法是重写的父类的方法，不是子类中独有的方法。
2.子类重写的方法不影响父类的方法调用效果。

重写的要求：
1.必须要有继承关系。
2.父类中私有化的方法不能被重写。
3.在子类中重写的方法除了方法体不一样，其他都必须与父类方法中的一致。
4.必须在子类中去重写父类。

代码示例：

class Father {
	public void eat () {
		System.out.println("吃粗粮");
	}
	public void driver () {
		System.out.println("开拖拉机");
	}
}

class Son extends Father {
	//当父类不能满足子类的需求，可以在子类中重写父类的方法
    @Override
	public void eat() {
		System.out.println("吃白面馒头");
	}
	@Override
	public void driver() {
		System.out.println("开小汽车");
	}	
}

public class Demo1 {
	public static void main(String[] args) {
		Son son = new Son();
		son.eat(); //吃白面馒头
		son.driver(); //开小汽车
		//子类重写父类中的方法，不影响父类方法的使用
		Father father = new Father();
		father.eat(); //吃粗粮
		father.driver(); //开拖拉机
	}
}

在Java中，同一个类中有很多方法，方法的名字是一样的，但是参数不同，这种方式就叫做方法的重载。

注意事项：
1.方法的重载必须写在同一个类中。
2.重载方法的名字一定是一样的，参数一定是不一样的。

代码示例：

public class Person {
	//在一个类中，方法法名字一样，但是参数一定不一样。这叫方法的重载
	public void test () {
		System.out.println("test");
	}
	public void test (String name) {
		System.out.println(name);
	}
	public void test (int i) {
		System.out.println(i);
	}
	//修饰符可以不一样
    void test (double d1) {
		
	}
    //返回值可以不一样
	public String test(String str1, String str2) {
		return str1 + str2;
	}
}