day09

09.01 面向对象（多态的概述及其代码实现）
 A.多态概述（ploymorphic）
　　事物存在的多种形态
 B.多态前提
　　a.要有继承
　　b.要有方法重写
　　c.要有父类引用子类对象
 C.案例演示

package day09;
public class day09_01 {
    public static void main(String[] args) {
        Cat c = new Cat();
        c.eat();
        
        Animal a = new Cat();        //父类引用指向子类对象
        a.eat();
    }
}
class Animal{
    public void eat(){
        System.out.println("Animal eat");
    }
}
class Cat extends Animal{
    public void eat(){
        System.out.println("Cat eat");
    }
}

View Code

09.02 面向对象（多态的成员访问特点）
 A.多态中的成员方法特点
　　a.成员变量
　　　　编译看左，运行看左
　　b.成员方法（指的是非静态的成员方法）
　　　　编译看左，运行看右
　　c.静态方法
　　　　编译看左，运行看左
　　　　(静态和类相关，算不上重写，所以，访问还是看右边)
 B.案例演示

package day09;

public class day09_02 {
    public static void main(String[] args) {
        Father f = new Son();
        System.out.println(f.num);
    }
}
//成员变量，（父类引用指向子类对象）左左
class Father {
    int num = 10;
}
class Son extends Father{
    int num = 20;
}

public class day09_02 {
    public static void main(String[] args) {
        Father f = new Son();
        f.print();
    }
}
//成员方法，（父类引用指向子类对象）左右
class Father {
    public void print(){
        System.out.println("father");
    }
}
class Son extends Father{
    public void print(){
        System.out.println("Son");
    }
}
---------------------------------
public class day09_02 {
    public static void main(String[] args) {
        Father f = new Son();
        f.method();
    }
}
//静态得到，（父类引用指向子类对象）左左
class Father {
    public static void method(){
        System.out.println("father static method");
    }
}
class Son extends Father{
    public static void method(){
        System.out.println("Son  static method");
    }
}

View Code

09.03 面向对象（多态的概述及其代码实现）
　　成员方法
　　　　编译看左，运行看右

09.04 面向对象（多态的概述及其代码实现）
　　静态方法
　　　　编译看左，运行看左
09.05 面向对象（超人的故事）
 A.案例演示

package day09;
public class day09_05 {
    /*基本数据类型自动类型提升和强制类型转换
     * int i = 10;
     * byte b = 20;
     * i=b;                //自动类型提升byte--> int
     * b=byte()i;        //强制类型提升int -->byte
     */
    public static void main(String[] args) {
        SuperMan p =new SuperMan();
        System.out.println(p.name);
        p.Tlak();
        //无法用 p.fly()调用子类的fly()方法，因为编译看左，父类没有fly()，编译失败
        SuperMan sm = (SuperMan)p;
        sm.fly();
    }
}
class Person{
    String name = "John";
    public void Tlak(){
        System.out.println("tlak bussiness");
    }
}
class SuperMan extends Person{
    String name = "SuperMan";
    public void Tlak(){
        System.out.println("tlak Son class");
    }
    public void fly(){
        System.out.println("fly out");
    }
}

View Code

09.06 面向对象（多态的向上转型和向下转型）
　　Person p = new Person()
　　SuperMan sm = (SuperMan)p;
09.07 面向对象（多态的好处和弊端）
 A.多态的好处
　　a.提高了代码的复用性
　　b.提高了代码的拓展性
 B.案例演示
　　多态的好处

package day09;
public class day09_07 {
    public static void main(String[] args) {
        method(new Cat7());
        method(new Dog7());
    }
    /*public static void method(Cat7 c){
        c.eat();
    }*/
    public static void method(Animal7 a){
    //    a.eat();      //调用子类共有的属性
        //如果先调用子类特有的属性呢？
        //关键字 ：instanceof,判断前面的引用是否是后边的数据类型
        if(a instanceof Cat7){
            Cat7 c = (Cat7)a;
            c.eat();
            c.catchMouse();
        }
    }
}
class Animal7{
    public void eat(){
        System.out.println("Animal eat fish");
    }
}
class Cat7 extends Animal7{
    public void eat(){
        System.out.println("Cat eat fish");
    }
    public void catchMouse(){
        System.out.println("catch Mouse");
    }
}
class Dog7 extends Animal7{
    public void eat(){
        System.out.println("Dog eat rou");
    }
    public void LookHome(){
        System.out.println("LookHome");
    }
}

