Java面向对象基础记录

最新推荐文章于 2022-11-16 18:03:03 发布

Dandri

最新推荐文章于 2022-11-16 18:03:03 发布

阅读量303

点赞数

分类专栏： JAVA 文章标签：面向对象 JAVA 面向对象基础 JAVA学习

本文链接：https://blog.csdn.net/dandri/article/details/54849557

版权

JAVA 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

面向对象基础学习

2017.01.28

1) 面向对象(面向对象思想概述)(了解)

A:面向过程思想概述
- 第一步
- 第二步
B:面向对象思想概述
- 找对象(第一步,第二步)
C:举例
- 买煎饼果子
- 洗衣服
D:面向对象思想特点
- a:是一种更符合我们思想习惯的思想
- b:可以将复杂的事情简单化
- c:将我们从执行者变成了指挥者
  - 角色发生了转换
E:面向对象开发
- 就是不断的创建对象，使用对象，指挥对象做事情。
F:面向对象设计
- 其实就是在管理和维护对象之间的关系。
G:面向对象特征
- 封装(encapsulation)
- 继承(inheritance)
- 多态(polymorphism)

2) 面向对象(类与对象概述)(掌握)

A:我们学习编程是为了什么
- 为了把我们日常生活中实物用学习语言描述出来
B:我们如何描述现实世界事物
- 属性就是该事物的描述信息(事物身上的名词)
- 行为就是该事物能够做什么(事物身上的动词)
C:Java中最基本的单位是类,Java中用class描述事物也是如此
- 成员变量就是事物的属性
- 成员方法就是事物的行为
D:定义类其实就是定义类的成员(成员变量和成员方法)
- a:成员变量和以前定义变量是一样的，只不过位置发生了改变。在类中，方法外。
- b:成员方法和以前定义方法是一样的，只不过把static去掉，后面在详细讲解static的作用。
E:类和对象的概念
- a:类：是一组相关的属性和行为的集合
- b:对象：是该类事物的具体体现
- c:举例：
  - 类学生
  - 对象具体的某个学生就是一个对象

３) 面向对象(学生类的使用)(掌握)

A:文件名问题
- 在一个java文件中写两个类：一个基本的类，一个测试类。
- 建议：文件名称和测试类名称一致。
B:如何使用对象?
- 创建对象并使用
- 格式：类名对象名 = new 类名();
D:如何使用成员变量呢?
- 对象名.变量名
E:如何使用成员方法呢?
- 对象名.方法名(…)

４) 面向对象(成员变量和局部变量的区别)(掌握)

A:在类中的位置不同
- 成员变量：在类中方法外
- 局部变量：在方法定义中或者方法声明上
B:在内存中的位置不同
- 成员变量：在堆内存(成员变量属于对象,对象进堆内存)
- 局部变量：在栈内存(局部变量属于方法,方法进栈内存)
C:生命周期不同
- 成员变量：随着对象的创建而存在，随着对象的消失而消失
- 局部变量：随着方法的调用而存在，随着方法的调用完毕而消失
D:初始化值不同
- 成员变量：有默认初始化值
- 局部变量：没有默认初始化值，必须定义，赋值，然后才能使用。
注意事项：
- 局部变量名称可以和成员变量名称一样，在方法中使用的时候，采用的是就近原则。
- 基本数据类型变量包括哪些:byte,short,int,long,float,double,boolean,char
- 引用数据类型变量包括哪些:数组,类,接口,枚举

５) 面向对象(方法的形式参数是类名的时候如何调用)(掌握)

A:方法的参数是类名public void print(Student s){}//print(new Student());
- 如果你看到了一个方法的形式参数是一个类类型(引用类型)，这里其实需要的是该类的对象。

６) 面向对象(匿名对象的概述和应用)(掌握)

A:什么是匿名对象
- 没有名字的对象
B:匿名对象应用场景
- a:调用方法，仅仅只调用一次的时候。
  - 那么，这种匿名调用有什么好处吗?
    - 节省代码
  - 注意：调用多次的时候，不适合。匿名对象调用完毕就是垃圾。可以被垃圾回收器回收。
- b:匿名对象可以作为实际参数传递
C:案例演示
- 匿名对象应用场景

７) 面向对象(封装的概述)(掌握)

A:封装概述
- 是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。
B:封装好处
- 隐藏实现细节，提供公共的访问方式
- 提高了代码的复用性
- 提高安全性。
C:封装原则
- 将不需要对外提供的内容都隐藏起来。
- 把属性隐藏，提供公共方法对其访问。

