java继承重写，重载与抽象类的写法注意事项

不一全部概括，只说重点易错注意部分。

继承，重载，重写，调用父类

（1）重载与重写

**重写方法的规则**：
	1、参数列表必须完全与被重写的方法相同，否则不能称其为重写而是重载。
	2、返回的类型必须一直与被重写的方法的返回类型相同。
	3、访问修饰符的限制一定要大于被重写方法的访问修饰符	
	（public>protected>default>private）
	4、重写方法一定不能抛出新的检查异常或者比被重写方法申明更加宽泛的检		
	查型异常。例如：
	父类的一个方法申明了一个检查异常IOException，在重写这个方法是就不能抛出Exception,只能抛出IOException的子类异常，可以抛出非检查异常。

**方法的重载的规则：**
	方法名称必须相同。
	参数列表必须不同（个数不同、或类型不同、参数排列顺序不同等）。
	方法的返回类型可以相同也可以不相同。
	仅仅返回类型不同不足以成为方法的重载。

方法重载的实现：
方法名称相同时，编译器会根据调用方法的参数个数、参数类型等去逐个匹配，以选择对应的方法，如果匹配失败，则编译器报错，这叫做重载分辨

package jicheng;

public class Jicheng_1Dome {
	public static void main(String[] args) {
		//创建对象进行调用
		Jicheng_1Dome src = new Jicheng_1Dome();
		src.set1();
		src.set2("李");
		System.out.println("=======================================");
		son src1 = new son();
		src1.sayHello();	
		
		
		
	}
	/*
	   * 方法重载，参数列表中的参数个数不同，参数的类型不同，参数的顺序不同 
	   * 视为重载，重载对返回类型没有要求，可以相同也可以不同，所以不能通过返回值类型判断是否为重载
	   * 重写是方法的的方法名相同，参数列表中的参数相同相同， 壳子不变核心变了。
	 */
	public void set1() {
		System.out.println("我是未被方法重写之前");
	}	
	//方法重载
	public void set2(String name) {
		System.out.println("你去了哪里？ "+name);
	}
}

//重写
class father{
	public Object fang;

	public void sayHello() {
		System.out.println("具体的任务");
		System.out.println("任务一");
		System.out.println("任务二");
	}
}
/*方法重写返回值类型必须一样
 * 注意子类函数的访问修饰权限不能少于父类的
 * （public>protected>default>private)
 * 不能重写父类的私有方法，private还有final
 *当然只有子类继承了父类，才能将方法进行重写，
 *构造方法不能被继承，是成员方法的一种特殊存在，所以构造方法不能被重载
 * */
class son extends father{
	@Override
	public void sayHello() {
		//用super将父类的方法进行输出
		super.sayHello();
		System.out.println("我的任务是不同的! ");
	}
}

应该注意：
	重载构造方法是可以的。
	但是重写则不可以，因为被重写的前提是被继承，而构造方法根本就不能被继承，所以谈不上被重写。

（2）调用父类方法

继承中如果不调用父类，则默认调用无参父类，使用super调用必须放在方法中的第一行，因为构造器之前么有对象

package jicheng;

public class Jicheng_1Dome {
	public static void main(String[] args) {
		Son src = new Son();		
	}
	/* 在有子父类的继承关系的类中，创建子类的对象，调用子类的构造方法，
	 * 如果子类的构造方法第一行没有调用父类构造方法，则默认调用父类的无参构造方法
	 * 注释不算
	 * 因为用this或者super调用自己类中构造方法与调用父类中的构造方法都得在方法中的
	 * 第一行中写入，所以this与super不能同时使用
	 * 另外this与super在创建对象的时候之前使用，构造器之前是没有对象的，所以必须放在代码的第一行中
	 * 如果调用父类，肯定首先执行父类的调用
	 * 
	 * 
	 */
}

class Die{
	public Die() {
		System.out.println("我是父类无参构造!");
	}
	public Die(String name) {
		System.out.println("我是父类有参构造! "+name);
	}
}