View Code

 C.多态的弊端
　　不能使用子类的特有属性和行为
D.案例演示
　　method(Animal a)
　　method(Cat c)
09.08 面向对象（多态的题目分析）
09.09 面向对象（抽象类的概述机器特点）
 A.抽象类概述
　　当你无法描述一个类时，就将她定义为抽象的。抽象就是看不懂的。抽象就是看不懂的（********）
 B.抽象类特点
　　a.抽象类和抽象方法必须使用abstract关键字来修饰
　　　　abstract class 类名{}
　　　　public abstract void eat();
　　b.抽象类不一定由抽象方法，有抽象方法的类一定是抽象类或者接口
　　c.抽象类不能被实例化，那么抽象类如何实例化呢？
　　　　按照多态的方式，由句体的子类实例化。其实这也是多态的一种，抽象类多态
　　d.抽象类的子类
　　　　要么抽象类
　　　　要么是重写抽象类中所有抽象方法(一般选择这种方式)（**********）
 C.案例演示

package day09;
public class day09_09 {
    /*a.抽象类和抽象方法必须使用abstract关键字来修饰
          abstract class 类名{}
          public abstract void eat();
      b.抽象类不一定由抽象方法，有抽象方法的类一定是抽象类或者接口
      c.抽象类不能被实例化，那么抽象类如何实例化呢？
          按照多态的方式，由句体的子类实例化。其实这也是多态的一种，抽象类多态
      d.抽象类的子类
          要么抽象类
          要么是重写抽象类中所有抽象方法(一般我们这么使用)
     */
    public static void main(String[] args) {
    //    Animal9 a = new Animal9();           //抽象方法不能实例化
        //用父类引用指向子类对象来调用子类方法
        Animal9  a = new Cat9();
        a.eat();
    }
}
abstract class Animal9{             //抽象类
    public abstract void eat();     //抽象方法
}
class Cat9 extends Animal9{
    public void eat(){
        System.out.println("Cat eat fish");
    }
}

View Code

09.10 面向对象（抽象类的成员特点）
 A.抽象类的成员特点
　　a.成员变量：既可以是变量，也可以是常量。abstract不能修饰成员变量
　　b.构造方法：有。用于子类访问父类数据的初始化
　　c.成员方法：抽象，非抽象都可以
 B.案例特点

09.10 面向对象（抽象类的成员特点）
  A.抽象类的成员特点
　　a.成员变量：既可以是变量，也可以是常量。abstract不能修饰成员变量
　　b.构造方法：有。用于子类访问父类数据的初始化
　　c.成员方法：抽象，非抽象都可以
  B.案例特点

09.10 面向对象（抽象类的成员特点）
  A.抽象类的成员特点
      a.成员变量：既可以是变量，也可以是常量。abstract不能修饰成员变量
      b.构造方法：有。用于子类访问父类数据的初始化
      c.成员方法：抽象，非抽象都可以
  B.案例特点
09.11 面向对象（岳不群,东方不败）
09.12 面向对象（猫狗类）
09.13 面向对象（老师类）
09.14 面向对象（员工类）
    假如我们再开发一个系统程序是需要堆程序员进行设计，程序员包括3个属性：姓名/工号/工资
       经理，除了含有程序员的属性外，还有一个奖金属性
      请使用继承的思想设计出程序员类和经理类。要求类中提供必要的方法进行属性访问*/