８) 面向对象(private关键字的概述和特点)(掌握)

A:人类赋值年龄的问题
B:private关键字特点
- a:是一个权限修饰符
- b:可以修饰成员变量和成员方法
- c:被其修饰的成员只能在本类中被访问
C:案例演示
- 封装和private的应用：
- A:把成员变量用private修饰
- B:提供对应的getXxx()和setXxx()方法
- private仅仅是封装的一种体现形式,不能说封装就是私有

９) 面向对象(this关键字的概述和应用)(掌握)

A:this关键字特点
- 代表当前对象的引用
B:案例演示
- this的应用场景
- 用来区分成员变量和局部变量重名

2017.01.29

1）面向对象(构造方法Constructor概述和格式)(掌握)

A:构造方法概述和作用
- 给对象的数据(属性)进行初始化
B:构造方法格式特点
- a:方法名与类名相同(大小也要与类名一致)
- b:没有返回值类型，连void都没有
- c:没有具体的返回值return;

2）面向对象(构造方法的重载及注意事项)(掌握)

A:案例演示
- 构造方法的重载
- 重载:方法名相同,与返回值类型无关(构造方法没有返回值),只看参数列表
B:构造方法注意事项
- a:如果我们没有给出构造方法，系统将自动提供一个无参构造方法。
- b:如果我们给出了构造方法，系统将不再提供默认的无参构造方法。
  - 注意：这个时候，如果我们还想使用无参构造方法，就必须自己给出。建议永远自己给出无参构造方法

3）面向对象(给成员变量赋值的两种方式的区别)

A:setXxx()方法
- 修改属性值
B:构造方法
- 给对象中属性进行初始化
这两种方式使用setXXX更加方便，因为比较灵活

4）面向对象(static关键字的特点)(掌握)

A:static关键字的特点
- a:随着类的加载而加载
- b:优先于对象存在
- c:被类的所有对象共享
  - 举例：咱们班级的学生应该共用同一个班级编号。
  - 其实这个特点也是在告诉我们什么时候使用静态?
    - 如果某个成员变量是被所有对象共享的，那么它就应该定义为静态的。
  - 举例：
    - 饮水机(用静态修饰)
    - 水杯(不能用静态修饰)
    - 共性用静态,特性用非静态
- d:可以通过类名调用
  - 其实它本身也可以通过对象名调用。
  - 推荐使用类名调用。
  - 静态修饰的内容一般我们称其为：与类相关的，类成员
  - ```
  class Demo_Person {
      public static void main(String[] args) {
          Person.country = "日本";
          ...
      }
  }
  
  class Person {
      static String country;
      ... 
  }
```
- e、共性用静态，单个个性用动态

5）面向对象(static的注意事项)(掌握)

A:static的注意事项
- a:在静态方法中是没有this关键字的
  - 如何理解呢?
    - 静态是随着类的加载而加载，this是随着对象的创建而存在。
    - 静态比对象先存在。
- b:静态方法只能访问静态的成员变量和静态的成员方法
  - 静态方法：
    - 成员变量：只能访问静态变量
    - 成员方法：只能访问静态成员方法
  - 非静态方法：
    - 成员变量：可以是静态的，也可以是非静态的
    - 成员方法：可是是静态的成员方法，也可以是非静态的成员方法。
  - 简单记：
    - 静态只能访问静态。

6）　面向对象(静态变量和成员变量的区别)(掌握)

静态变量也叫类变量成员变量也叫对象变量
A:所属不同
- 静态变量属于类，所以也称为为类变量
- 成员变量属于对象，所以也称为实例变量(对象变量)
B:内存中位置不同
- 静态变量存储于方法区的静态区
- 成员变量存储于堆内存
C:内存出现时间不同
- 静态变量随着类的加载而加载，随着类的消失而消失
- 成员变量随着对象的创建而存在，随着对象的消失而消失
D:调用不同
- 静态变量可以通过类名调用，也可以通过对象调用
- 成员变量只能通过对象名调用

７) 面向对象(main方法的格式详细解释)(了解)

A:格式
- public static void main(String[] args) {}
B:针对格式的解释
- public 被jvm调用，访问权限足够大。
- static 被jvm调用，不用创建对象，直接类名访问
- void被jvm调用，不需要给jvm返回值
- main 一个通用的名称，虽然不是关键字，但是被jvm识别
- String[] args 以前用于接收键盘录入的

