Java 面向对象之继承和重写OverWrite,重写和重载的区别，抽象类

01继承的概述
　　A:继承的概念
　　　　a:继承描述的是事物之间的所属关系，通过继承可以使多种事物之间形成一种关系体系
　　　　b:在Java中，类的继承是指在一个现有类的基础上去构建一个新的类，构建出来的新类被称作子类，现有类被称作父类
    B:继承关系的子类特点
       a:子类会自动拥有父类所有非private修饰的属性和方法

02继承的定义格式和使用

03继承的好处
    A:继承的好处：
        1、继承的出现提高了代码的复用性，提高软件开发效率。
        2、继承的出现让类与类之间产生了关系，提供了多态的前提。

04继承的注意事项
　　A:继承的注意事项
　　　　a:在Java中，类只支持单继承，不允许多继承，也就是说一个类只能有一个直接父类，例如下面这种情况是不合法的。
　　　　class A{}
　　　　class B{}
　　　　class C extends A,B{}  // C类不可以同时继承A类和B类
　　 　　假如支持多继承例如:
             class A{
             	int a=3;
                public void method(){

                }
             }
		     class B{
		     	int a=5;
		     	public void method(){

		     	}
		     }
		     class C extends A,B{

		     }
		     class Demo{
		     	public static void main(String[] args){
		     		C c=new C();
		     		System.out.println(c.a);//到底是调用A的还是B的成员变量??无法确定
		     		c.method();//到底是调用A的还是B的成员方法??无法确定
		     	}
		     }
　　b:多个类可以继承一个父类，例如下面这种情况是允许的(就像你爹可以多个儿子,但是这些儿子都只有一个爹)
		     class A{}
		     class B extends A{}
		     class C extends A{}   // 类B和类C都可以继承类A
　　c:在Java中，多层继承是可以的，
	        即一个类的父类可以再去继承另外的父类，
	        例如C类继承自B类，而B类又可以去继承A类，这时，C类也可称作A类的子类。下面这种情况是允许的。
		     class A{}
		     class B extends A{}   // 类B继承类A，类B是类A的子类
		     class C extends B{}   // 类C继承类B，类C是类B的子类，同时也是类A的子类
　　d:在Java中，子类和父类是一种相对概念，
            也就是说一个类是某个类父类的同时，也可以是另一个类的子类。
            例如上面的这种情况中，B类是A类的子类，同时又是C类的父类。

05继承的体系
　　A:继承的体系:

						                  动物(吃)
						                    |
						           -------------------------
						           |                        |
						        猫科动物(吃,胎生)      爬行动物(吃,卵生)
						           |                            |
				 -------------------------------        -----------------
			     |          			       |        |                |
				猫(吃,抓老鼠,胎生)   虎(吃,领地,胎生)  蛇(吃,冬眠,卵生)  鳄鱼(吃,潜水,卵生)

	    a:动物体系是对每个具体事物共性的抽取,子类的共性抽取形成父类
	    b:父类:具有所有子类的共性内容
	       子类:不但有共性还有自身特有的内容
	    c:整个继承体系,越向上越抽象,越向下越具体

