（二）、Java复习笔记之面向对象

最新推荐文章于 2022-01-16 15:29:14 发布

椰子Tyshawn

最新推荐文章于 2022-01-16 15:29:14 发布

阅读量365

点赞数 2

分类专栏： Java笔记文章标签： java

本文链接：https://blog.csdn.net/litianxiang_kaola/article/details/78358480

版权

Java笔记专栏收录该内容

25 篇文章 6 订阅

订阅专栏

13、数组的初始化

一维数组：
- int[] arr = new int[]{1，2，3，4，5}; //正确
- int[] arr = {1，2，3，4，5}; //正确
- int[] arr = new int[5]{1，2，3，4，5}; //错误
- int[] arr;
- arr = new int[]{1，2，3，4，5}; //正确。
- arr = {1，2，3，4，5}; //错误
二维数组：
- int[][] arr = new int[3][2]; //正确
- int[] arr[] = new int[3][2]; //正确
- int arr[][] = new int[3][2]; //正确

14、值传递和引用传递

值传递：传递的是值的拷贝，不改变原值。如基本数据类型及其包装类、String。
引用传递：传递的是引用的地址值，改变原值。如类类型，接口类型和数组。
Java中只有传值，因为地址值也是值。（面试）

15、static关键字

static关键字的特点
- 随着类的加载而加载
- 优先于对象存在
- 被类的所有对象共享
- 可以通过类名调用
static的注意事项
- 在静态方法中是没有this关键字的
  - 如何理解呢?
    - 静态是随着类的加载而加载，this是随着对象的创建而存在。
    - 静态比对象先存在。
- 静态方法只能访问静态的成员变量和静态的成员方法
  - 简单记：
    - 静态只能访问静态。
如果一个类中所有的方法都是静态的（工具类），需要私有化构造方法，目的是不让其他类创建本类对象。

16、代码块的概述和分类（面试）

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

面试题：看程序写结果

class Student {
    static {
        System.out.println("Student 静态代码块");
    }

    {
        System.out.println("Student 构造代码块");
    }

    public Student() {
        System.out.println("Student 构造方法");
    }
}

class Demo2_Student {
    static {
        System.out.println("Demo2_Student静态代码块");
    }

    public static void main(String[] args) {
        System.out.println("我是main方法");

        Student s1 = new Student();
        Student s2 = new Student();
    }
}
结果：
Demo2_Student静态代码块
我是main方法
Student 静态代码块
Student 构造代码块
Student 构造方法
Student 构造代码块
Student 构造方法

17、开发的原则

高内聚，低耦合
耦合：类与类的关系
内聚：就是自己完成某件事情的能力

18、继承的注意事项

子类只能继承父类所有非私有的成员(成员方法和成员变量)
子类不能继承父类的构造方法，但是可以通过super关键字去访问父类构造方法。
子类中所有的构造方法默认都会访问父类中空参数的构造方法
- 因为子类会继承父类中的数据，可能还会使用父类的数据。
- 所以，子类初始化之前，一定要先完成父类数据的初始化。
- 其实：每一个构造方法的第一条语句默认都是：super()，Object类是最顶层的父类。
当类没有重载有参数的构造方法，JVM会默认增加一个空参数的构造方法。否则，不增加。

面试题

看程序写结果1：
class Fu{
    public int num = 10;
    public Fu(){
        System.out.println("fu");
    }
}
class Zi extends Fu{
    public int num = 20;
    public Zi(){
        System.out.println("zi");
    }
    public void show(){
        int num = 30;
        System.out.println(num);
        System.out.println(this.num);
        System.out.println(super.num);
    }
}
class Test1_Extends {
    public static void main(String[] args) {
        Zi z = new Zi();
        z.show();
    }
}   
结果：
fu
zi
30
20
10

看程序写结果2
class Fu {
    static {
        System.out.println("静态代码块Fu");
    }

    {
        System.out.println("构造代码块Fu");
    }

    public Fu() {
        System.out.println("构造方法Fu");
    }
}

class Zi extends Fu {
    static {
        System.out.println("静态代码块Zi");
    }

    {
        System.out.println("构造代码块Zi");
    }

    public Zi() {
        System.out.println("构造方法Zi");
    }
}

public class Demo{
    public static void main(String[] args) {
        Zi z = new Zi();
    }
}
/*
 * 1、JVM先加载Fu.class，加载后执行Fu静态代码块，然后再加载Zi.class，加载后执行Zi静态代码块。
 * 2、在执行Zi.class的构造方法之前先执行Fu.class的构造方法
 * 3、执行构造方法之前先执行构造代码块
 */
