• java复习回顾

    文章目录

    0 开发工具

    Maven是进行包管理的工具，只需要声明一些配置，程序就可以自动下载所依赖的包。其配置文件在本机电脑~\.m2\settings.xml中，settings.xml里面声明了依赖包存放的位置，也可以在里面声明下载依赖包的国内镜像地址。

    idea中自带了jdk，无需额外安装。
    Git可用来进行版本控制

    1. 对象和类、三大特性

    面向对象的思想object oriented programming：一切皆对象，对象由属性和方法构成。
    类相当于一个模板，对象是由类创建出来的，每个对象都是类的一个实例，创建对象的过程也称为实例化。

    封装：把一些对象的共同属性、方法抽象出来，合理的封装，抽象成类。
    继承：子类享有父类的属性和方法，并且还存在一定的属性和方法的扩展
    多态：有两种意义的多态。一种是操作名称的多态，即有多个操作具有相同的名字，但这些操作所接收的参数类型必须不同。 另一种多态是和继承有关的多态，是指同一个操作被不同类型对象调用时可能产生不同的行为。

    2. 成员/实例变量和实例变量（this关键字）

    成员变量也叫实例变量。
    在这里插入图片描述

    // 该例子展示了实例/成员变量、局部变量的作用范围
// 以及this关键字的使用：this指向当前对象
public class Dog {
    String name;
    public Dog(){ // 构造方法
        name="汪汪";
    }
    public void eat(){
        String name="局部变量汪汪";
        System.out.println(name+"在吃东西");//name=局部变量汪汪
        System.out.println(this.name+"在吃东西");//name=汪汪
    }
    public void sleep(){
        System.out.println(name+"在睡觉");//name=汪汪
    }

