面向对象高级day01--继承总结

雨里的夜

已于 2023-04-09 21:14:18 修改

阅读量60

点赞数 1

分类专栏： JAVAEE进阶文章标签： java 开发语言 ide

于 2023-04-05 20:02:57 首次发布

本文链接：https://blog.csdn.net/weixin_50705923/article/details/129963584

版权

JAVAEE进阶专栏收录该内容

4 篇文章 0 订阅

订阅专栏

---------------

1.继承概述

2.继承的好处语弊端

3.继承的语法

4.继承中成员的访问特点

5.方法重写

6.java类的注意事项

7.包

8.修饰符

9.main方法详解

10.static应用：工具类

11.Math类的使用

12.扩展

1.继承概述

(1). 继承是面向对象的三大特性之一（封装，继承，多态）。

(2). 可以使子类有自己特有内容的同时，拥有父类的属性，方法和构造，还可以在子类中重新定义，追加属性和方法。

2.继承的好处和弊端

好处：

提高了代码的复用性（多个类相同的成员可以放到一个类中）

提高了代码的维护性（如果方法的代码需要修改，只需要修改一处即可）

弊端：

提高了类之间的耦合性, 修改父类, 就会影响到子类的内容，削弱了子类的独立性削弱了子类的独立性(代码要低耦合: 因为耦合度高了,扩展性就差了)
耦合性: 关联度
扩展性: 当需求变化的时候,改变越少,扩展性就越强

3.继承的语法

(1).格式（核心关键字 extends）

//.格式        在子类名后面加extends 父类名
// B是父类,基类,超类
//A是子类,派生类
class A extends B{//类体 }

        (2).继承的应用场景：
                    使用继承，需要考虑类与类之间是否存在is..a的关系，不能盲目使用继承
                    is..a的关系：谁是谁的一种

例如：老师和学生是人的一种，那人就是父类，学生和老师就是子类，两类事物有从属关系的时候，比如狗是属于动物的一种那么狗就可以继承动物。

4.继承中成员的访问特点

(1).在子类方法中访问一个变量

I. 核心: 就近原则
II. 详解: 先访问子类局部,再访问子类成员,最后访问父类成员，如果都没有就报错

(不考虑父亲的父亲…)

注：假设父类和子类成员变量重名了怎么去区分:

父类的成员变量用: super.成员变量名
当前类的成员变量: this.成员变量名

(2).通过子类对象访问一个方法

子类成员范围内找，再到父类成员找，没有就报错

(3).构造方法的访问特点（构造方法用来创建对象及对本类中的成员变量进行默认初始化。）

核心：子类构造必须调用父类的构造

详解：子类中所有的构造方法默认都会访问父类的空参构造，因为子类会继承父类中的数据，可能还会使用父类的数据。所以，子类初始化之前，一定要先完成父类数据的初始化且每一个子类构造方法的第一条语句默认都是：super() 如果父类没有空参构造,子类就需要手动调用父类的有参构造，通过使用super关键字去显示的调用父类的带参构造方法在父类中自己提供一个无参构造方法
推荐：自己给出无参构造方法

语法:

1. this(...) 调用本类构造

2. super(...) 调用父类构造

3. 注意点

I. 必须在构造方法里才能使用

II. 必须写在有效代码第一行

5.方法重写

定义：子类中出现了和父类一模一样的方法声明（返回值类型，方法名，参数列表）

应用场景：当子类需要父类的功能，而功能主体子类有自己特有内容时，可以重写父类中的方法，这样，即沿袭了父类的功能，又定义了子类特有的内容。 **@Override：**是一个注解，检查重写方法的方法声明的正确性。

注：注意区分重载和重写

重写：子父类中，方法名相同，参数列表相同，返回值类型也相同的方法。

重载：在同一个类中，方法名相同，参数列表不同，与返回值无关

6.java类的继承注意事项

java类的继承只有单继承和多层继承，没有多继承。

7.包

        导包的格式
                格式：import 包名;
                范例：import java.util.Scanner;

注意：如果当前类和我们要使用的类在同一个包下这个时候是不需要导的
如果一个类是在java.lang包下的，也不需要导包。

/*
   TODO 包 package
    1. 包是文件夹,路径
    2. 导包的目的: 就是让JVM知道类在何处
    3. 在java中,用到一个类,都需要导包,只有两种情况例外
        1). java.lang 包下的类(String,Object)
        2). 本包下的类
    4. 特殊情况:
         一个类中需要用到两个类,这两个类的类名相同,报名不同的情况
         其中一个可以导包,另一个就需要写 完全限定名(报名+类名)
 */
public class Demo {