09.15 面向对象（抽象类中的面试题）
     面试题：
     1.一个抽象类如果没有抽象方法，可不可以定义为抽象类？如果可以，有什么意义？
         可以。这么做的目的只有一个，就是不让其他类创建本类对象，交给子类完成
     2.abstract不能和哪些关键字共存、、
         abstract和static/final,private
         static。被static修饰的可以用类名.调用，但是类名.调用抽象方法是没有意义的
         final。   被abstract修饰的方法强制子类重写，被final修饰的不让子类重写
         private.被abstract修饰的是为了让子类看到并强制重写
09.16 面向对象（接口的概述及其特点）
  A.
  B.接口特点
      a:接口关键字：interface。 使用方式：   interface  接口名  {}
      b:类实现接口：implements 使用方法：  class 类名 implements 接口名 {}
      c:接口不能实例化。所以可以按照多态的方式进行实例化
      d:接口的子类：可以是抽象类（意义不大），可以是具体类，要重写接口中的所有抽象方法(********)
  C.案例演示
09.17 面向对象（接口的成员特点）
  A.接口成员特点
      成员变量：只能是常量，并且是静态的公共的
          默认修饰符是：public static final
          建议：自己手动给出
      构造方法：无
      成员方法：只能是抽象方法
          建议：自己手动给出
 09.18 接口与接口，类 的关系
  A.类与类，类与接口，接口与接口
      a.类与类：       继承关系。只能单继承
      b.类与接口：   实现关系，单实现和多实现
      c.接口与接口:继承关系，单继承和多继承
 09.19 面向对象（抽象类和接口的区别）
  A.成员区别
      抽象类：
          成员变量：可以变量也可以常量
          构造方法：有
          成员方法：可以抽象，可以非抽象
      接口：
          成员变量：只能常量
          成员方法：只能抽象
  C.设计理念：
      抽象类：体现的是：“is a”
      接口 ：   体现的是：“like a”
09.20 面向对象（猫狗类）
 A.案例演示<猫狗类>
     动物类: 姓名 年龄 吃饭 睡觉
     猫和狗
     动物培训接口:跳高

View Code

09.11 面向对象（岳不群,东方不败）

package day09;
public class day09_11 {
    public static void main(String[] args) {
        岳不群 小岳子 = new 岳不群();
        小岳子.自宫();
    }
}
abstract class 葵花宝典{                   //抽象类
    public abstract void 自宫();            //定义抽象方法
}
class 岳不群 extends 葵花宝典{
    public void 自宫(){                    //必须重写父类的抽象方法
        System.out.println("用牙签");
    }
}
class 林平之 extends 葵花宝典{
    public void 自宫(){                    //必须重写父类的抽象方法
        System.out.println("用指甲刀");
    }
}
class 东风不败 extends 葵花宝典{
    public void 自宫(){                    //必须重写父类的抽象方法
        System.out.println("用锤子");
    }
}

View Code

09.12 面向对象（猫狗类）

package day09;
public class day09_12 {
    public static void main(String[] args) {
        Cat12 c = new Cat12("加菲猫",80);
        System.out.println(c.getName() + "..." + c.getAge());
        c.eat();
        c.catchMouse();
        
        Dog12 d = new Dog12("八公",20);
        d.eat();
        d.LookHome();
    }
}
abstract class Animal12{
    private String name;
    private int age;
    //
    public Animal12(){}
    public Animal12(String name,int age){
        this.name = name;
        this.age = age;
    }
    //
    public String getName(){
        return name;
    }
    public void setName(String name){
        this.name =name;
    }
    public int getAge(){
        return age;
    }
    public void setAge(int age){
        this.age = age;
    }
    //
    public abstract void eat();              //抽象方法必须放在抽象类种
} 
class Cat12 extends Animal12{
    public Cat12(){}
    public Cat12(String name,int age){
        super(name,age);
    }
    public void eat(){                      //必须重写父类的抽象方法
        System.out.println("Cat eat");
    }
    public void catchMouse(){
        System.out.println("catch mouse");
    }
}
class Dog12 extends Animal12{
    public Dog12(){}
    public Dog12(String name,int age){
        super(name,age);
    }
    public void eat(){                      //必须重写父类的抽象方法
        System.out.println("dog eat rou");
    }
    public void LookHome(){
        System.out.println("look home");
    }
}

