Java复习（二）

java 复习（二）

目录

• java 复习（二）
• • 1. 多态
  • • 1.1 多态的前提
    • 1.2 多态中的成员访问特点
    • 1.3 向上转型
    • 1.4 向下转型
    • 1.5 多态的好与坏
  • 2. 抽象类
  • • • 注意点
    • 2.1 抽象类的子类
  • 3. 接口
  • • 3.1 接口的子类
    • 3.2 接口的成员特点
  • 4. 参数传递
  • • 4.1 类名作为参数作为形参和返回值
    • 4.2 抽象类作为形参和返回值
    • 4.3 接口名作为形参和返回值
  • 5. 内部类
  • • 5.1 内部类访问特点
    • 5.2 成员内部类
    • 5.3 局部内部类
    • • 特点
    • 5.3 匿名内部类
  • 6.常用API
  • 7.Object 类的方法重写
  • 8.引用数据类型与包装类型的区别

1. 多态

1.1 多态的前提

• 要有继承或者实现关系
• 要有方法的重写
• 要有父类引用指向子类对象

1.2 多态中的成员访问特点

• 成员方法：编译看左边（父类对象有没有），执行看右边（子类对象有没有）
• 成员变量：编译看左边（父类对象有没有），执行看左边（父类对象有没有）

1.3 向上转型

• 父类引用指向子类对象

1.4 向下转型

• 子类对象=父类引用

1.5 多态的好与坏

• 不是重写的方法不能使用，变量不能使用

2. 抽象类

• 抽象方法：没有方法体的方法
• 抽象类：含有抽象方法的类（可以含有普通方法）

注意点

• 抽象类中不一定有抽象方法，有抽象方法的一定是抽象类
• 抽象类不能实例化

2.1 抽象类的子类

• 要么重写抽象类中的所有抽象方法
• 要么是抽象类

3. 接口

• 一个特定行为的抽象，一个工具，大家在有需要的时候就用，并不是一个公共行为（固有行为）
• 接口本身不能实例化，它的实现类实现了一个接口，这个类在实例化，这叫接口多态

3.1 接口的子类

• 重写所有抽象方法
• 抽象类

3.2 接口的成员特点

• 成员变量：只能是常量，默认修饰符public static final，（不可见）
• 无构造方法
• 成员方法：只能是抽象方法，默认修饰符 public abstract（不可见）
• 一个类可以实现多个接口
• 接口与接口之间是继承关系

4. 参数传递

4.1 类名作为参数作为形参和返回值

• 作为形参，传递的是地址值
• 作为返回值，返回的也是地址值

4.2 抽象类作为形参和返回值

• 方法的形参为抽象类名，起始需要的是该抽象类的子类对象
• 方法的返回值是抽象类名，其实返回的是该抽象类的子类对象

abstract class Animal {
public abstract void eat();
}
class Cat extends Animal {
@Override
public void eat() {
System.out.println("猫吃鱼");
}
}
class AnimalOperator {
public void useAnimal(Animal a) { //Animal a = new Cat();
a.eat();
}
public Animal getAnimal() {
Animal a = new Cat();
return a;
}
}
public class AnimalDemo {
public static void main(String[] args) {
//创建操作类对象，并调用方法
AnimalOperator ao = new AnimalOperator();
Animal a = new Cat();
ao.useAnimal(a);
Animal a2 = ao.getAnimal(); //new Cat()
a2.eat();
}
}

4.3 接口名作为形参和返回值

• 方法的形参为接口名，其实需要的是该接口的实现类对象
• 方法的返回值为接口名，返回的该接口的实现类对象

interface Jumpping {
void jump();
}
class JumppingOperator {
public void useJumpping(Jumpping j) { //Jumpping j = new Cat();
j.jump();
}
public Jumpping getJumpping() {
Jumpping j = new Cat();
return j;
}
}
class Cat implements Jumpping {
@Override
public void jump() {
System.out.println("猫可以跳高了");
}
}
public class JumppingDemo {
public static void main(String[] args) {
//创建操作类对象，并调用方法
JumppingOperator jo = new JumppingOperator();
Jumpping j = new Cat();
jo.useJumpping(j);
Jumpping j2 = jo.getJumpping(); //new Cat()
j2.jump();
}
}

5. 内部类

• 定义：在一个类A中定义一个类B

5.1 内部类访问特点

• 内部类可以访问外部类的成员
• 外部类的成员访问内部类，需要创建内部类对象

5.2 成员内部类

• 在成员变量的位置
• 在外界创建成员内部类

Outer.Inner oi=new Outer().new Inner();

• 一般用法

class Outer {
private int num = 10;
private class Inner {
public void show() {
System.out.println(num);
}
}
public void method() {
Inner i = new Inner();
i.show();
}
}
public class InnerDemo {
public static void main(String[] args) {
//Outer.Inner oi = new Outer().new Inner();
//oi.show();
Outer o = new Outer();
o.method();
}
}

5.3 局部内部类

• 在方法中定义的一个类

特点

• 外界无法使用，需要在内部创建对象使用
• 该类可以访问外部类的成员和局部变量

5.3 匿名内部类

• 前提：存在一个类或者接口，类可抽象也可具体
• 本质：没有名字的一个类的子类或者一个接口的实现类

6.常用API

• Math类

• System类

• Object类

• Arrays类

• 查阅jdk文档

7.Object 类的方法重写

• toString方法
• equals方法

8.引用数据类型与包装类型的区别

1. 引用类型与基本包装类型的主要区别就是对象的生存期
2. 使用new操作符创建的引用类型的实例，在执行流离开当前作用域之前都一直保存在内存中
3. 自动创建的基本包装类型的对象，则只存在于一行代码的执行瞬间，然后立即被销毁