    public String getName() {
        return name; //name=汪汪
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21

    3. 方法重载overload

    方法重载overload：一个类中定义多个具有相同名字的方法，具体执行哪个，由传入的参数决定。即方法名字相同，参数列表不同（类型、个数、顺序），与返回值类型、访问修饰符无关。
    System.out.println();是一个经典的重载方法。

    //方法重载举例
public class ClassTest {
    public void test(int a){}
    public void test(String a){}
    public void test(int a,String b){}
    public void test(String a,int b){}
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    4. 构造方法和this关键字

    构造方法：类中的特殊方法，主要用于创建对象。

    • 名称与类名相同
    • 没有返回类型
    • 创建对象时，出发构造方法
    • 编译器默认执行一个无参的构造方法
    • 构造方法也可以重载，遵循重载规则
    public class ThisTest {
    public static void main(String[] args) {
        ThisDog dog=new ThisDog("汪汪",5,"公");
        System.out.println(dog.name+"---"+dog.age+"---"+dog.sex);
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    public class ThisDog {
    String name;
    int age;
    String sex;
    public ThisDog(String name,int age){
        this.name=name;
        this.age=age;
    }
    public ThisDog(String name,int age,String sex){
        this(name,age); //this调用重载的构造方法只能放在第一行
        this.sex=sex;
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13

    5. 继承

    语法：class子类 extends 父类{ } //定义子类时，显式继承父类。所有的类默认都继承Object
    应用：子类可以使用父类中的属性和方法，也可定义自己独有的属性和方法。
    优势：提高了代码的复用性和可扩展性。
    特点：单继承（一个子类只能有一个直接父类）；多重继承（类之间可以多级继承，如C类可以继承A类、B类中所有的属性和方法）
    在这里插入图片描述
    注意：父类的私有属性可以被继承但不能被直接访问（可借助其他工具观察内存分布，可知父类的私有属性可以被继承。父类的私有属性可通过get、set方法访问）。
    当父类和子类具有相同的属性时，使用super和this关键字区分。

    在这里插入图片描述

    父类的私有属性可通过get、set方法访问

    public class A {
    private int a;
    
    public void setA(int a) {
        this.a = a;
    }

    public int getA() {
        return a;
    }

    public void show() {
        System.out.println("父类的show方法");
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    public class B extends A{
    public B(){
        setA(1);
    }
    public void show(){
        System.out.println(getA()+" 子类的show方法");
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    public class Test {
    public static void main(String[] args) {
        B b=new B();
        b.show();
    }
}
//输出： 1 子类的show方法

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    6. 访问修饰符

    Java中，可以使用访问控制符来保护对类、变量、方法和构造方法的访问。Java 支持 4 种不同的访问权限。

    • default (即默认，什么也不写）: 在同一包内可见，不使用任何修饰符。使用对象：类、接口、变量、方法。
    • private : 在同一类内可见。使用对象：变量、方法。 注意：不能修饰类（外部类）
    • public : 对所有类可见。使用对象：类、接口、变量、方法
    • protected : 对同一包内的类和所有子类可见。使用对象：变量、方法。 注意：不能修饰类（外部类）。

    我们可以通过以下表来说明访问权限：
    在这里插入图片描述
    默认访问修饰符-不使用任何关键字
    如果在类、变量、方法或构造函数的定义中没有指定任何访问修饰符，那么它们就默认具有默认访问修饰符。

    默认访问修饰符的访问级别是包级别（package-level），即只能被同一包中的其他类访问。

    7. 方法重写

    前提A是父类，B extends A
    有以下规则和特点：

    1. 子类方法的访问权限可以比父类大
    2. 子类方法的返回值类型可以和父类一致，也可以是父类返回类型的子类
    3. 方法名一定要完全一样
    4. 参数列表也必须和父类完全一样（否则就成方法重载了）
    5. 子类重写父方法后，优先执行子类方法。若想要执行父类中被重写 的方法，使用super关键字
    //父类A中的show方法
protected A show() {
    System.out.println("父类的show方法");
    return null;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    //子类B中的show方法，B extends A，public > protected，B < A
public B show(){
	super.show();
    System.out.println("子类的show方法");
    return null;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    public class Test {
    public static void main(String[] args) {
        B b=new B();
        b.show();
    }
}
/*输出：
父类的show方法
子类的show方法
*/

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

    8. 继承下的构造执行

    要想构造子类，必先调用父类构造方法，但并未构建一个父类对象，构建的是子类对象

    // 无参构造方法
package example05;

public class Test {
    public static void main(String[] args) {
        new C();
    }
}
class A{
    public A(){
        System.out.println("A的构造方法");
    }
}
class B extends A{
    public B(){
        System.out.println("B的构造方法");
    }
}
class C extends B{
    public C(){
        System.out.println("C的构造方法");
    }
}
//output:
//A的构造方法
//B的构造方法
//C的构造方法

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27

    要想构造子类，必先调用父类构造方法，但并未构建一个父类对象，构建的是子类对象。其空间分布如下：
    其判断具体见下面代码中的注释掉的输出，均为true。
    一个子类对象可以是一个父类类型，但一个父类对象不能是一个子类类型。如b是B的一个对象，c是C的一个对象，b instanceof C=false，c instanceof B=true

    //        System.out.println(this instanceof B);// true，一个子类类型可以是一个父类类型
//        System.out.println(this instanceof C);// true

    • 1
    • 2

    在这里插入图片描述

    // 有参构造方法
package example06;

public class Test {
    public static void main(String[] args) {
        C c=new C(7,8,9);
        System.out.println(c.a+"---"+c.b+"---"+c.c);
    }
}
class A{
    int a=1;
    public A(int a){
        this.a=a;
        System.out.println("A的构造方法");
    }
}
class B extends A{
    int b=2;
    public B(int a,int b){
        super(a);
        this.b=b;
        System.out.println("B的构造方法");
//        System.out.println(this instanceof B);// true
//        System.out.println(this instanceof C);// true
    }
}
class C extends B{
    int c=3;
    public C(int a,int b,int c){
        super(a,b);
        this.c=c;
        System.out.println("C的构造方法");
    }
}
//输出
//A的构造方法
//B的构造方法
//C的构造方法
//7---8---9

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39

    9. 多态

    以下所举例子，均以A是父类，B extends A，C extends B为前提。

    9.1 向上转型

    父类引用指向子类对象，从而形成多态。
    父类引用仅可调用父类所声明的属性和方法，不可调用子类独有的属性和方法。
    A a=new B(); A a是父类引用（引用类型），new B()产生了一个子类对象（对象类型），a只能调用A中的方法/属性，不能调用B中的方法/属性。也就是a.属性/方法()必须在类A中存在。
    若子类B没有重写A的show方法，输出父类A的show方法。若调用a.showB()会报错，因为父类A中并没有showB方法

    package example06;

public class Test {
    public static void main(String[] args) {
        A a=new B();
        a.show();
//        a.showB(); //报错
    }
}
class A{
    public void show(){
        System.out.println("父类A的show方法");
    }
}

class B extends A{
    public void show(){
        System.out.println("子类B的show方法");
    }
    public void showB(){
        System.out.println("子类B的showB方法");
    }
}

//输出：子类B的show方法

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25

    9.2 向下转型

    将父类引用中的真实子类对象，强制转换为子类本身对象，称为向下转型。

    A a=new B();
B b=(B) a;//强制类型转换

    • 1
    • 2

    向下转型前，应判断引用中的对象的真实类型（使用instanceof来判断），保证类型转换的正确性。

    9.3 多态的应用

    应用一：使用父类作为方法形参实现多态，使方法参数的类型更广泛。
    应用二：使用父类作为方法返回值实现多态，使方法可以返回不同子类对象。

    package example08;

public class Person {
    public void feed(Pet pet){//多态的应用一，Pet作为方法形参
        pet.eat();
    }
    public Pet getPet(String type){//多态的应用二，返回的是Pet
        if(type.equals("dog")){
            return new Dog();
        }
        else{
            return new Cat();
        }
    }
    public static void main(String[] args) {
        Person person=new Person();
        Pet pet=person.getPet("dog");
        person.feed(pet);//多态的应用二
        person.feed(new Cat());//多态的应用一，可以改成new别的，如Dog
    }

}
class Pet{
    public void eat(){
        System.out.println("在吃东西");
    }
}

class Dog extends Pet{
    public void eat(){
        System.out.println("狗狗在啃骨头");
    }
}
class Cat extends Pet{
    public void eat(){
        System.out.println("猫咪在吃鱼");
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
  • 相关阅读:
    王道计算机考研 操作系统学习笔记篇章一：操作系统概念
    GBase 8d的分布式特性-Referral特性
    多显示屏，将Qt程序显示在指定显示器上
    CY3-NHS ester良好的光稳定性介绍1032678-38-8
    图扑软件用数据可视化形式告诉你，楼宇建设如何数字化转型
    Python日志模块：实战应用与最佳实践
    第07章 连接Hadoop集群
    嵌入式IDE之修改MDK主题(暗黑主题)
    RabbitMQ高级篇，进阶内容
    判断三条边是否构成三角形(Python实现)
  • 原文地址：https://blog.csdn.net/qq_44807176/article/details/133438832