8) 面向对象(工具类中使用静态)(了解)

A:制作一个工具类
- ArrayTool
- 1,获取最大值
- 2,数组的遍历
- 3,数组的反转
- 4,如果一个类中所有的方法都是静态的，需要多做一步，私有构造方法
  - private ArryTool() {}
  - 目的是不让其他类创建本类对象，直接用类名.调用即可

9) 面向对象(说明书的制作过程)(了解)

A:对工具类加入文档注释
B:通过javadoc命令生成说明书
- @author(提取作者内容)
- @version(提取版本内容)
- javadoc -d 指定的文件目录 -author -version ArrayTool.java
- @param 参数名称//形式参数的变量名称@return 函数运行完返回的数据

10) 面向对象(如何使用JDK提供的帮助文档)(了解)

A:找到文档，打开文档
B:点击显示，找到索引，出现输入框
C:你应该知道你找谁?举例：Scanner
D:看这个类的结构(需不需要导包)
- 成员变量字段
- 构造方法构造方法
- 成员方法方法

11) 面向对象(学习Math类的随机数功能)(了解)

打开JDK提供的帮助文档学习
A:Math类概述
- 类包含用于执行基本数学运算的方法
B:Math类特点
- 由于Math类在java.lang包下，所以不需要导包。
- 因为它的成员全部是静态的,所以私有了构造方法
C:获取随机数的方法
- public static double random():返回带正号的 double 值，该值大于等于 0.0 且小于 1.0。
D:我要获取一个1-100之间的随机数，肿么办?
- int number = (int)(Math.random()*100)+1;

2017.01.30

1）面向对象(代码块的概述和分类)(了解)

A:代码块概述
- 在Java中，使用{}括起来的代码被称为代码块。
B:代码块分类
- 根据其位置和声明的不同，可以分为局部代码块，构造代码块，静态代码块，同步代码块(多线程讲解)。
C:常见代码块的应用
- a:局部代码块
  - 在方法中出现；限定变量生命周期，及早释放，提高内存利用率
- b:构造代码块 (初始化块)
  - 在类中方法外出现；多个构造方法方法中相同的代码存放到一起，每次调用构造都执行，并且在构造方法前执行，即优先执行构造代码块！
- c:静态代码块
  - 随着类的加载而加载，只执行一次
  - 在类中方法外出现，并加上static修饰；用于给类进行初始化，在加载的时候就执行，并且只执行一次。
  - 一般用于加载驱动
  - 静态代码块优先于主方法执行！

2）面向对象(继承案例演示)(掌握)

A:继承(extends)
- 让类与类之间产生关系,子父类关系
B:继承案例演示：
- 动物类,猫类,狗类
- 定义两个属性(颜色,腿的个数)两个功能(吃饭，睡觉)
C:案例

class Demo1_Extends {
    public static void main(String[] args) {
        Cat c = new Cat();
        c.color = "花";
        c.leg = 4;
        c.eat();
        c.sleep();
        System.out.println("color = " + c.color + " , leg = " + c.leg);
    }
}

class animal {
    String color;
    int leg;

    public void eat() {
        System.out.println("eating...");
    }

    public void sleep() {
        System.out.println("sleeping...");
    }
}

class Cat extends animal {}

3）面向对象(继承的好处和弊端)(掌握)

A:继承的好处
- a:提高了代码的复用性
- b:提高了代码的维护性
- c:让类与类之间产生了关系，是多态的前提
B:继承的弊端
- 类的耦合性增强了。
- 开发的原则：高内聚，低耦合。
- 耦合：类与类的关系
- 内聚：就是自己完成某件事情的能力

4）面向对象(Java中类的继承特点)(掌握)

A:Java中类的继承特点
- a:Java只支持单继承，不支持多继承。(一个儿子只能有一个爹)
  - 有些语言是支持多继承，格式：extends 类1,类2,…
- b:Java支持多层继承(继承体系)
B:案例演示
- Java中类的继承特点
  - 如果想用这个体系的所有功能用最底层的类创建对象
  - 如果想看这个体系的共性功能,看最顶层的类

5）面向对象(继承的注意事项和什么时候使用继承)(掌握)

