Java基础笔记-抽象,继承,多态

抽象类: abstract修饰

抽象方法必须定义在抽象类中,抽象类不能创建对象.

在抽象方法中可以不定义抽象方法,作用是:让该类不能建立对象.

特点是:

1.定义在抽象类中

2.方法和类都用abstract修饰,在抽象类中的方法不写abstract也默认的是抽象方法.

3.不能用new来创建对象,调用抽象方法没意义.

4.抽象类中的方法被使用,必须由子类覆写其所有的抽象方法后,才能建立子类对象进行调用.

　如果子类只覆盖了部分的抽象方法.那么该子类还是一个抽象类.

5.抽象类不可以被实例化.

继承:(extends)

关键字:extends,一般用于类与类之间的所属关系.java中是单继承,多实现(implements).

让类与类之间产生关系,从而才有了多态的特性.

当两个类有了继承关系以后.就可以在子类中调用父类的方法和属性,一般使用 super 关键字.

其用法和this关键字类似.super调用的是父类的,而this是调用的方法本身的.

 abstract class Employee
 {
     private String name;
     private String id;
     private double pay;
     //构造函数
     Employee(String name,String id,double pay)
     {
         this.name = name;
         this.id = id;
         this.pay = pay;
     }
     public abstract void work(); //抽象类.

 }

 class NormalWorker extends Employee
 {
     NormalWorker(String name,String id,double pay)
     {
         super(name,id,pay);
     }

     public void work()
     {
         System.out.println("NormalWorker Work");
     }

 }

 class Manager extends Employee
 {
     private double bonus;

     Manager(String name,String id,double pay,double bonus)
     {
         super(name,id,pay);
         this.bonus = bonus;
     }
     public void work()
     {
         System.out.println("Manager Work");
     }

 }
 class AbstractTest
 {
     public static void main(String args[])
     {
         Manager M = new Manager("lisi","0910",10000,5000);
         M.work();

     }
 }

多态:
向上转型:将子类的对象转给父类的引用.

向下转向;将父类转换成子类类型.

一般使用的是向上转型,向下转型会出现不安全的问题,例如,猫是动物,但是我们不能说动物就是猫.

 /*
 多态:
 人:男人,女人
 动物:猫,狗
 猫 m =new 猫();
 动物 m = new 猫();
 特点:提高代码的拓展.
 */
 abstract class Animal
 {
     abstract void eat();
 }

 class Cat extends Animal
 {
     public void eat()
     {
         System.out.println("吃鱼");
     }
     public void catchMouse()
     {
         System.out.println("抓老鼠");
     }
 }

 class Dog extends Animal
 {
     public void eat()
     {
         System.out.println("啃骨头");
     }
     public void kanJia()
     {
         System.out.println("看家");
     }
 }

 class Pig extends Animal
 {
     public void eat()
     {
         System.out.println("饲料");
     }
     public void swim()
     {
         System.out.println("游泳");
     }
 }

 class DuoTaiDemo
 {
     public static void  main(String args[])
     {
         /*
         Cat c = new Cat();
         c.eat();
         Dog d = new Dog();
         d.eat();
         Pig p = new Pig();
         p.eat();
         */
         /*
         function(new Cat());
         function(new Dog());
         function(new Pig());
         */
         //Animal c = new Cat(); //向上转型
         function(new Cat());
         function(new Dog());
         function(new Pig());
     }
     /*
     public static void function(Cat c)
     {
         c.eat();
     }
     public static void function(Dog d)
     {
         d.eat();
     }
     public static void function(Pig p)
     {
         p.eat();
     }
     */
     public static void function(Animal a)
     {
         a.eat();
     }
 }

 abstract class Animal
 {
     abstract void eat();
 }

 class Cat extends Animal
 {
     public void eat()
     {
         System.out.println("吃鱼");
     }
     public void catchMouse()
     {
         System.out.println("抓老鼠");
     }
 }

 class Dog extends Animal
 {
     public void eat()
     {
         System.out.println("啃骨头");
     }
     public void kanJia()
     {
         System.out.println("看家");
     }
 }

 class Pig extends Animal
 {
     public void eat()
     {
         System.out.println("饲料");
     }
     public void swim()
     {
         System.out.println("游泳");
     }
 }

 class DuoTaiDemo2
 {
     public static void  main(String args[])
     {
         /*
         Animal a = new Cat(); //向上转型
         a.eat();
         Cat c = (Cat)a; //向下转型,将父类的引用转成子类类型.
         c.catchMouse();
         */
         function(new Cat());
         function(new Dog());
         function(new Pig());
     }

     public static void function(Animal a)
     {
         a.eat();
         if(a instanceof Cat)
         {
             Cat c = (Cat)a;
             c.catchMouse();
         }
         else if(a instanceof Dog)
         {
             Dog d = (Dog)a;
             d.kanJia();
         }
         else if(a instanceof Pig)
         {
             Pig p = (Pig)a;
             p.swim();
         }

     }
 }

 /*
 练习:
 基础班学生:学习,睡觉.
 高级班学生:学习,睡觉.
 */
 abstract class Student
 {
     public abstract void study();
     public void sleep()
     {
         System.out.println("躺着睡.");
     }

 }

 class DoStudent
 {
     public void doSomething(Student stu)
     {
         stu.study();
         stu.sleep();
     }
 }

 class BaseStudent extends Student
 {
     public void study()
     {
         System.out.println("base study");
     }
     public void sleep()
     {
         System.out.println("站着睡");
     }
 }

 class AdvStudent extends Student
 {
     public void study()
     {
         System.out.println("adv study");
     }
 }

 class DuoTaiTest
 {
     public static void main(String args[])
     {
         /*
         BaseStudent bs = new BaseStudent();
         bs.study();
         bs.sleep();
         AdvStudent as = new AdvStudent();
         as.study();
         as.sleep();
         */
         DoStudent ds = new DoStudent();
         ds.doSomething(new BaseStudent());
         ds.doSomething(new AdvStudent());
     }
 }

多态中成员的特点:
1.成员函数的特点; 在编译时,参阅引用型变量所属的类中是否有调用方法,有的话编译会通过,没有的话会编译失败

　　　　　　　　　在运行时,参阅对象所属的类中属否有调用方法.

面试中可能遇见的问题.问调用显示结果.

　　　成员函数(非静态的)在多态调用时,编译看左边,运行看右边.

　　　静态函数,无论编译还是运行,都看左边

看了一下之前写的那篇笔记,感觉都没什么能写的了,不知道写些什么,越往后学感觉都是得理解的,越学越难的说,最近又没什么状态,只好慢慢来,慢慢学习了.