Java程序设计基础学习笔记——IDEA的使用、包、封装、继承、多态

最新推荐文章于 2023-10-14 18:01:09 发布

原创最新推荐文章于 2023-10-14 18:01:09 发布 · 577 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#intellij-idea #学习 #java #ide #开发语言

JAVA程序设计基础学习笔记专栏收录该内容

9 篇文章

订阅专栏

文章介绍了Java编程中IDEA的常用快捷键，如`sout`用于`System.out.println()`。讲解了包的概念，包括包的命名规则和使用，以及如何利用包进行数组排序。接着深入探讨了面向对象的三大特性——封装、继承和多态，详细阐述了继承的细节，如子类构造器对父类构造器的调用规则。同时，文章通过实例展示了类的继承关系和多态的运用。

以下笔记整理自B站UP主韩顺平【零基础快速学Java】韩顺平零基础30天学会Java课程

IDEA常用快捷键

System.out.println();——快捷键——sout

IDEA模板

自定义模板方法

包基本介绍

包原理

包的本质：创建不同的文件夹/目录来保存类文件

包的命名规则和命名规范

常用的包

包的使用细节

使用包完成数组排序

package com.jzalearn.pkg;

/* 注意：建议使用到哪个类就导入哪个类，不建议全部导入 */
//import java.util.Scanner;  //表示只会引入 java.util 包下的 Scanner 类
//import java.util.*;        //表示将 java.util 包下的所有类都引入（导入）

import java.util.Arrays;

public class Import01 {

    public static void main(String[] args) {

        //使用系统提供的 Arrays 完成数组排序
        int[] arr = {-1, 2, 58, 23, -5};

        //进行排序
        Arrays.sort(arr);

        for(int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + "\t");
        }
    }
}

package 的作用是声明当前类所在的包，需要放在类(或者文件)的最上面，一个类中最多只有一句 package

import 指令位置放在 package 的下面，在类定义前面,可以有多句且没有顺序要求

访问修饰符规则

面向对象编程的三大特征

封装、继承、多态

封装

封装实现步骤

继承

继承的本质就是建立查找关系

继承细节问题

子类继承了所有的属性和方法，非私有的属性和方法可以在子类直接访问, 但是私有属性和方法不能在子类直接访问，要通过父类提供公共的方法去访问

子类必须调用父类的构造器，完成父类的初始化

当创建子类对象时，不管使用子类的哪个构造器，默认情况下总会去调用父类的无参构造器，如果父类没有提供无参构造器，则必须在子类的构造器中用 super 去指定使用父类的哪个构造器完成对父类的初始化工作，否则，编译不会通过

如果希望指定去调用父类的某个构造器，则显式的调用一下 : super(参数列表)

调用父类的无参构造器：super()或者不写

super 在使用时，必须放在构造器第一行(super 只能在构造器中使用)

super() 和 this() 都只能放在构造器第一行，因此这两个方法不能共存在一个构造器

java 所有类都是 Object 类的子类, Object 是所有类的基类.（ctrl+H可以查看继承关系）

父类构造器的调用不限于直接父类！将一直往上追溯直到 Object 类(顶级父类)

子类最多只能继承一个父类(指直接继承)，即 java 中是单继承机制。

不能滥用继承，子类和父类之间必须满足 is-a 的逻辑关系

先在方法区加载类之间的关系，然后在堆中分配空间

访问的时候先从子类开始，如果子类中没有再访问父类，如果子类中有就结束，只要有一级不能访问，就结束，不会越过这一级。

package com.jzalearn.extend_;

public class Extendtheory {
    public static void main(String[] args) {

        Son son = new Son();
        System.out.println(son.age);        //10
        System.out.println(son.hobby);      //旅游
        System.out.println(son.name);       //大头儿子
    }
}

class GrandPa {
    String name = "大头爷爷";
    String hobby = "旅游";
}

class Father extends GrandPa {
    String name = "大头爸爸";
    int age = 10;
}

class Son extends Father {
    String name = "大头儿子";
}

课堂练习题1

分析如下代码的输出结果

package com.jzalearn.extend_.Exercise;

public class ExtendsExercise01 {

    public static void main(String[] args) {

        B b = new B();

    }
}

class A {
    A() {
        System.out.println("a");
    }
    A(String name) {
        System.out.println("a name");
    }
}

class B extends A{
    B() {
        this("abc");
        System.out.println("b");
    }
    B(String name) {
        //这里有隐藏的super()
        System.out.println("b name");
    }
}

输出结果

a
b name
b

课堂练习题2

分析如下代码的输出结果

package com.jzalearn.extend_.Exercise;

public class ExtendsExercise02 {

    public static void main(String[] args) {
        CC cc = new CC();

    }
}

class AA {                       //AA 类
    public AA() {
        System.out.println("我是 AA 类");
    }
}

class BB extends AA{ //BB 类,继承 AA 类
    public BB() {
        System.out.println("我是 BB 类的无参构造");
    }
    public BB(String name) {
        //这里有默认的super()
        System.out.println(name + "我是 BB 类的有参构造");
    }
}

class CC extends BB {
    public CC() {
        this("hello");
        System.out.println("我是 CC 类的无参构造");
    }
    public CC(String name) {
        super("hahah");
        System.out.println("我是 CC 类的有参构造");
    }
}

输出结果

我是 AA 类
hahah我是 BB 类的有参构造
我是 CC 类的有参构造
我是 CC 类的无参构造

super和this的比较

多态

课堂练习题

属性是看编译类型，方法的调用是看运行类型