A:继承的注意事项
- a:子类只能继承父类所有非私有的成员（public）(成员方法和成员变量)
- b:子类不能继承父类的构造方法，但是可以通过super(马上讲)关键字去访问父类构造方法。
- c:不要为了部分功能而去继承
- 项目经理姓名工号工资奖金
- 程序员姓名工号工资
B:什么时候使用继承
- 继承其实体现的是一种关系：”is a”。
  - Person
    - Student
    - Teacher
  - 水果
    - 苹果
    - 香蕉
    - 橘子
- 采用假设法。
  - 如果有两个类A,B。只有他们符合A是B的一种，或者B是A的一种，就可以考虑使用继承。

6）面向对象(继承中成员变量的关系)(掌握)

A:案例演示
- a:不同名的变量
- b:同名的变量
  - 子类父类在开发中是不允许出现同名变量的，子类继承父类就是为了使用父类的成员

7）面向对象(this和super的区别和应用)(掌握)

A:this和super都代表什么
- this:代表当前对象的引用,谁来调用我,我就代表谁
- super:代表当前对象父类的引用
B:this和super的使用区别
- a:调用成员变量
  - this.成员变量 调用本类的成员变量,也可以调用父类的成员变量
  - super.成员变量 调用父类的成员变量
- b:调用构造方法
  - this(…) 调用本类的构造方法
  - super(…) 调用父类的构造方法
- c:调用成员方法
  - this.成员方法调用本类的成员方法,也可以调用父类的方法
  - super.成员方法调用父类的成员方法

8）面向对象(继承中构造方法的关系)(掌握)

A:案例演示
- 子类中所有的构造方法默认都会访问父类中空参数的构造方法
```
 

class Demo4_Extends { 

public static void main(String[] args) { 

    Son s = new Son(); 

} 

}
```
class Father { public Father() { System.out.println(“Father 构造方法…”); } } class Son extends Father { public Son() { //相当于在此处加了super(); System.out.println(“Son 构造方法…”); } }
- 相当于在子类空参构造中加上 super(); ，就算不写，系统也会默认加上！
B:为什么呢?
- 因为子类会继承父类中的数据，可能还会使用父类的数据。
- 所以，子类初始化之前，一定要先完成父类数据的初始化。
- 其实：
  - 每一个构造方法的第一条语句默认都是：super() Object类最顶层的父类。

9) 面向对象(继承中构造方法的注意事项)(掌握)

A:案例演示

父类没有无参构造方法,子类怎么办?
super解决

this解决

 

class Son extends Father { 

public Son() { 

    //super(null,0);            //使用super解决 

    this(null,0);               //使用this解决 

    System.out.println("Son 空参构造"); 

} 

... 

}

B:注意事项
- super(…)或者*this(….)必须出现在构造方法的第一条语句上*

10) 面向对象(继承中成员方法关系)(掌握)

A:案例演示
- a:不同名的方法
- b:同名的方法

B:解决方法

super可以调用父类的成员属性和方法

 

class Demo6_Extends { 

public static void main(String[] args) { 

    Son s = new Son(); 

    s.print(); 

    s.method(); 

} 

}

class Father { public void print() { System.out.println(“Fu print”); } } class Son extends Father { public void print() { super.print(); //super可以调用父类的成员属性和方法 System.out.println(“Zi print”); }

public void method() {
    System.out.println("Zi method");
}

}

11）面向对象(方法重写概述及其应用)(掌握)

A:什么是方法重写
- 重写:子父类出现了一模一样的方法(注意:返回值类型可以是子父类,这个我们学完面向对象讲)
B:方法重写的应用：
- 当子类需要父类的功能，而功能主体子类有自己特有内容时，可以重写父类中的方法。这样，即沿袭了父类的功能，又定义了子类特有的内容。

C:案例演示

a:定义一个手机类。

 

class Demo7_Phone { 

public static void main(String[] args) { 

    Ios8 i = new Ios8(); 

    i.siri();           //增加ios8的说中文和ios7的Speak English 

    i.call();           //调用ios7的call的功能 

} 

}

class Ios7 { public void call() { System.out.println(“Calling…”); }

public void siri() {
    System.out.println("Speak English...");
}

} class Ios8 extends Ios7 { public void siri() { super.siri(); System.out.println(“说中文…”); } }

12) 面向对象(方法重写的注意事项)(掌握)

A:方法重写注意事项
- a:父类中私有方法不能被重写
  - 因为父类私有方法子类根本就无法继承
- b:子类重写父类方法时，访问权限不能更低
  - 最好就一致
- c:父类静态方法，子类也必须通过静态方法进行重写
  - 其实这个算不上方法重写，但是现象确实如此，至于为什么算不上方法重写，多态中我会讲解(静态只能覆盖静态)