View Code

09.13 面向对象（老师类）

package day09;
public class day09_13 {
    public static void main(String[] args) {
        BaseTeacher bt = new BaseTeacher("fengjia",18);
        bt.teach();
    }
}
abstract class Teacher{
    private String name;
    private int age;
    //
    public Teacher(){}
    public Teacher(String name,int age){
        this.name = name;
        this.age = age;
    }
    //
    public String getName(){
        return name;
    }
    public void setName(String name){
        this.name =name;
    }
    public int getAge(){
        return age;
    }
    public void setAge(int age){
        this.age = age;
    }
    public abstract void teach();
}
class BaseTeacher extends Teacher{
    public BaseTeacher(){}
    public BaseTeacher(String name,int age){
        super(name,age);
    }
    public void teach(){
        System.out.println("我的姓名是："+ this.getName() + "，我的年龄是："+ this.getAge()+",讲的内容是Java基础");
        
    }
}

View Code

09.14 面向对象（员工类）
　　假如我们再开发一个系统程序是需要堆程序员进行设计，程序员包括3个属性：姓名/工号/工资
　　经理，除了含有程序员的属性外，还有一个奖金属性
　　请使用继承的思想设计出程序员类和经理类。要求类中提供必要的方法进行属性访问*/

package day09;
public class day09_14 {
    public static void main(String[] args) {
        Coder c = new Coder("demaxiya",8,8000,5000);
        c.work();
    }
}
/*假如我们再开发一个系统程序是需要堆程序员进行设计，程序员包括3个属性：姓名/工号/工资
 * 经理，除了含有程序员的属性外，还有一个奖金属性
 * 请使用继承的思想设计出程序员类和经理类。要求类中提供必要的方法进行属性访问*/

class Employee{
    private String name;
    private int id;
    private double salary;
    public Employee(){}
    public Employee(String name,int id,double salary){
        this.name = name;
        this.id = id;
        this.salary=salary;
    }
    //
    public String getName(){
        return name;
    }
    public void setName(String name){
        this.name =name;
    }
    public int getId(){
        return id;
    }
    public void setId(int id){
        this.id = id;
    }
    public double getSalary(){
        return salary;
    }
    public void setSalary(double salary){
        this.salary = salary;
    }
}
class Coder extends Employee{
    private int bonus;                //定义本类的成员变量
    public Coder(){}
    public Coder(String name,int id,double salary,int bonus){
        super(name,id,salary);
        this.bonus = bonus;            //this进行赋值
    }
    public void work(){
        System.out.println("我的姓名是："+ this.getName() + "，我的工号是："+this.getId()+",我的工资是："+this.getSalary()+"，我的奖金是："+this.bonus);
    }
}

View Code

09.15 面向对象（抽象类中的面试题）
　　面试题：
　　1.一个抽象类如果没有抽象方法，可不可以定义为抽象类？如果可以，有什么意义？
　　　　可以。这么做的目的只有一个，就是不让其他类创建本类对象，交给子类完成
　　2.abstract不能和哪些关键字共存、、
　　　　abstract和static/final,private
　　　　static。被static修饰的可以用类名.调用，但是类名.调用抽象方法是没有意义的
　　　　final。 被abstract修饰的方法强制子类重写，被final修饰的不让子类重写
　　　　private.被abstract修饰的是为了让子类看到并强制重写

package day09;

public class day09_15 {

    /**
     面试题：
     1.一个抽象类如果没有抽象方法，可不可以定义为抽象类？如果可以，有什么意义？
         可以。这么做的目的只有一个，就是不让其他类创建本类对象，交给子类完成
     2.abstract不能和哪些关键字共存、、
         abstract和static/final,private
         static。被static修饰的可以用类名.调用，但是类名.调用抽象方法是没有意义的
         final。   被abstract修饰的方法强制子类重写，被final修饰的不让子类重写
         private.被abstract修饰的是为了让子类看到并强制重写
     */
    public static void main(String[] args) {

    }
}
/*abstract class Demo{
    //public static abstract void print();//错误，这是不能共存的
    //public final abstract void print();//错误，这是不能共存的
    //private abstract void print();    /错误，这是不能共存的
}*/