结果：
静态代码块Fu
静态代码块Zi
构造代码块Fu
构造方法Fu
构造代码块Zi
构造方法Zi

19、this和super的区别

this和super都代表什么
- this：代表当前对象的引用，谁来调用我，我就代表谁
- super：代表当前对象父类的引用
this和super的使用区别
- 调用成员变量
  - this.成员变量调用本类的成员变量，也可以调用父类的成员变量
  - super.成员变量调用父类的成员变量
- 调用构造方法
  - this(…) 调用本类的构造方法
  - super(…) 调用父类的构造方法
- 调用成员方法
  - this.成员方法调用本类的成员方法，也可以调用父类的方法
  - super.成员方法调用父类的成员方法
注意，super(…)或者this(….)必须出现在构造方法的第一条语句上

20、方法重载、方法覆盖、多态

方法重载(Overload)：方法名相同，参数不同。
```
void foo(String str);
void foo(int number);
```

方法覆盖(Override)：也叫方法重写，父类与子类有同样的方法名和参数。

class Parent {
    void foo() {
        System.out.println("Parent foo()");
    }
}
class Child extends Parent {
    void foo() {
        System.out.println("Child foo()");
    }
}

多态：见下21

21、多态

概述
- 事物存在多种形态
多态的前提：
- 要有继承关系
- 要有方法重写（覆盖）
- 要有父类引用指向子类对象（调用方法时会调用子类的实现，而不是父类的实现）
```
Parent instance = new Child();
instance.foo(); // Child foo()
```

多态中成员访问特点

成员变量：调用变量时会调用父类的变量
成员方法：调用方法时会调用子类的实现

静态方法：调用方法时会调用父类的实现（静态与类相关，算不上重写）

public class Demo{
    public static void main(String[] args) {
        Father f = new Son();
        System.out.println(f.num);
        f.print();
        f.method();
    }
}

class Father {
    int num = 10;
    public void print(){
        System.out.println("father");
    }

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

class Son extends Father{
    int num = 20;
    public void print(){
        System.out.println("son");
    }

    public static void method(){
        System.out.println("son static method");
    }
}
结果：
10
son
father static method

多态的好处
- 提高了代码的维护性（继承保证）
- 提高了代码的扩展性（由多态保证）
  - 可以作为形式参数，接受任意子类对象
多态的弊端
- 不能使用子类特有的属性和行为

22、方法重写的注意事项

父类中私有方法不能被重写
- 因为父类私有方法子类根本就无法继承
子类重写父类方法时，访问权限不能更低
- 最好就一致
父类静态方法，子类也必须通过静态方法进行重写
- 静态与类相关，其实算不上重写。

23、final关键字

final修饰特点
- 修饰类，类不能被继承
- 修饰变量，变量就变成了常量，只能被赋值一次
- 修饰方法，方法不能被重写
final关键字修饰局部变量
- 基本类型，是值不能被改变
- 引用类型，是地址值不能被改变，对象中的属性可以改变
final修饰变量的初始化时机
- 类成员变量没有显示初始化时，JVM会默认初始化
- 加了final修饰后JVM不再默认初始化

24、抽象类

概述
- 抽象就是看不懂的
抽象类的特点
- 抽象类和抽象方法必须用abstract关键字修饰
  - abstract class 类名{}
  - public abstract void eat();
- 抽象类不一定有抽象方法，有抽象方法的类一定是抽象类或接口
- 抽象类不能实例化，那么抽象类如何实例化呢？
  - 按照多态的方式，由具体的子类实例化。其实这也是多态的一种，抽象类多态。
- 抽象类的子类
  - 要么是抽象类
  - 要么重写抽象类中所有抽象方法
抽象类成员特点
- 成员变量：既可以是变量，也可以是常量。abstract不能修饰成员变量
- 构造方法：有。用于子类访问父类数据的初始化。
- 成员方法：既可以是抽象的，也可以是非抽象的。
抽象类的成员方法特性：
- 抽象方法：强制要求子类做的事情
- 非抽象方法：子类继承的事情，提高代码复用性
面试题
- 面试题1：一个抽象类如果没有抽象方法，可不可以定义为抽象类？如果可以，有什么意义？
  - 可以。这么做目的是不让其他类创建本类对象，交给子类完成
- 面试题2：abstract不能和哪些关键字共存
  - static、final、private
  - static和abstract，被abstract修饰的方法没有方法体，static修饰的方法可以用类名.调用，但是类名.调用抽象方法是没有意义的。
  - final和abstract，被abstract修饰的方法强制子类重写，被final修饰的方法不让子类重写，矛盾。
  - private和abstract，abstract修饰方法目的是让子类强制重写，private修饰方法不让子类继承，矛盾。

25、接口

概述
- 从狭义的角度讲就是指Java中的interface
- 从广义的角度讲对外提供规则的都是接口
特点
- 接口用关键字interface表示
  - interface 接口名 {}
- 类实现接口用implements表示
  - class 类名 implements 接口名 {}
- 接口不能实例化，那么接口如何实例化呢？
  - 按照多态的方式来实例化
- 接口的子类
  - 可以是抽象类。但意义不大
  - 可以是具体类。要重写接口中所有抽象方法（推荐）
接口成员特点
- 成员变量：只能是常亮，并且是静态公共的。
  - 默认修饰符：public static final
- 构造方法：无
- 成员方法：只能是抽象方法
  - 默认修饰符：public abstract

26、抽象类和接口的区别

成员区别
- 抽象类
  - 成员变量：可以变量，也可以常量
  - 构造方法：有。
  - 成员方法：可以抽象，也可以非抽象
- 接口
  - 成员变量：只能是常量
  - 成员方法：只能是抽象
关系区别
- 类与类：继承，单继承
- 类与接口：实现，单实现，多实现
- 接口与接口：继承，单继承，多继承
设计理念区别
- 抽象类：被继承体现的是“is a”关系。抽象类中定义的是该继承体系的共性功能。
- 接口：被实现体现的是“like a”关系。接口中定义的是该继承体系的扩展功能。

27、如何编译运行带包的类

javac编译的时候带上-d即可
- javac -d . HelloWorld.java
通过java命令执行。
- java 包名.HellWord

28、四种权限修饰符

这里写图片描述

29、类及其组成所使用的常见修饰符

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

30、内部类访问特点

内部类可以直接访问外部类的成员，包括私有。
外部类要访问内部类的成员，必须创建对象。
创建内部类对象格式：
- 外部类名.内部类名对象名 = 外部类对象.内部类对象;
成员内部类被静态修饰后的访问方式：
- 外部类名.内部类名对象名 = 外部类名.内部类对象;

实例

public class Test {
    public static void main(String[] args) {
        Outer.Inner oi = new Outer.Inner();
        oi.method();

        Outer.Inner2.print();
    }
}

class Outer {
    static class Inner {
        public void method() {
            System.out.println("method");
        }
    }

