javase基础三大特征之一“多态”

Posted 水公子

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了javase基础三大特征之一“多态”相关的知识,希望对你有一定的参考价值。

1. 包

1.1 包的概述

包的概述和使用】:
包其实就是文件夹,它的作用就是进行分类管理的
格式:package 包名;(多级包用.分开)
范例:package com.demo;
方法:
1.带包的Java类编译和执行手动建包:按照以前的格式编java文件

javac HelloWorld.java

2.手动创建包
在E盘建立文件夹com,然后在com下建立文件夹demo
把class文件放到包的最里面,把HelloWorld.class文件放到com 下的demo这个文件夹下,带包执行

java com.demo.HelloWorld

1.2 导包

对于不在同一个目录下的java类,如果想要实现类与类之间的测试与调用,那么就需要进行导包

  • 格式:import 包名;
  • 范例:import.com.test;

2.修饰符

2.1 权限修饰符

  • private同一个包可在本类中都可以被访问到,其他的类中不可被访问
  • protected同一个包下可进行访问,不在同一个包下子类也进行访问,但无关类不可进行访问无关类:未继承父类的类
  • public 都可以进行访问
  • 默认 不同包的子类,和无关类不可进行访问

2.2 状态修饰符

final

  • final 关键字是最终的意思,可以修饰成员方法,成员变量,类

举例:
1.定义一个父类:


public class Fu 
public  void show()
    System.out.println("父中方法被调用");
      

定义子类:

public class Zi extends Fu 
    @Override//用来检测重写方法时方法名单词是否拼写错误
  public void show()
      System.out.println("子中方法被调用");
  

定义测试类:


public class jicheng 
    public static void main(String[] args) 
        Zi z=new Zi();
        z.show();
    

那么这里输出的结果就是

子类方法被调用

但是,如果在父类前加入final来修饰,那么子类中将会报错,因为最终方法不可被重写如下面所示,在方法名前加final那么就代表是最终态,不会在被重写

public class Fu 
public final void  show()
    System.out.println("父中方法被调用");
      

同样的对于成员变量如果在前面加入final这个修饰符,就代表最终态,就是一个常量了,不可在局部变量中在进行赋值

public class demo
public final int age=10;
public void zi()
     age=20;//这里赋值也不会再起作用,还会报错
     

还有final修饰类,就代表是最终类,就不能被使用:


public final class Fu 
public  void  show()
    System.out.println("父中方法被调用");
      

上面有final修饰类,那么子类就不能继承
总结:
final修饰的特点

  • 修饰方法:修饰方法:表明该方法是最终方法,不能被重写
  • 修饰变量:表明该变量是常量,不能再次被赋值
  • 修饰类:表明该类是最终类,不能被继承

final 修饰局部变量

  • 修饰基本类型变量

    被它修饰后,局部变量不可再用
  • 修饰引用类型
    对于修饰类型,修饰的是地址,而里面的内容可以改变
public class Student
public int age=10;

那么它输出的就会是100,而不是10
总结:

  • 变量是基本类型: final修饰指的是基本类型的数据值不能发生改变
  • 变量是引用类型: final修饰指的是引用类型的地址值不能发生改变,但是地址里面的内容是可以发生改变的

static关键字

static 是静态的意思,可以修饰成员方法,成员变量
对于一个事物,别的事物都需要它来共享,这样建议使用static来进行修饰

例如,很多个学生来自同一个大学,但年龄,性别不同,这里,赋值时,因为多个同学来自同一个大学,那么大学就是一个静态的,共享的,赋值时如果给每个学生大学都赋值同一个大学,那么会显得臃肿,用static修饰大学就是不错的选择

主函数部分:

public class main 
    public static void main(String[] args) 
        stu.university="清华大学";//直接给大学赋值,建议使用这种方式来进行给静态赋值
        stu s1=new stu();
        s1.name="张三";
        s1.age=18;
        s1.show();
        stu s2=new stu();
        s2.name="李四";
        s2.age=19;
        s2.show();
    

学生类部分


public class stu
    public String name;
    public int age;
    public static String university;//加上静态修饰符,可以共享
    public void show()
        System.out.println(name+", "+age+", "+university);
    

那么输出结果就是:

张三, 18, 清华大学
李四, 19, 清华大学

访问特点:

3. 多态

3.1 多态概述

**概述:**同一对象,在不同时刻表现出来的不同形态

  • 有继承关系:

public class Cat extends Animal//继承关系
    @Override
    public void eat()//方法重写
        System.out.println("猫爱吃鱼");
    

  • 方法重写:

public class Animal 

    public void eat()
        System.out.println("动物吃肉");
    


  • 父类引用指向子类对象:
public class AnimalDemo 
    public static void main(String[] args) 
      Animal animal=new Cat();//多态,父类引用指向子类对象,这里也就是下面说的向上转型
    

3.2 多态中成员访问特点