    public static void main(String[] args) {

        String str = "abc";
        Student s = new Student();

        Teacher t = new Teacher("张三");

        com.itheima10.Teacher t2 = new com.itheima10.Teacher(18);

    }
}

8.修饰符

(1).权限修饰符

public > protected > 默认 > private

//如果想任意访问就用 public修饰
//如果只想给本类使用  private
//如果想给本类和其子类使用： protected
public class Fu {
    //私有 : 本类内部
    private int id1;
    //默认,缺省 : 只能本包
    int id2;
    //受保护: 本包,以及非本包的子类内部
    protected int id3;
    //公开
    public int id4;
}

(2).状态修饰符

----final关键字----

final 修饰类表明该类是最终类，则不可被继承

final 修饰方法表明该方法是最终方法，则不可被重写

final 修饰变量表明该变量是常量，则不可被修改，但必须给初始值。

//最终类: 不可被继承 (例子: String)
public final class A {

}
class B{
    //最终方法: 不能被重写
     public final void show(){

    }
}
class C extends B{
   /* @Override
    public void show() {

    }*/
}
class D{
    //final修饰的变量必须给初始值，
      //常量 : 一次赋值,终身不变, 常量名一般大写

    final int YEAR = 0;

    public void show(){

    }
}

final 修饰局部变量：

变量是基本类型：final 修饰指的是基本类型的数据值不能发生改变

变量是引用类型： final 修饰指的是引用类型的 地址值 不能发生改变，但是地址里面的内容是可以发生改变的

package com.itheima12;

/*
    TODO final修饰变量的特殊情况
        1. 变量是基本类型：final 修饰指的是基本类型的数据值不能发生改变
        2. 变量是引用类型：final 修饰指的是引用类型的地址值不能发生改变，但是地址里面的内容是可以发生改变的

 */
public class Demo {

    public static void main(String[] args) {

        //基本类型的数据值不能发生改变
        final int YEAR = 2023;
//        YEAR = 2024; //报错

        //引用类型的地址不能发生改变
        final Student s = new Student();
        //堆中内容可以变
        s.age = 1;
        s.age = 2;

//        s = new Student(); //报错
    }
}

----static关键词----

1. 定义：**static**关键字是静态的意思，可以修饰成员方法，成员变量

2.格式：

静态变量：类名称.静态变量
静态方法：类名称.静态方法()

3.static 修饰的特点

1). 被类的所有对象共享，这也是我们判断是否使用静态关键字的条件

2). 可以通过类名调用，当然，也可以通过对象名调用，推荐使用类名调用

4.static访问特点

1).非静态的成员方法能访问静态的成员变量，成员方法。也能访问非静态的成员变量，成员方法。

2).静态的成员方法只能访问静态的成员变量和成员方法。

总结成一句话就是：静态成员方法只能访问静态成员

public class Student {

    //非静态变量
    public int a;
    //静态变量
    public static int b;

    //非静态方法
    public void method01(){
        System.out.println(a);
        System.out.println(b);
        this.method02();
        method02();
        System.out.println(this);
    }
    //静态方法
    public static void method02(){
        System.out.println(b);
    }

}

注：a. 静态不能直接访问非静态。
原因：因为在内存当中是【先】有的静态内容，【后】有的非静态内容。

b. 静态方法当中不能用this。
原因：this代表当前对象，通过谁调用的方法，谁就是当前对象。

c.static的使用场景:
①如果需要共享数据,可以使用static
②如果想要方便调用某些成员,可以使用static修饰

(PS:因为就可以直接用类名来调用,不需要创建对象)

详解：因为被staric修饰的东西就属于类了,所以可以使用类名.来调用
被staric修饰的东西就属于类了,类的加载优先于对象,所以在静态方法中,不能使用非静态(PS:非静态的成员是属于对象)的成员,类出现的时候对象还不存在,所以不能使用还不存在的东西
因为被staric修饰的东西就属于类了,而this代表的某个对象,类加载的时候对象还没创建,所以在静态方法中不能使用this,因为对象都没有出现呢