- 子类重写父类方法的时候，最好声明一模一样。
B:案例演示
- 方法重写注意事项

13) 面向对象(方法重写的面试题)(掌握)

A:方法重写的面试题
- Override(重写)和Overload（重载）的区别?Overload能改变返回值类型吗?
- overload可以改变返回值类型,只看参数列表
  - 方法重写：子类中出现了和父类中方法声明一模一样的方法。与返回值类型有关,返回值是一致(或者是子父类)的
  - 方法重载：本类中出现的方法名一样，参数列表不同的方法。与返回值类型无关。
  - 子类对象调用方法的时候：
    - 先找子类本身，再找父类。

14）面向对象(使用继承前和使用继承后的学生和老师案例)(掌握)

A:案例演示
- 使用继承前的学生和老师案例
- 属性:姓名,年龄
- 行为:吃饭
- 老师有特有的方法:讲课
- 学生有特有的方法:学习
B:案例演示
- 使用继承后的学生和老师案例

15）面向对象(final关键字修饰类,方法以及变量的特点)(掌握)

A:final概述
B:final修饰特点
- 修饰类，类不能被继承
- 修饰变量，变量就变成了常量，只能被赋值一次
- 修饰方法，方法不能被重写
C:final修饰特点
- final 修饰常量一般会与 public static 相修饰，组成public static final int NUM = …，这样做的好处是可以直接通过类调用。

16）面向对象(final关键字修饰局部变量)(掌握)

基本类型，是值不能被改变

引用类型，是地址值不能被改变,对象中的属性可以改变

class Demo10_Final {
    public static void main(String[] args) {
        final int NUM = 10;
        //NUM = 20;
        System.out.println("NUM = " + NUM);

    final Person p = new Person("张三",34);
    //p = new Person("李四",44);          //不能再次创建对象
    p.setName("李四");                    //可以对已创建的对象的属性进行赋值
    p.setAge(55);

    System.out.println("name : " + p.getName() + " , age : " + p.getAge());

    method(20);
    method(45);
}

public static void method(final int x) {        //将x改变为final类型
    System.out.println(x);
}


}

class Person {
    private String name;
    private int age;

public Person() {}      //无参构造

public Person(String name,int age) {        //有参构造
    this.name = name;
    this.age = age;
}

public void setName(String name) {
    this.name = name;
}

public String getName() {
    return this.name;
}

public void setAge(int age) {
    this.age = age;
}

public int getAge() {
    return this.age;
}


}

17）面向对象(final修饰变量的初始化时机)(掌握)

A:final修饰变量的初始化时机
- 显示初始化
- 在对象构造完毕前即可

17.02.01

1）面向对象(package关键字的概述及作用)(了解)

A:为什么要有包
- 将字节码(.class)进行分类存放
- 包其实就是文件夹
B:包的概述

举例：
学生：增加，删除，修改，查询
老师：增加，删除，修改，查询
…

方案1：按照功能分
    com.heima.add
        AddStudent
        AddTeacher
    com.heima.delete
        DeleteStudent
        DeleteTeacher
    com.heima.update
        UpdateStudent
        UpdateTeacher
    com.heima.find
        FindStudent
        FindTeacher

方案2：按照模块分
    com.heima.teacher
        AddTeacher
        DeleteTeacher
        UpdateTeacher
        FindTeacher
    com.heima.student
        AddStudent
        DeleteStudent
        UpdateStudent
        FindStudent

2）面向对象(包的定义及注意事项)(掌握)

A:定义包的格式
- package 包名;
- 多级包用.分开即可
B:定义包的注意事项
- A:package语句必须是程序的第一条可执行的代码
- B:package语句在一个java文件中只能有一个
- C:如果没有package，默认表示无包名
C:案例演示
- 包的定义及注意事项

3）面向对象(带包的类编译和运行)(掌握)

A:如何编译运行带包的类
- a:javac编译的时候带上-d即可
  - javac -d . HelloWorld.java(不要忘记有一个点！)
- b:通过java命令执行。
  - java 包名.HellWord

4）面向对象(import关键字的概述和使用)(掌握)

A:案例演示
- 为什么要有import
  - 其实就是让有包的类对调用者可见,不用写全类名了
B:导包格式
- import 包名;
- 注意：
- 这种方式导入是到类的名称。
- 虽然可以最后写*，但是不建议。
C:package,import,class有顺序关系