成员变量:编译看左边,执行看左边
成员方法:编译看左边,执行看右边

//子类
public class Cat extends Animal//继承关系
  public int age=40;
    @Override
    public void eat()//方法重写
        System.out.println("猫爱吃鱼");
    
    public void playGame()
    System.out.println("猫爱玩");//非重写
    

//父类
public class Animal 
  public int age=30;
    public void eat()
        System.out.println("动物吃肉");
    

//测试类
public class AnimalDemo 
    public static void main(String[] args) 
      Animal animal=new Cat();//多态
      System.out.println(animal.age);
      //运行结果是左边Animal,则age=30,
      //如果Animal没有age,则会报错
      //----------------------------------
      animal.eat();//方法重写执行看右面
      //输出的是Cat里面的方法
      //----------------------------------
       animal.playGame();//这时就会报错
       //执行左面Animal里面没有这个方法
    

为什么成员变量和成员方法的访问不一样呢?
因为成员方法有重写,而成员变量没有

3.3 多态的好处与弊端

测试类

狗类:

猫类:

操作类:

测试结果:

3.4 多态中的转型

  • 向上转型 从子到父,父类引用指向子类对象
  • 向下转型 从父到子,父类引用转为子类对象
    向上转型,上面的有实例,这里不在叙述,
    关于向下转型,也就是在子类中,如果不用父类的方法时,想要用自己的方法时,还不能出现报错,这里就要用向下转型,从而实现
    例如:
    在猫类中有方法eat,而猫类继承父类,父类也有eat方法,这就实现了猫类方法重写,而在猫类中还有方法Game(),而父类没有此方法,那么使用时就会报错,如果不想报错,就要实施类似强转
//子类

public class Cat extends Animal//继承关系
    @Override
    public void eat()//方法重写
        System.out.println("猫爱吃鱼");
    
    public void playGame()//这里方法没被重写,按照编译看左面,看父类中没有就会报错,
    //下面向下转型就可以实现这个问题
    System.out.println("猫爱玩");//非重写
    

//父类
public class Animal 
    public void eat()
        System.out.println("动物吃肉");
    

//测试类
public class AnimalDemo 
    public static void main(String[] args) 
      Animal animal=new Cat();//多态,向上转型,父类引用指向子类对象
     animal.eat();//这里因为有重写方法,所以执行看右面,看cat中的eat,所以会输出猫爱吃鱼
     /*这里我如果还想调用cat中的playGame()方法,显然会报错,那么、怎末不让它报错呢,就要用到向下转型
     */
   Cat c= (Cat)animal;//后面的(Cat)animal是父类引用作为子类对象,转为Cat,
   //那么就可以实现调用子类独有的方法了
   c.playGame();
    
    

4.抽象类

4.1 抽象类概述

概述
在Java中,一个没有方法体的方法应该定义为抽象方法,而类中如果有抽象方法,该类必须定义为抽象类
abstract表示抽象

public abstract class Animal //抽象类
   public abstract  void eat();//定义抽象方法

4.2 抽象类特点

实例化

//猫类
public class Cat extends Animal//继承关系
    public void eat() //重写父类方法,有抽象类的方法
        System.out.println("猫吃鱼");
    

//Animal类
public abstract class Animal //抽象类
   public abstract  void eat();//定义抽象方法
   public void sleep()//抽象类中一定有抽象的方法,但也可有不抽象的方法
       System.out.println("睡觉");
   

//狗类
public abstract class dog extends Animal 
    //这里如果不想重写所有方法,就需要在加abstract

测试类
public class AnimalDemo 
    public static void main(String[] args) 
        Animal c = new Cat(); //采用多态方式
        c.eat();//调用eat方法,遵循编译看左面,执行看右面
        c.sleep();//尽管猫类中没有,但是会继承父类中的
    


运行结果

猫吃鱼
睡觉

4.3 抽象类的成员特点

  • 可以提供构造方法,但是不能实例化
  • 构造方法作用是子类访问父类数据的初始化
  • 成员变量可以是变量,也可以是常量
  • 成员方法 可以有抽象方法:限定子类完成某些动作;也有非抽象方法:提高代码复用性
public abstract class xxx()
    public xxx()//无参构造方法
    public xxx(String name)//有参构造方法
    this.name=name;
    

public abstract class xxx()
   
    private final int age=10;//可以是常量
    private String name;//也可以是变量

public abstract class xxx()
   public void sleep()//非抽象方法,提高复用性
   System.out.println("睡觉");
   
   

public abstract class xxx()
   public abstract void eat();
   //限定猫类中重写eat方法,否则报错

以上是关于javase基础三大特征之一“多态”的主要内容,如果未能解决你的问题,请参考以下文章

05_JavaSE之OOP--面向对象(多态)

Java面向对象三大特征之继承和多态

三大特性:封装,继承,多态

Java面向对象编程三大特征 - 多态

JavaSE/封装继承多态

JavaSE基础之面向对象(上)