View Code

09.16 面向对象（接口的概述及其特点）
  A.
  B.接口特点
　　a:接口关键字：interface。 使用方式： interface 接口名 {}
　　b:类实现接口：implements 使用方法： class 类名 implements 接口名 {}
　　c:接口不能实例化。所以可以按照多态的方式进行实例化
　　d:接口的子类：可以是抽象类（意义不大），可以是具体类，要重写接口中的所有抽象方法(********)
 C.案例演示

09.17 面向对象（接口的成员特点）
  A.接口成员特点
　　成员变量：只能是常量，并且是静态的公共的
　　　　默认修饰符是：public static final
　　　　建议：自己手动给出
　　构造方法：无
　　成员方法：只能是抽象方法
　　　　建议：自己手动给出
09.18 接口与接口，类 的关系
  A.类与类，类与接口，接口与接口
　　a.类与类： 继承关系。只能单继承
　　b.类与接口： 实现关系，单实现和多实现
　　c.接口与接口:继承关系，单继承和多继承

package day09;
public class day09_18 {
    public static void main(String[] args) {

    }
}
interface InterA{
    public abstract void printA();
}
interface InterB{
    public abstract void printB();
}
class Demo18 implements InterA{
    public void printA(){
        System.out.println("printA");
    }
    public void printB(){
        System.out.println("printB");
    }
}

View Code

09.19 面向对象（抽象类和接口的区别）
  A.成员区别
　　抽象类：
　　　　成员变量：可以变量也可以常量
　　构造方法：有
　　成员方法：可以抽象，可以非抽象
　　接口：
　　　　成员变量：只能常量
　　成员方法：只能抽象
  C.设计理念：
　　抽象类：体现的是：“is a”
　　接口 ： 体现的是：“like a”
09.20 面向对象（猫狗类）
  A.案例演示<猫狗类>
　　动物类: 姓名 年龄 吃饭 睡觉
　　猫和狗
　　动物培训接口:跳高

package day09;
public class day09_20 {
    public static void main(String[] args) {
        Cat20 c = new Cat20("加菲猫",20);
        c.eat();
        c.sleep();
        System.out.println("-------------------");
        JumpCat jc = new JumpCat("调高猫",30);
        jc.eat();
        jc.sleep();
        jc.jump();
    }
}
/*A.案例演示<猫狗类>
    动物类: 姓名 年龄 吃饭 睡觉
    猫和狗
    动物培训接口:调高*/
abstract class Animal20{
    private String name;
    private int age;

    public Animal20(){}
    public Animal20(String name,int age){
        this.name = name;
        this.age = age;
    }

    public String getName(){
        return name;
    }
    public void setName(String name){
        this.name =name;
    }
    public int getAge(){
        return age;
    }
    public void setAge(int age){
        this.age = age;
    }
    
    public abstract void eat();              //1.抽象方法必须放在抽象类种
    public abstract void sleep();  
} 

interface Jumping{                        //实现一个接口
    public void jump();
}
//用猫继承动物
class Cat20 extends Animal20{
    public Cat20(){}
    public Cat20(String name,int age){
        super(name,age);
    }
    
    public void eat(){                      //2.必须重写父类的抽象方法
        System.out.println("Cat eat");
    }
    public void sleep(){
        System.out.println("sleep");
    }
}

//跳猫JumpCat先继承Cat20后继续Jumping 
class JumpCat extends Cat20 implements Jumping{
    public JumpCat(){}
    public JumpCat(String name,int age){
        super(name,age);
    }
    
    public void jump(){                    //3.必须重写 接口中的方法
        System.out.println("猫跳高");
    }
}

View Code

 

转载于:https://www.cnblogs.com/chengxiaofeng/p/10394890.html