面向对象总结

代码心航者

已于 2024-06-30 14:32:47 修改

阅读量690

点赞数 20

文章标签： java

于 2024-06-30 13:41:20 首次发布

本文链接：https://blog.csdn.net/qq_75004322/article/details/140071706

版权

一.面向过程和面向对象

面向过程编程思想强调的是过程,必须清楚每一个步骤,然后按照步骤一步一步去实现。

面向对象编程思想强调的是对象, 通过调用对象的行为来实现功能，而不是自己一步一步的去操作实现。

二.类

2.1类的概述

类是用来描述一类具有共同属性和行为事物的统称。所以其实类在客观世界里是不存在的，是抽象的，只是用来描述数据信息的。

2.2类的组成

属性：就是该事物的状态信息。

行为：就是该事物能够做什么。

2.3类的定义

类的组成是由属性和行为两部分组成

属性：该类事物的状态信息,在类中通过成员变量来体现（类中方法外的变量）

行为：该类事物有什么功能,在类中通过成员方法来体现（和前面的方法比去掉static关键字即可）

三.对象

3.1对象的概述

对象是类的一个实例，具体存在的，看得见摸得着的，并且具备该类事物的属性和行为。

对象的属性:对象的属性具有特定的值

对象的行为:对象可以操作的行为

3.2 类和对象的关系

类是对一类具有共同属性和行为的事物的统称,是抽象的

对象是一类事物的具体实例,看得见,摸的着的,真实存在的实体,是具体的

对象是根据类来创建的

类中有什么属性和行为，对象就有什么属性和行为

3.3 对象的创建和使用

对象的创建

创建对象的格式：类名对象名 = new 类名()；

对象的使用

访问成员变量

获取成员变量的值: 对象名.成员变量名

给成员变量赋值: 对象名.成员变量名=值;

访问成员方法

对象名.成员方法名(实参);

3.4练习

定义一个学生类，然后定义一个测试类，在测试类中通过对象完成成员变量和成员方法的使用。属性: 姓名，年龄...；行为: 学习功能，打游戏功能...

四.成员变量和局部变量

类中位置不同：成员变量类中方法外，局部变量方法内部或方法声明上

初始化值不同：成员变量有默认初始化值，局部变量没有默认初始化值，必须先定义，赋值才能使用

作用范围不同：成员变量:作用于整个类，局部变量:只作用于自己所在的方法，其他方法使用不了

五. 封装

5.1封装概述

封装，它也是面向对象思想的特征之一。面向对象共有三个特征：封装，继承，多态。

封装表现：

方法就是一个最基本封装体。

类其实也是一个封装体。

一台电脑，它是由CPU、主板、显卡、内存、硬盘、电源等部件组长，其实我们将这些部件组装在一起就可以使用电脑了，但是发现这些部件都散落在外面，很容造成不安全因素，于是，使用机箱壳子，把这些部件都装在里面，并在机箱壳上留下一些插口等，若不留插口，大家想想会是什么情况。总结：机箱其实就是隐藏了办卡设备的细节，对外提供了插口以及开关等访问内部细节的方式。

封装好处：

1. 提高了代码的复用性。

2.隐藏了实现细节，还要对外提供可以访问的方式。便于调用者的使用。这是核心之一，也可以理解为就是封装的概念。

3.提高了安全性。

5.2 private关键字

private是一个权限修饰符，代表最小权限。

可以修饰成员变量和成员方法。

被private修饰后的成员变量和成员方法，只在本类中才能访问。

通过对象名直接访问成员变量的方式来对属性赋值,会存在数据安全隐患, 应该怎么解决呢?

解决方式: 不让外界直接访问成员变量(也就是要对属性进行封装)

对需要访问的成员变量,提供对应的getXxx方法(获取属性的值) 、setXxx 方法(给属性赋值) 。

5.3 Get和Set方法

由于属性使用了private关键字修饰,在其他类中无法直接访问,所以得提供公共的访问方法,我们把这张方法叫做set和get方法