5）面向对象(四种权限修饰符的测试)(掌握)

A:案例演示
- 四种权限修饰符
B:结论（访问范围）

本类	同一个包下(子类和无关类)	不同包下(子类)	不同包下(无关类)
private	Y
默认	Y	Y
protected	Y	Y	Y
public	Y	Y	Y

6）面向对象(类及其组成所使用的常见修饰符)(掌握)

A:修饰符：
- 权限修饰符：private，默认的，protected，public
- 状态修饰符：static，final
- 抽象修饰符：abstract
B:类：
- 权限修饰符：默认修饰符，public
- 状态修饰符：final
- 抽象修饰符：abstract
- 用的最多的就是：public
C:成员变量：
- 权限修饰符：private，默认的，protected，public
- 状态修饰符：static，final
- 用的最多的就是：private
D:构造方法：
- 权限修饰符：private，默认的，protected，public
- 用的最多的就是：public
E:成员方法：
- 权限修饰符：private，默认的，protected，public
- 状态修饰符：static，final
- 抽象修饰符：abstract
- 用的最多的就是：public
F:除此以外的组合规则：
- 成员变量：public static final
- 成员方法：
  - public static
  - public abstract
  - public final

7）面向对象(内部类概述和访问特点)(了解)

A:内部类概述
B:内部类访问特点
- a:内部类可以直接访问外部类的成员，包括私有。
- b:外部类要访问内部类的成员，必须创建对象。
- 外部类名.内部类名对象名 = 外部类对象.内部类对象;
C:案例演示
- 内部类极其访问特点

8）面向对象(静态成员内部类)(了解)

static
B:成员内部类被静态修饰后的访问方式是:
- 外部类名.内部类名对象名 = 外部类名.内部类对象;

9）面向对象(成员内部类的面试题)(掌握)

A:面试题

要求：使用已知的变量，在控制台输出30，20，10。

class Outer {
    public int num = 10;
    class Inner {
        public int num = 20;
        public void show() {
            int num = 30;
            System.out.println(?);
            System.out.println(??);
            System.out.println(???);
        }
    }
}
class InnerClassTest {
    public static void main(String[] args) {
        Outer.Inner oi = new Outer().new Inner();
        oi.show();
    }   
}

？：num
？？：this.num
？？？：Outer.this.num（内部类之所以能获取到外部类的成员，这是因为它能获取到外部类的引用：外部类.this）

10）面向对象(局部内部类访问局部变量的问题)(掌握)

A:案例演示
- 局部内部类访问局部变量必须用final修饰
- 局部内部类在访问他所在方法中的局部变量必须用final修饰,为什么?
  因为当调用这个方法时,局部变量如果没有用final修饰,他的生命周期和方法的生命周期是一样的,当方法弹栈,这个局部变量也会消失,那么如果局部内部类对象还没有马上消失想用这个局部变量,就没有了,如果用final修饰会在类加载的时候进入常量池,即使方法弹栈,常量池的常量还在,也可以继续使用
  
  但是jdk1.8取消了这个事情,所以我认为这是个bug

11）面向对象(匿名内部类的格式和理解)

A:匿名内部类
- 就是内部类的简化写法。
B:前提：存在一个类或者接口
- 这里的类可以是具体类也可以是抽象类。
C:格式：
new 类名或者接口名(){
重写方法;
}
D:本质是什么呢?
- 是一个继承了该类或者实现了该接口的子类匿名对象。
匿名内部类适用于只重写一个方法的时候使用

12）面向对象(匿名内部类在开发中的应用)

A:代码如下

//这里写抽象类，接口都行
abstract class Person {
    public abstract void show();
}

class PersonDemo {
    public void method(Person p) {
        p.show();
    }
}

class PersonTest {
    public static void main(String[] args) {
        //如何调用PersonDemo中的method方法呢?
        PersonDemo pd = new PersonDemo ();

    }
}

Dandri

关注

0
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
Java面向对象基础记录

面向对象基础学习2017.01.281) 面向对象(面向对象思想概述)(了解)A:面向过程思想概述第一步第二步 B:面向对象思想概述找对象(第一步,第二步) C:举例买煎饼果子洗衣服 D:面向对象思想特点 a:是一种更符合我们思想习惯的思想b:可以将复杂的事情简单化c:将我们从执行者变成了指挥者角色发生了转换E:面向对象开发就是不断的创建对象，使用对象，指挥对
复制链接

扫一扫