package com.itheima13;
/*
    TODO static关键字
     1. static 关键字是静态的意思，可以修饰成员方法，成员变量
     2. static 修饰的特点
        1). 被类的所有对象共享，这也是我们判断是否使用静态关键字的条件
        2). 可以通过类名调用，当然，也可以通过对象名调用，推荐使用类名调用
     3. 非静态可以调用静态,静态不能调用非静态(对象)
        1). 例子: 静态方法不能调用非静态属性和方法
        2). 例子: 静态方法不能调用this和super
 */
public class Demo {

    public static void main(String[] args) {

        //非静态变量会进堆,一个对象一个非静态变量,是相互独立
        Student s1 = new Student();
        s1.a = 1;
        Student s2 = new Student();
        s2.a = 2;

        System.out.println(s1.a);//1
        System.out.println(s2.a);//2

        //静态变量不会进堆(在方法区),在内存只有一份,被该类所有对象所共享
        Student s3 = new Student();
        s3.b = 3;
        Student s4 = new Student();
        s4.b = 4;
        System.out.println(s3.b);//4
        System.out.println(s4.b);//4
        //静态成员可以类名直接调用,推荐!
        Student.b = 5;
        System.out.println(Student.b);//5

        Student.method02();
    }
}

静态方法的好处
    1. 静态的好处
        直接通过类名直接调用,无需创建对象, 节省内存和时间,运行快
    2. 比如: main方法
        1). 介绍: 这是java程序的入口方法,由JVM自动调用
        2). public static void main(String[] args)
            参数: 接收jvm调用时传入的参数

/*
    TODO 静态方法的好处
        1. 静态的好处
            直接通过类名直接调用,无需创建对象, 节省内存和时间,运行快
        2. 比如: main方法
            1). 介绍: 这是java程序的入口方法,由JVM自动调用
            2). public static void main(String[] args)
                参数: 接收jvm调用时传入的参数
 */
public class Demo05 {

    public static void main(String[] args) {

//        Student s1 = new Student();
//        s1.method01();
//        Student.method02();

        for (int i = 0; i < args.length; i++) {
            String str = args[i];
            System.out.println(str);
        }

        String a = Person.name;
        int length = a.length();
        System.out.println(length);

        System.out.println(Person.name.length());
    }
}

class Person{
    public static String name = "xx";
}

9.main方法详解

main方法的声明：

public static void main(String[] args) { }

public 被jvm调用，访问权限足够大
static 被jvm调用，不用创建对象，直接类名访问
void 被jvm调用，不需要给jvm返回值
main 一个通用的名称，虽然不是关键字，但是被jvm识别
String[] args 以前用于接收键盘录入的
演示args接收数据

10.static应用：工具类

工具类的特点:

构造方法私有

成员用 static修饰

工具类的方法一般有以下两个特点
1). 工具类中的方法基本纯逻辑,跟非静态成员无关
2). 工具类中的方法经常被设计成静态的,这样调用方便,而且还快

11.Math类的使用

Math类是：数学工具类，包含对数学运算的方法

帮助文档中，没有看到构造方法，因为成员都用static修饰了，可以通过类名直接访


public class Demo02 {

    public static void main(String[] args) {

        int abs = Math.abs(-1);
        //absolute : 绝对值
        System.out.println(abs); //1

        //向上取整
        double ceil = Math.ceil(3.1);
        System.out.println(ceil);// 4

        //向下取整
        double floor = Math.floor(3.1);
        System.out.println(floor);// 3

        //四舍五入
        long round = Math.round(3.5);
        System.out.println(round); // 4

        //取较大值
        System.out.println(Math.max(10, 20)); // 20

        //幂运算: 2的3次方
        double pow = Math.pow(2, 8);
        System.out.println(pow);//8
    }
}

12.扩展

         # IDEA创建工程的两种方式
                0. 概念
                1). project : 项目,工程
                2). module : 模块
        a. 直接Project

        b. 先创建empty project,然后在里面添加module
            1). A module有编译异常, B module是不能运行
            2). 更便于区分不同的知识

雨里的夜

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
面向对象高级day01--继承总结

被staric修饰的东西就属于类了,类的加载优先于对象,所以在静态方法中,不能使用非静态(PS:非静态的成员是属于对象)的成员,类出现的时候对象还不存在,所以不能使用还不存在的东西。例如：老师和学生是人的一种，那人就是父类，学生和老师就是子类，两类事物有从属关系的时候，比如狗是属于动物的一种那么狗就可以继承动物。
复制链接

扫一扫

专栏目录