    static class Inner2 {
        public static void print() {
            System.out.println("print");
        }
    }
}

面试题

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

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

局部内部类：在方法中定义的内部类

public class Test {
    public static void main(String[] args) {
        Outer o = new Outer();
        o.method();
    }
}

class Outer {
    public void method() {
        final int num = 10; //jdk1.8后不用再加final
        class Inner {
            public void print() {
                System.out.println(num);
            }
        }

        Inner i = new Inner();
        i.print();
    }
}

匿名内部类：内部类的简化写法

前提：存在一个类或者接口
- 这里的类可以是具体类也可以是抽象类。
格式：
new 类名或者接口名(){
重写方法;
}
本质：是一个继承了该类或者实现了该接口的子类匿名对象。

实例

public class Test {
    public static void main(String[] args) {
        PersonDemo pd = new PersonDemo ();

        //如何调用PersonDemo中的method方法呢?
        pd.method(new Person() {
            public void show() {
                System.out.println("Hello World");
            }
        });
    }
}

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

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

面试题

按照要求，补齐代码
interface Inter { void show(); }
class Outer { //补齐代码 }
class OuterDemo {
public static void main(String[] args) {
Outer.method().show();
}
}
要求在控制台输出”HelloWorld”

public class Test {
    public static void main(String[] args) {
        Outer.method().show(); //连续两次调用方法，说明返回的是个对象
    }
}

//按照要求，补齐代码
interface Inter { 
    void show(); 
}

class Outer { 
    //补齐代码 
    public static Inter method() {
        return new Inter() {
            public void show() {
                System.out.println("Hello World");
            }
        };
    }
}
//要求在控制台输出”Hello World”

椰子Tyshawn

关注

2
点赞
踩
1

收藏

觉得还不错? 一键收藏
1
评论
（二）、Java复习笔记之面向对象

13、数组的初始化一维数组：int[] arr = new int[]{1，2，3，4，5}; //正确int[] arr = {1，2，3，4，5}; //正确int[] arr = new int[5]{1，2，3，4，5}; //错误int[] arr;arr = new int[]{1，2，3，4，5}; //正确。arr = {1，2，3，4，5}; //错误二维数组：in
复制链接

扫一扫