class Son extends Die{
	public Son() {
		
		super("zouzhuo");	//调用的父类的有参构造
		
		System.out.println("我是子类无参构造!");
	}
	public Son(String name) {
		System.out.println("我是子类有参构造! "+name);
	}	
}

（3）继承的优缺点

优点：
 	提高了代码的复用性
	便于代码的维护
	继承是多态的前提之一
缺点：
	类的耦合性增加了

提一句开发的原则：高内聚低耦合

（4）抽象类

使用关键字“abstract”来修饰 方法和类
抽象方法：
不同类的方法是相似的，但是具体内容确实不一样的，只能抽取他的声明，没有具体的方法，没有具体方法的方法是抽象方法
有抽象方法的类必须是抽象类
注意：
一个类继承了抽象类需要在子类中重写他所有的方法，否则这个子类就得是抽象类，非抽象类方法可以不重写。
或者将继承的子类在前面加上abstract变成抽象类
方式一：
将子类中继承父类的方法重写

package fangfa.com;

public class ChouXiangLei {

}
abstract class Animal{
	public abstract void eat();
}
class Cat extends Animal{

	@Override
	//这里将父类中的方法重写了
	public void eat() {
		System.out.println("猫吃鱼!");		
	}
	//非抽象方法的子类可以不用重写
	public void run() {
				
	}
}
class Dog extends Animal{
	
}

方式二：
将子类也用abstract变成抽象类，也可以不用重写

package fangfa.com;

public class ChouXiangLei {

}
abstract class Animal{
	
	public abstract void eat();
}
abstract class Cat extends Animal{
	//这里将父类中的方法重写了
//	public void eat() {
//		System.out.println("猫吃鱼!");		
//	}
	//非抽象方法的子类可以不用重写
}
abstract class Dog extends Animal{
	
}

抽象类注意：
	（1）抽象方法只能存在在抽象类中
	（2）抽象类和抽象方法必须被abstract关键字修饰
	（3）抽象类不能创建对象，不能进行实例化
	（4）抽象类中可以有非抽象方法
	（5）抽象类和类的关系也是继承
	（6）一个类继承了抽象方法要么自己也变成抽象类，要么就要重写父类中的所有的抽象方法**

package fangfa.com;

public class ChouXiangLei {
	public static void main(String[] args) {
		
	}

}
abstract class Animal{
	
	public abstract void eat();
	public void run() {
		
	}
}
//方式一
abstract class Cat extends Animal{
	
	
}
//方式二
class Dog extends Animal{
	public void eat() {
		
	}
	
}

抽象类的成员方法：
不能创建对象，需要对有抽象类的成员变量进行初始化
		成员变量
			可以有成员变量，成员常量
		成员方法
				可以有抽象方法，和非抽象方法
		构造方法
				可以有构造方法
		final：可以修饰类，成员变量，成员方法
		修饰的类不能被继承，修饰的成员方法不能修改，相当于一个常量，修成的成员方法不能被修改

package fangfa.com;

public class ChouXiangLei {
	public static void main(String[] args) {
		Cat src = new Cat();
		src.name();
	}

}
abstract class Animal{
	public String name = "哮天犬";
	final int age = 10;
	public Animal() {
		System.out.println("我是抽象类的构造方法!");
		
	}
}
//方式一
class Cat extends Animal{
	public void name() {
		System.out.println("原来你是"+name);
		System.out.println(age);
	}
	
}
//方式二
class Dog extends Animal{
	public void eat() {
		
	}
	
}

抽象类的细节：
（1）抽象类（abstract）不能与这些关键字在一起
不能被重写，final以及父类的private
（2）抽象类虽然不能创建对象与实例化，但存在构造方法，
也有成员变量
（3）既可以有抽象方法也可以有非抽象方法
（4）不重写抽象类的方法无法使用，相当于将父类的构造方法进行私有化