get方法: 提供“get变量名()”方法，用于获取成员变量的值，方法用 public修饰

set方法: 提供“set变量名(参数)”方法，用于设置成员变量的值，方法用 public修饰

5.4 this关键字

5.4.1 成员变量和局部变量同名问题

当在方法中出现了局部变量和成员变量同名的时候，那么在方法中怎么区别局部变量成员变量呢？可以在成员变量名前面加上this.来区别成员变量和局部变量

5.4.2 this应用

我们发现setXXX方法中的形参名字并不符合见名知意的规定，那么如果修改与成员变量名一致，是否就见名知意了呢？

六.构造方法

6.1构造方法概述

构造方法是一个比较特殊的方法,主要用来创建对象以及给对象的属性赋初始值

构造方法的定义格式：

构造方法的特点：

构造方法的方法名就是类名

构造方法没有返回值类型,连void都没有

使用new来调用构造方法

构造方法和set方法的区别：

构造方法用来创建对象,并给对象的属性赋初始值,只能赋值一次

set方法用来给对象的属性赋值,可以赋值多次

//空参构造
public class Student{
    // 属性
    private String name;// 姓名
    private int age;// 年龄


    //空参构造
    public Student(){
   }
    // 有参构造
    public Student(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 class Demo {
    public static void main(String[] args) {
        Student stu1 = new Student();// 类名 对象名 = 
new 类名();
       
 System.out.println(stu1.getName()+","+stu1.getAge())
;// null,0
        // 有参构造:
        Student stu2 = new Student("张三",18);
       
 System.out.println(stu2.getName()+","+stu2.getAge())
;// 张三,18
        stu2.setName("冰冰");
        System.out.println(stu2.getName());// 冰冰
        stu2.setName("小泽");
        System.out.println(stu2.getName());// 小泽
   }

}

6.2 构造方法的注意事项

public class Demo {
    public static void main(String[] args) {
        /*构造方法的注意事项:
                1.如果一个类没有定义构造方法,系统会自动生成一个空参构造方法            
                2.如果一个类定义了构造方法,系统就不会再自动生成空参构造方法            
                3.构造方法可以重载,一个类中可以有多个构造方法         
            */

           Student stu = new Student();

           Student stu1 = new Student("张三");

           Student stu2 = new Student(18);
           
           Student stu3 = new Student("张三",18);

           stu.show();// null,0        
           stu1.show();// 张三,0        
           stu2.show();// null,18        
           stu3.show();// 张三,18   
    }
}

6.3标准类制作

JavaBean是 Java语言编写类的一种标准规范。符合JavaBean的类，要求类必须是公共的，属性使用private修饰,并且具有无参数的构造方法，提供用来操作成员变量的set 和get 方法。

public class ClassName{  //成员变量  private
  //构造方法
  //无参构造方法【必须】
  //满参构造方法【建议】
  //getXxx()
  //setXxx()
  //成员方法    
}

6.2随机点名器练习

public class Student {    
    // 成员变量 private    
    private  String name;    
    private  int age;

    // 空参构造方法    
    public Student() {}
      // 满参构造方法    
    public Student(String name, int age) {        
        this.name = name;        
        this.age = age;    
    }
    
    //set.get方法略

    // 成员方法 功能方法
    public void show(){
        System.out.println(name+","+age);    }
}
public class Demo {    
    public static void main(String[] args) {        
    //创建Scanner类的对象        
    Scanner sc=new Scanner(System.in);        
    //创建Student类型的数组        
    Student[] students=new Student[5];        
    //循环遍历数组        
    for (int i = 0; i < students.length; i++) {            
        System.out.println("请输入第"+(i+1)+"个学生的姓名:");            
        String name = sc.next();            
        System.out.println("请输入第"+(i+1)+"个学生的年龄:"); 

        //使用age变量名接收用户的数据           
        int age = sc.nextInt();
        //创建Student学生类的对象            
        Student student=new Student(name,age);            
        students[i]=student;        
    }
        //创建Random类的对象
        Random r=new Random();        
        int index = r.nextInt(5);       
        Student student=students[index];
        //输出        
        student.show();    
    }
}

七.继承

7.1继承概述

7.1.1继承的好处

提高代码的复用性（减少代码冗余，相同代码重复利用）。

类与类之间产生了关系，是多态的前提。

7.1.2 继承的含义

在java中指的是一个类可以继承自另一个类。被继承的类叫做: 父类/ 超类/基类，继承其他类的类叫做:子类。继承后，子类自动拥有父类中可继承的成员(成员变量、成员方法)。子类就不需要再定义了。

7.2 继承的格式

通过extends关键字，可以声明一个子类继承另外一个父类，定义格式如下：

class 父类 {
 ...
}
class 子类 extends 父类 {
 ...
}

注意：

不要为了继承而继承,一定要满足什么是什么的关系(is a)

Java中的类只能单继承,不能多继承(一个类只能有一个父类)

public class Person {
    private String name;// 姓名
    private int age;// 年龄
    private String sex;// 性别
    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 String getSex() {
        return sex;
    }
    public void setSex(String sex) {
        this.sex = sex;
   }
    public void eat(){
        System.out.println("吃饭...");
   }
    public void drink(){
        System.out.println("喝水...");
   }
    public void sleep(){
        System.out.println("睡觉...");
   }
}
public class Student extends Person{
}
public class Dog /* extends Person */{
    //语法上是可以的,但不符合客观世界逻辑
}
public class DemoTest {
    public static void main(String[] args) {
        /*
            继承的格式:public class 子类 extends 父类 {}
            继承的注意事项:
                1.不要为了继承而继承,一定要满足什么是什么的
关系(is a)
                2.Java中的类只能单继承,不能多继承(一个类只
能有一个父类)*/
        Student stu=new Student();
        stu.setName("张三");
        stu.setAge(23);
        stu.setSex("男");
       
 System.out.println(stu.getName()+"..."+stu.getAge()+
"..."+stu.getSex());
        stu.eat();
        stu.drink();
        stu.sleep();
   }
}

7.3继承后私有成员的访问规则

父类的私有成员不能被直接访问

public class Fu {
    private int num=10; //私有成员,只能在本类中使用
    private void method(){
        System.out.println("私有成员方法...");
   }
}
public class Zi extends Fu{
}
public class DemoTest {
    public static void main(String[] args) {
        Zi zi=new Zi();
        //System.out.println(zi.num); 编译报错
        //z.method(); 编译报错
   }
}

7.4继承后非私有成员的访问规则

当通过子类访问非私有成员时，先在子类中找，如果找到就使用子类的，找不到就继续去父类中找。

public class Fu {
    public int money=10;
    public void method(){
        System.out.println("父类成员方法...");
   }
}
public class Zi extends Fu{
    //public int money=100;
    public void method(){
        System.out.println("子类成员方法...");
   }
}
public class DemoTest {
    public static void main(String[] args) {
        Zi zi=new Zi();
        System.out.println(zi.money);
        zi.method();
   }
}

7.5 继承后构造方法的访问规则

构造方法的名字是与类名一致的。所以子类是无法继承父类构造方法的。

public class Fu {
    public Fu(){
   }
    public Fu(String name,int gae){
   }
}
public class Zi extends Fu{
}
public class DemoTest {
    public static void main(String[] args) {
        //Zi zi=new Zi("刘德华",18);编译错误，Zi类没有有参构造
   }
}

7.6 方法重写(Override)

方法重写：子类中出现与父类一模一样的方法时（返回值类型，方法名和参数列表都相同），会出现覆盖效果，也称为重写或者复写。声明不变，重新实现。

方法重载:在同一个类中,方法名相同,参数列表不同
方法重写:在父子类中,出现一模一样的方法时(返回值类型,方法名,参数列表)
重写的注意事项:
            1.方法重写一定要是父子类关系
            2.方法重写要求返回值类型,方法名,参数列表要相同
            3.子类重写父类的方法,要求子类重写方法的访问
权限大于或者等于父类方法的权限
            权限修饰符: public >   protected > 默认(空)   > private
 4.如果是重写的方法,可以使用@Override注解来标识,如果不是重写的方法,就不可以                        
重写的使用场景:父类的方法无法满足子类的需求,才会去重写

7.7 this和super关键字

this：表示当前对象

this可以访问：本类的成员属性、成员方法、构造方法；

super：表示父类对象

super可以访问：父类的成员属性、成员方法、构造方法；

this关键字的三种用法

this访问本类成员变量: this.成员变量

this访问本类成员方法: this.成员方法名();

his访问本类构造方法: this()可以在本类的一个构造方法中，调用另一个构造方法（当使用this()调用另一个构造方法时，此代码必须是此构造方法的第一句有效代码。）

super关键字的三种用法

super访问父类的成员变量: super.父类成员变量名

super访问父类的成员方法: super.成员方法名();

super访问父类的构造方法: super()

super的注意事项：

super访问成员变量和成员方法: 优先去父类中找,如果有就直接使用,如果没有就去爷爷类中找,如果有,就用,依次类推...

子类的构造方法默认会调用父类的空参构造方法,如果父类中的没有空参构造方法,只定义了有参构造方法,会编译报错。

7.8继承的特点

Java中的类只支持单继承，不支持多继承。

// 一个类只能有一个父类，不可以有多个父类。
class A {
    
}
class B {
    
}
class C1 extends A {// ok
    
} 
class C2 extends A, B {// error
    
}

一个类只能有一个父类,但可以有多个子类。

// A可以有多个子类
class A {
    
}
class C1 extends A {
    
}
class C2 extends  A {
    
}

可以多层继承。

class A /*extends Object*/{// 爷爷   默认继承Object类
    
}
class B extends A {// 父亲
    
}
class C extends B {// 儿子
    
}

八.抽象类

8.1抽象类的概述和定义

概述: 使用abstract关键字修饰的类就是抽象类

特点: 这种类不能被创建对象,它就是用来做父类的,被子类继承的

抽象类的定义：

修饰符 abstract class 类名{
    
}

抽象类中的成员：

成员变量

成员方法

构造方法

抽象方法

抽象类的概述和特点
          概述:使用abstract修饰的类就是抽象类
          特点:
            1.抽象类不能创建对象,只能用来做父类
            2.可以写抽象方法
          格式:
            public abstract class 类名{
            }
           抽象类中的成员:
            1.成员变量
            2.构造方法
            3.成员方法
            4.抽象方法
          抽象类和普通类的区别:
          1.抽象类的成员可以包含抽象方法,而普通类不行
          2.抽象类不能创建对象
         */
        //Person p=new Person();//编译报错,抽象类不能创建对象

8.2抽象方法的概述和定义

概述：没有方法体,使用abstract修饰的方法就是抽象方法

抽象方法的定义：

修饰符 abstract 返回值类型 方法名(形参列表);

//抽象方法
    public abstract void method01();
    public abstract int method02(int num);

/*         
          抽象方法的概述
            概述:没有方法体，并使用abstract关键字修饰的方法就是抽象方法
            抽象方法的定义
            修饰符 abstract 返回值类型 方法名(形参列表);
         注意事项:
            1.子类必须重写抽象方法
            2.抽象方法必须在抽象类中,抽象类中不一定都是抽象方法
         */

8.3抽象类的特点

抽象类不能被创建对象，就是用来做“父类”，被子类继承的。

抽象类不能被创建对象，但可以有“构造方法”——为成员属性初始化。

抽象类中可以没有抽象方法,但抽象方法必须定义在抽象类中

子类继承抽象类后,必须重写抽象类中所有的抽象方法,否则子类必须也是一个抽象类

九.final关键字

9.1 final关键字的概述

final：不可改变。可以用于修饰类、方法和变量。

类：被修饰的类，不能被继承。

方法：被修饰的方法，不能被重写。

变量：被修饰的变量，就只能赋值一次,不能被重新赋值。

9.2final关键字的使用

9.2.1修饰类

修饰符 final class 类名 {
  
}

public final class Fu {
    
}
public class Zi /*extends FinalClassFu*/ {
    // Fu类被final修饰了,所以不能被继承
}

9.2.2修饰方法

修饰符 final 返回值类型 方法名(参数列表){
   //方法体
}
public class Fu {
    public final void show(){
   }
}
public class Zi extends Fu {
    /*@Override
    public void show() {
    }*/
    // 无法重写父类中的show方法,因为父类中的show方法被final修饰了
}

9.2.3修饰变量

被final修饰的常量名称，一般都有书写规范，所有字母都大写

//局部变量
public class FinalDemo1 {
    public static void main(String[] args) {
        // 声明变量，使用final修饰
        final int NUM;
        // 第一次赋值 
        NUM = 10;
        // 第二次赋值
        NUM = 20; // 报错,不可重新赋值
   }
}

引用类型的局部变量，被final修饰后，只能指向一个对象。但是不影响对象内部的成员变量值的修改，代码如下：

public class Demo2 {
    public static void main(String[] args) {
        // 创建 User 对象
        final User U = new User();
        // 创建 另一个 User对象
// U = new User(); // 报错，指向了新的对象，地址值改变。
        // 调用setName方法
        U.setName("张三"); // 可以修改
   }
}

成员变量涉及到初始化的问题，初始化方式有两种，只能二选一：

十.static关键字

1.1static关键字概述

static关键字：静态的意思 , 可以修饰变量 , 也可以修饰方法 , 被static修饰的成员 , 我们叫做静态成员

static关键字特点

静态成员被所类的所有对象共享

可以通过对象调用 , 也可以通过类名调用 , 建议使用类名

static关键字使用场景

静态变量:当程序中的某个数据需要共享时使用static修饰

静态方法:工具类

1.2 static关键字注意事项

静态方法中只能调用静态成员

非静态方法中可以调用任何成员

public class Student {
    static String city;
    public static void method(){
        System.out.println(city);
        show();
        System.out.println("method...");
   }
    public static void show(){
        System.out.println("show...");
   }
    public void run(){
        System.out.println(city);
        show();
   }
}

1.3 静态代码块

三种代码块{ 代码块 }, 其中两种没有使用价值

了解:局部代码块方法中

了解:构造代码块写在类中,创建对象的时候运行

掌握:静态代码块写在类中, static{} 在使用类的成员的时候,仅仅执行一次

十一.接口

1.1接口的概述

接口是功能的集合。接口的内部主要就是定义方法，包含常量，抽象方法（JDK 7及以前），默认方法和静态方法（JDK 8）,私有方法(JDK9)。

接口不能创建对象；接口是用来被类实现（implements）的，实现接口的类称为实现类。

好处：

功能的定义与实现分离，优化了程序设计。

程序的扩展性

1.2接口的定义

定义接口的关键字使用interface

接口中可以定义变量，变量有固定的修饰符修饰：public static final。

接口中的变量也称之为常量，其值不能改变。

接口中可以定义方法，方法有固定的修饰符，public abstract

public interface 接口名 {
      public static final 数据类型 变量名 = 值
      public abstract 返回值类型  方法名字(参数列表);
}
public interface MyInterface {
    //固定修饰符 public static final 常量
    public static final int N=10;
    int M=20;
    //固定修饰符 public abstract 抽象方法
    public abstract void method01();
    public void method02();
}

1.3 类实现接口

类与接口的关系为实现关系，即类实现接口。实现的动作类似继承，只是关键字不同，实现使用implements。实现类需要重写接口中所有的抽象方法，创建该类对象，就可以调用方法了，否则它必须是一个抽象类。

public interface MyInterface {
    //固定修饰符 public static final 常量
    public static final int N=10;
    int M=20;
    //固定修饰符 public abstract 抽象方法
    public abstract void method01();
    public void method02();
}

public class MyInterfaceImpl implements MyInterface{
@Override
    public void method01() {
        System.out.println("method01...");
   }
 @Override
    public void method02() {
        System.out.println("method02...");
   }
}
public class DemoTest {
    public static void main(String[] args) {
        //常量被静态修饰,接口的名字直接调用
        System.out.println(MyInterface.N);
        MyInterfaceImpl my=new MyInterfaceImpl();
        System.out.println(my.M);
        my.method01();
        my.method02();
   }
}

1.4 接口的多实现

public interface MyInter01 {
    public void show01();
}

public interface MyInter02 {
    public void show02();
}

public class MyInterImpl implements MyInter01, MyInter02 {
    @Override
    public void show01() {
        System.out.println("show01...");
   }
    @Override
    public void show02() {
        System.out.println("show02...");
   }
}


public class DemoTest {
    public static void main(String[] args) {
        MyInterImpl my=new MyInterImpl();
        my.show01();
        my.show02();
   }
}

1.5 继承类同时实现接口

public class MyInterImpl extends Fu implements MyInter01, 
MyInter02 {
    @Override
    public void show01() {
        System.out.println("show01...");
   }
    @Override
    public void show02() {
        System.out.println("show02...");
   }
    @Override
    public void show03() {
        System.out.println("show03...");
   }
}

public class DemoTest {
    public static void main(String[] args) {
        MyInterImpl my=new MyInterImpl();
        my.show01();
        my.show02();
        my.show03();
   }
}

1.6 接口新增方法

常量(JDK7及其以前)

抽象方法(JDK7及其以前)

默认方法(JDK8额外增加)

静态方法(JDK8额外增加)

私有方法(JDK9额外增加)

public interface MyInter {
    /*
        默认方法:默认的修饰符是 public default,public可以省
略,default不可以省略
        可以继承,也可以重写,重写需要去掉default关键字
     */
    public default void method01(){
        System.out.println("method01...");
   }
    /*
        静态方法:静态方法只能通过接口名调用,不能通过实现类名字和对象
调用
     */
    public static void method02(){
        System.out.println("method02...");
   }
    /*
        私有方法:只能在接口中直接调用
     */
//   private void method03(){
//       System.out.println("mthod03....");3.7 接口和抽象的区别 
相同点
位于继承的顶端,用于被其他类实现或继承；
都不能直接创建对象；
都包含抽象方法,其子类都必须覆写这些抽象方法；
不同点
//   }

public class MyInterImpl implements MyInter{
//   @Override
//   public void method01() {
//
//       System.out.println("impl...method01...");
//
//   }
}

public class DemoTest {
    public static void main(String[] args) {
       MyInterImpl my=new MyInterImpl();
       my.method01();
       MyInter.method02();
   }
}

1.7 接口和抽象的区别

相同点

位于继承的顶端,用于被其他类实现或继承；

都不能直接创建对象；

都包含抽象方法,其子类都必须覆写这些抽象方法；

不同点

抽象类为部分方法提供实现,避免子类重复实现这些方法,提高代码重用性;

一个类只能继承一个直接父类(可能是抽象类),却可以实现多个接口; (接口弥补了Java的单继承)

抽象类是继承体系中应该具备的功能, 继承体系是一种 is..a关系

接口是这个事物中的扩展功能,继承体系是一种 like..a关系

十二.权限修饰符

在Java中提供了四种访问权限，使用不同的访问权限修饰符修饰时，被修饰的内容会有不同的访问权限。public：公共的；protected：受保护的；(空的)：默认的；private：私有的。

十三.多态

1.多态概述

面向对象的第三大特性：封装、继承、多态

多态：是指同一行为，对于不同的对象具有多个不同表现形式。

程序中多态: 是指同一方法,对于不同的对象具有不同的实现。

多态前提条件

继承或者实现【二选一】

父类类型指向子类对象【格式体现】父类类型变量名 = new 子类类型();

方法的重写【意义体现：不重写，无意义】

2.多态的定义和使用

2.1 多态定义格式

父类类型变量名 = new 子类类型();

变量名.方法名();

2.2 普通类多态定义的格式

public class Person {
    public void run(){
        System.out.println("run...");
   }
}
public class Student extends Person{
    @Override
    public void run() {
        System.out.println("学生大步跑...");
   }
}
public class Teacher extends Person{
    @Override
    public void run() {
        System.out.println("老师碎步跑...");
   }
}public class DemoTest {
    public static void main(String[] args) {
        Person p01=new Student();
        p01.run();
        Person p02=new Teacher();
        p02.run();
   }
}

2.3 抽象类多态定义的格式

public abstract class Animal {
    public abstract void eat();
}
public class Cat extends Animal{
    @Override
    public void eat() {
        System.out.println("猫吃鱼...");
   }
}
public class Dog extends Animal{
    @Override
    public void eat() {
        System.out.println("狗吃肉...");
   }
}
public class DemoTest {
    public static void main(String[] args) {
        Animal a1=new Cat();
        a1.eat();
        Animal a2=new Dog();
        a2.eat();
   }
}

2.4 接口多态定义的格式

public interface MyInter {
    public void fly();
}
public class Bird implements MyInter{
    @Override
    public void fly() {
        System.out.println("鸟靠翅膀飞...");
   }
}
public class Plane implements MyInter{
    @Override
    public void fly() {
        System.out.println("飞机靠动力飞...");
   }
}
public class DemoTest {
    public static void main(String[] args) {
        MyInter my01=new Bird();
        my01.fly();
        MyInter my02=new Plane();
        my02.fly();
    }
}

3.多态时访问成员的特点

多态时成员变量的访问特点：编译看父类，运行看父类

多态时成员方法的访问特点：编译看父类，运行看子类

4.多态的好处与弊端

4.1 多态的好处与弊端

好处：提高了代码的扩展性。实际开发的过程中，父类类型作为方法形式参数，传递子类对象给方法，进行方法的调用，更能体现出多态的扩展性与便利。

弊端：多态的情况下，只能调用父类的共性内容，不能调用子类的特有内容。

4.2 类型转换

向上转型：子类类型向父类类型向上转换的过程，这个过程是默认的。

Fu fu = new Zi();

向下转型：父类类型向子类类型向下转换的过程，这个过程是强制的。

Aniaml aniaml = new Cat();  

Cat c = (Cat)aniaml;//向下转型

c.catchMouse();// 可以访问 子类独有的功能,解决多态的弊端

instanceof关键字

为了避免ClassCastException的发生，Java提供了instanceof 关键字，给变量做类型的校验。

变量名 instanceof 数据类型

如果变量属于该数据类型，返回true。

如果变量不属于该数据类型，返回false。

public class DemoTest {
    public static void main(String[] args) {
        Animal animal=new Dog();
        animal.eat();
        //animal.lookHome();//编译报错 无法调用子
类特有的功能
        Dog dog=(Dog)animal;五.多态的几种表现形式 
5.1 形参多态 
        dog.lookHome();
       // Cat cat=(Cat)animal; 类型转换异常
        if(animal instanceof Dog){
            Dog d=(Dog)animal;
            d.lookHome();
       }
   }

5.多态的几种表现形式

5.1 形参多态

public abstract class Animal {
    public abstract void eat();
}
public class Cat extends Animal{
    @Override
    public void eat() {
        System.out.println("猫吃鱼...");
   }
public void catchMouse(){
    System.out.println("猫抓老鼠...");
   }
}
public class Dog extends Animal{
    @Override
    public void eat() {
        System.out.println("狗吃肉...");
   }
    public void lookHome(){
        System.out.println("狗看家...");
   }
}
public class DemoTest {
    public static void main(String[] args) {
        Dog dog=new Dog();
        method(dog);
        Cat cat=new Cat();
        method(cat);
   }
public static void method(Animal animal){
        animal.eat();
        if(animal instanceof Dog){
            Dog dog=(Dog)animal;
            dog.lookHome();
       }
        if(animal instanceof Cat){
            Cat cat=(Cat)animal;
            cat.catchMouse();
       }
   }
}

5.32返回值多态

public abstract class Animal {
    public abstract void eat();
}
public class Cat extends Animal{
    @Override
    public void eat() {
        System.out.println("猫吃鱼...");
   }
public void catchMouse(){
        System.out.println("猫抓老鼠...");
   }
}
public class Dog extends Animal{
    @Override
    public void eat() {
        System.out.println("狗吃肉...");
   }
    public void lookHome(){
        System.out.println("狗看家...");
   }
}
public class DemoTest {
    public static void main(String[] args) {
        Cat cat=new Cat();
        Dog dog=new Dog();
        Animal a01 = method01(cat);
        Animal a02 = method01(dog);
        Animal animal = method02();
}
    public static Animal method01(Animal animal)
{
        //一系列操作,操作后,返回操作后的对象
        return animal;
   }
    public static Animal method02(){
       /* Dog dog = new Dog();
        return dog;*/
        return new Cat();
   }
}

十四.内部类

1.1 内部类概述

将一个类A定义在另一个类B里面，里面的那个类A就称为内部类，B则称为外部类。

内部类分为成员内部类与局部内部类。

1.2 成员内部类

成员内部类：定义在类中方法外的类。

class 外部类 {
    class 内部类{
   }
}

public class Outer {
    class Inner{
        //成员变量
        public int num=10;
        //成员方法
        public void methodN(){
           
 System.out.println("inner...methodN...");
       }
        
   }
}

1.3 成员内部类访问特点

在其他类中,需要创建成员内部类对象来访问内部类成员

在外部类中访问成员内部类的成员,需要创建成员内部类对象在成员内部类中可以直接访问外部类的一切成员(包含私有的)

public class Outer {
    public int numW=20;
    public void methodW(){
        //创建内部类对象
        //Outer.Inner in=new Outer().new 
Inner();
        Inner in=new Inner();
        System.out.println(in.num);
        in.methodN();
   }
    public void method(){
        System.out.println("外部类...method...");
   }
    class Inner{
        //成员变量
        public int num=10;
//成员方法
        public void methodN(){
           
 System.out.println("inner...methodN...");
            //访问外部类成员
            System.out.println(numW);
            method();
       }
   }
}


 * 外部类名.内部类名 对象名 = new 外部类型().new 内部
类型()；
 */
public class DemoTest {
    public static void main(String[] args) {
        //在其他类中,需要创建成员内部类对象来访问内部类
成员
        Outer.Inner in=new Outer().new Inner();
        System.out.println(in.num);
        in.methodN();
        System.out.println("---------------");
        
        //在外部类中访问成员内部类的成员,需要创建成员内
部类对象
        Outer out=new Outer();
out.methodW();
   }
}

十五.匿名内部类

1. 匿名内部类概述

匿名内部类是内部类的简化写法它的本质是一个带具体实现的父类或者父接口的匿名的子类对象。

2. 匿名内部类作用

匿名内部类的作用: 为了简化代码,并没有什么特殊的功能

public abstract class Animal {
    public abstract void eat();
    
}
public class Cat extends Animal{
    @Override
    public void eat() {
        System.out.println("猫吃鱼...");
   }
}

public class DemoTest {
    public static void main(String[] args) {
        /*
            需求:调用Aniaml类的eat()方法
            1.创建一个子类继承Animal类
            2.在子类中重写eat方法
            3.创建子类对象
            4.使用子类对象调用eat方法
         */
        Animal a01=new Cat();
        a01.eat();
        Animal a02=new Animal(){
            @Override
            public void eat() {
                System.out.println("eat...");
           }
       };
        a02.eat();
   }
}


public interface MyInter {
     
     void method();
}
public class DemoTest {
    public static void main(String[] args) {
 MyInter my=new MyInter() {
            @Override
            public void method() {
                System.out.println("method...");
           }
       };
        my.method();
   }
}