06继承后子类父类成员变量的特点
　　A:继承后子类父类成员变量的特点
　　　　a:子类的对象调用成员变量的时候,子类自己有,使用子类,子类自己没有调用的父类
　　　　b:当子父类中出现了同名成员变量
　　　　//直接访问,遵循就近查找原则
　　　　子父类中出现了同名的成员变量时
　　　　//在子类中需要访问父类中非私有成员变量时，需要使用super关键字
　　
07继承后子类父类成员方法的特性_子类重写父类方法
　　A:继承后子类父类成员方法的特性
　　　　a:子类的对象调用方法的时候,子类自己有,使用子类,子类自己没有调用的父类
　　　　b:为什么要有重写?
　　　　c:子类中出现与父类一模一样的方法时，会出现覆盖操作，也称为override重写、复写或者覆盖
08方法覆盖的需求
09方法覆盖的实现
10方法覆盖的注意事项
　　A:方法覆盖的注意事项
　　　　a:权限:子类方法覆盖父类方法，必须要保证权限大于等于父类权限。
　　　　　　四大权限:public>默认=protected>private
　　　　b:方法定义:子类方法和要重写的父类的方法:方法的方法名和参数列表都要一样。
	   关于方法的返回值:
	     如果是基本数据类型,子类的方法和重写的父类的方法返回值类型必须相同
	     如果是引用数据类型,子类的方法和重写的父类的方法返回值类型可以相同或者子类方法的返回值类型是父类方法返回值类型的子类
	     class Fu{
			int show(){}
			public Fu method(){}
			public Fu method2(){}
　　　　　　　　 }
	    class Zi() extends Fu{
			public int show(){//返回值为基本类型的重写}
			public Fu method(){//子类的方法和重写的父类的方法返回值类型可以相同}
		    public Zi method2(){//子类方法的返回值类型是父类方法返回值类型的子类}
	    }
　　　　c:重载与重写对比:
        重载:
	权限修饰符(public private 默认):无关
　　　　　　方法名:重载的两个方法的方法名必须相同
　　　　　　形参列表:
　　　　　　形参类型的顺序不同
　　　　　　形参的个数不同
　　　　　　形参的类型不同
　　　　　　三者至少满足一个
　　　　　　返回值类型:重载与返回值类型无关
　　　　重写:
　　　　　　权限修饰符(public private 默认):
　　　　　　子类方法的权限>=父类的方法的权限
　　　　　　方法名:
　　　　　　子类方法和父类方法必须相同
　　　　　　形参列表:
　　　　　　子类方法和父类方法的形参列表必须相同
　　　　　　 返回值类型:
　　　　　　　　基本类数据类型:必须相同
　　　　　　　　引用数据类型:子类方法的返回值类型和父类方法的返回值类型相同
		       或者
		       子类方法的返回值类型是父类方法的返回值类型的 子类

11抽象类的产生
      A:抽象类的产生
        a:分析事物时，发现了共性内容，就出现向上抽取。会有这样一种特殊情况，就是方法功能声明相同，但方法功能主体不同。那么这时也可以抽取，但只抽取方法声明，不抽取方法主体。那么此方法就是一个抽象方法。
12抽象类的定义格式
	 A:抽象方法定义的格式：
	   a:public abstract 返回值类型 方法名(参数);
	     抽象类定义的格式：
		 abstract class 类名 {

		  }
	    b:抽象类示例代码：
		   /*
			 *  定义类开发工程师类
			 *    EE开发工程师 :  工作
			 *    Android开发工程师 : 工作
			 *
			 *    根据共性进行抽取,然后形成一个父类Develop
			 *    定义方法,工作: 怎么工作,具体干什么呀
			 *
			 *    抽象类,不能实例化对象, 不能new的
			 *    不能创建对象的原因:  如果真的让你new了, 对象.调用抽象方法,抽象方法没有主体,根本就不能运行
			 *    抽象类使用: 定义类继承抽象类,将抽象方法进行重写,创建子类的对象
			 */
			public abstract class Develop {
			   //定义方法工作方法,但是怎么工作,说不清楚了,讲不明白
				//就不说, 方法没有主体的方法,必须使用关键字abstract修饰
				//抽象的方法,必须存在于抽象的类中,类也必须用abstract修饰
				public abstract void work();
			}

13抽象类的使用方式
    A:抽象类的使用方式
	 /*
	 *  定义类,JavaEE的开发人员
	 *  继承抽象类Develop,重写抽象的方法
	 */
	public class JavaEE extends Develop{
		//重写父类的抽象方法
		//去掉abstract修饰符,加上方法主体
		public void work(){
			System.out.println("JavaEE工程师在开发B/S 软件");

		}
	}
	/*
	 *  定义Android类,继承开发人员类
	 *  重写抽象方法
	 */
	public class Android extends Develop{
	     public void work(){
	    	 System.out.println("Android工程师开发手机软件");
	     }
	}

	/*
	 *  测试抽象类
	 *    创建他的子类的对象,使用子类的对象调用方法
	 */
	public class Test {
		public static void main(String[] args) {
			 JavaEE ee = new JavaEE();
			 ee.work();//"JavaEE工程师在开发B/S 软件"

			 Android and = new Android();
			 and.work();//"Android工程师开发手机软件"
		}
	}

14抽象类特点
　　A:抽象类的特点
　　　　a:抽象类和抽象方法都需要被abstract修饰。抽象方法一定要定义在抽象类中。
　　　　b:抽象类不可以直接创建对象，原因：调用抽象方法没有意义。
　　　　c:只有覆盖了抽象类中所有的抽象方法后，其子类才可以创建对象。否则该子类还是一个抽象类。
　　　　之所以继承抽象类，更多的是在思想，是面对共性类型操作会更简单。
      abstract class A{
      	public abstract void func();
      	public abstract void func2();
      }
      class A2 extends A{//A2把A中的两个抽象方法都重写掉了
      	                 //A2类不再是抽象类
      	 public void func(){}
      	 public void func2(){}
      }

      abstract class A3 extends A{//含有抽象方法的类一定是抽象类
      	 public void func(){

      	 }
      	 //public abstract void func2();//func2相当于被继承下来
      }

15抽象类的设计思想
    A:抽象类的设计思想
      a:抽象类的作用:继承的体系抽象类,强制子类重写抽象的方法
        抽象员工:
          规定一个方法,work工作
          EE员工,Android员工 

           Develop类 抽象类
           abstract work();
               |
        -------------
       |             |
      EE            Android  //是我开发的一员必须工作
      work(){}       work(){}

16抽象类的细节
   A:抽象类的细节
     a:抽象类一定是个父类？
        是的，因为不断抽取而来的。
     b:抽象类中是否可以不定义抽象方法?
       是可以的，那这个抽象类的存在到底有什么意义呢？不让该类创建对象,方法可以直接让子类去使用
       (适配器设计模式)
        /*
		 *   抽象类,可以没有抽象方法,可以定义带有方法体的方法
		 *   让子类继承后,可以直接使用
		 */
		public  abstract class Animal {
		     public void sleep(){
		    	 System.out.println("动物睡觉");
		     }

		}
		public class Cat extends Animal{

        }     

        public class Test {
			public static void main(String[] args) {
				//Cat c = new Cat();
				new Cat().sleep();//不让该类创建对象,方法可以直接让子类去使用
			}
        }
     c:抽象关键字abstract不可以和哪些关键字共存？
	  1:private：私有的方法子类是无法继承到的，也不存在覆盖，
                 而abstract和private一起使用修饰方法，abstract既要子类去实现这个方法,
                 而private修饰子类根本无法得到父类这个方法。互相矛盾。 

        /*
		 *   抽象类,可以没有抽象方法,可以定义带有方法体的方法
		 *   让子类继承后,可以直接使用
		 */
		public  abstract class Animal {

		     // private abstract void show();
		     //抽象方法,需要子类重写, 如果父类方法是私有的,子类继承不了,也就没有了重写
		}