每日总结Day01

filthy555

已于 2024-06-19 16:51:08 修改

阅读量1k

点赞数 34

文章标签： java

于 2024-06-19 16:50:15 首次发布

本文链接：https://blog.csdn.net/filthy555/article/details/139804828

版权

每日总结Day01

一、静态&继承

1.静态

1.1成员变量

static关键字
    静态的意思，可以修饰成员变量、成员方法

成员变量按照有无static修饰，分为两种
    类变量:有static修饰，属于类，随着类的加载而加载，在计算机中只有一份，会被类的所有对象共享
        方式1: 类名.类变量(推荐)
        方式2: 对象名.类变量(不推荐)
    实例变量:无static修饰，属于每个对象自己
        对象名.实例变量

public class Demo {
    public static void main(String[] args) {
        //需求1: 访问Student中的类变量name,赋值张三
        Student.name = "张三";
        Student.sex = '男';
        //需求2: 访问Student中的实例变量age,赋值18
        Student st1 = new Student();
        st1.age = 18;
        Student st2 = new Student();
        st2.age = 19;
        //需求3: 获取Student的name和age的值,打印在控制台
        System.out.println(Student.name);
        System.out.println(st1.name);
        System.out.println(st1.age);
        System.out.println(st2.age);
        System.out.println(st1.name.equals(st2.name));
    }
}
class Student {
    //定义1个类变量: 记录学生姓名name
    static String name;
    static char sex;
    //定义1个实例变量, 记录学生的年龄age
    int age;
}

总结
    类变量既可以使用类名调用,也可以使用对象名调用,推荐类名方式
    实例变量只能使用对象名调用

1.2类变量的应用场景

在开发中，如果某个数据只需要一份，且希望能够被共享(访问/修改)，则该数据可以定义为静态变量

案例导学
    系统启动后，要求类可以记住自己创建了多少个用户对象

注意
    访问本类中的类变量，可以省略类名不写

public class Demo {
    public static void main(String[] args) {
        User u1 = new User();
        User u2 = new User();
        User u3 = new User();
    }
}

//用户类
class User {
    static int number;
    static int num = 8;

    public User() {
        User.number ++;
        User.num--;
        System.out.println("创建了"+User.num +"个用户");
    }
}

1.3成员方法

类方法
    有static修饰的方法, 属于类
    调用方式:
        类名.方法名()   [推荐]
        对象名.方法名() [不推荐]

实例方法
    无static修饰的方法, 属于对象
    调用方式:
        对象名.方法名()

public class Demo1 {
    public static void main(String[] args) {
        //需求1: 类方法调用
        Student.sayHello();
        //需求2: 实例方法调用
        Student student = new Student();
        student.sayHelloWorld();
    }
}
class Student {
    //编写一个类方法(使用Static修饰方法)打印hello
    public static void sayHello(){
        System.out.println("hello");
    }
    //编写一个实例方法(不使用Static修饰方法)打印HelloWorld
    public void sayHelloWorld(){
        System.out.println("打印HelloWorld");
    }
}

1.4成员方法的应用场景

方法最常见的应用场景
    做工具类

工具类
    我们有时候会开发一些非常实用的、具有独立功能的方法，而且希望这些方法可以被重复使用，就像一个个小工具一样
    这些方法所在的类，就被我们称为是工具类，而工具类中的方法，我们习惯上设置为类方法。

工具类一般要求:
    1. 工具类中每个方法都可以完成一个独立的功能
    2. 类中每个方法都要使用static修饰,方便调用者直接调用
    3. 为防止调用者创建工具类的对象,一般建议将工具类的构造方法私有
    4. 类名和方法名要求见名知意, 类名一般使用xxxUtil

public class Demo {
    public static void main(String[] args) {
        //调用工具类的方法完成功能
        int a = 10;
        int b= 20;
        int max = MathUntils.max(a, b);
        System.out.println(max);
        int min = MathUntils.min(a, b);
        System.out.println(min);
        int sum = MathUntils.sum(a, b);
        System.out.println(sum);


    }
}
//需求: 单独创建一个工具类,完成求两个整数的最大值、最小值、总和的方法

class MathUntils{
    public static int max(int a,int b){
        return a>b?a:b;
    }
    public static int min(int a,int b){
        return a<b?a:b;
    }
    public static int sum(int a,int b){
        return a+b;
    }
}

1.5注意事项

类方法、实例方法的注意事项
    1. 类方法中可以直接访问类的成员，不可以直接访问实例成员。
    2. 实例方法中既可以直接访问类成员，也可以直接访问实例成员。
    3. 实例方法中可以出现this关键字，类方法中不可以出现this关键字的。

总结:
    1. 静态方法只能访问静态内容,实例方法可以访问任何内容
    2. 静态方法中不能用this

本质:
    静态的内容是跟随类加载而加载的, 此时还没有对象, 也就没有this和实例内容

1.6代码块

代码块是类的5大成分之一（成员变量、构造器、方法、代码块、内部类）。
代码块分为两种：
    静态代码块:
        格式：static { }
        特点：类加载时自动执行，由于类只会加载一次，所以静态代码块也只会执行一次。
        作用：完成类的初始化，例如：对类变量的初始化赋值。
    实例代码块:
        格式：{ }
        特点：每次创建对象时，执行实例代码块，并在构造器前执行。
        作用：和构造器一样，都是用来完成对象的初始化的，例如：对实例变量进行初始化赋值。

public class Demo {
    public static void main(String[] args) {
        //类加载
        System.out.println(Student.name);
        System.out.println(Student.name);
        //对象创建
        Student student = new Student();
        Student student1 = new Student();
        Student student2 = new Student();
        System.out.println(student.age);
    }
}

class Student {
    //静态变量
    public static String name;
    //实例变量
    public int age;
    //静态代码块:类加载时自动执行，由于类只会加载一次，所以静态代码块也只会执行一次, 可以用来对类变量进行初始化赋值
    static {
        Student.name = "张三";
        System.out.println("执行静态代码块");
    }
    //实例代码块:每次创建对象时，执行实例代码块，并在构造器前执行。
    {
        age = 18;
        System.out.println("执行实例代码块");
    }
}

2.继承

2.1语法

继承
    Java中提供了一个关键字extends，用这个关键字，可以让一个类和另一个类建立起父子关系。
    class B extends A{
        B类: 子类(派生类)
        A类: 父类(基类或者超类)
    }

继承的特点
    子类能继承父类的非私有成员变量和方法

继承体系下类对象的创建
    子类的对象是由子类、父类共同完成的

public class Demo {
    public static void main(String[] args) {
        //继承下对象的创建: 子类的对象是由子类和父类共同完成的
        B b = new B();
        System.out.println(b.i);
        //System.out.println(b.j);//父类私有, 子类是无法直接使用的
        //System.out.println(b.k);//子类私有, 无法直接方法(封装的特点)
        b.print1();
        //b.print2();//父类私有, 子类是无法直接使用的
        b.print3();
    }
}
/*
    父类
*/
class A {
    //公有成员变量和方法
    public int i;
    public void print1(){
        System.out.println("父类中的print1方法");
    }
    //私有成员变量和方法
    private int j;
    private void print2(){
        System.out.println("父类中的print2方法");
    }
}
//使用extends关键字表明继承了A类
class B extends A{
    private int k;
    public void print3(){
        //父类的非私有的成员变量和方法,子类可以直接使用
        System.out.println(i);
        print1();
        //父类私有的成员变量和方法,子类可以继承到, 但是无法使用
        //System.out.println(b);
        //print2();
    }
}

继承的好处:
    提高代码的复用性(将多个类中的重复代码向上抽取到父类中)

2.2权限修饰符

权限修饰符
    用来限制类中的成员（成员变量、成员方法、构造器、代码块…）能够被访问的范围。

种类和作用
    private:    本类
    缺省:       本类、本包类
    protected:  本类、本包类、子孙类
    private:    任意类

2.3单继承&Object类

Java中继承的特点
    Java只支持单继承,不支持多继承,但是支持多层继承

为什么Java不支持多继承
    如果一个Java类继承了多个父类, 而多个父类中右恰好有一样的方法, 代码会产生冲突

Object类
    Object类是Java中所有类的祖宗类,我们写的任何一个类,都是Object的子类或子孙类
    也就是说:java中所有的类都直接或间接的继承Object类(只要我们的类不明确使用extends继承类,那么它就默认继承Object)

2.4方法重写

方法重写
    当子类觉得从父类中继承到的某个方法不好用，或者无法满足自己的需求时
    子类可以重写一个方法名称、参数列表一样的方法，去覆盖掉继承到的这个方法，这就是方法重写
    注意：重写后，方法的访问会遵循就近原则

注意事项:
    1. 在重写的方法上标注Override注解，可以指定java编译器，检查我们方法重写的格式是否正确
    2. 子类重写父类方法时，访问权限必须大于或者等于父类该方法的权限（ public > protected > 缺省 ）
    3. 重写的方法返回值类型，必须与被重写方法的返回值类型一样，或者范围更小。
    4. 私有方法、静态方法不能被重写，如果重写会报错的。

应用场景
    重写toString来展示对象中的属性

public class Demo {
    public static void main(String[] args) {
        Son son = new Son();
        //son.makeFriend();
        son.setName("张三");
        son.setAge(18);
        System.out.println(son);
    }
}
class Father{
    //交朋友
    public Father makeFriend(){
        System.out.println("正在通过写信的方式交朋友~~~");
        return null;
    }
}
class Son extends Father{
    private String name;
    private int age;
    @Override
    public String toString() {
        return "Son{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    //交朋友
    public Father makeFriend(){
        System.out.println("正在");
        return null;
    }
}

2.5子类中访问其他成员的特点

父子类下访问成员的顺序
    1、在子类方法中访问其他成员（成员变量、成员方法），是依照就近原则的。
        子类局部-->子类成员-->父类成员
    2、两个关键字
        强行访问子类的成员： this
        强行访问父类的成员： super

public class Demo {
    public static void main(String[] args) {
        Son son = new Son();
        son.show();
    }
}
class Father {
    //父类成员
    int num = 10;
}
class Son extends Father {
    //子类成员
    int num = 20;
    public void show() {
        //子类局部
        int num = 30;
        System.out.println(num);
        System.out.println(this.num);
        System.out.println(super.num);
    }
}

2.6子类构造器的特点

子类构造器的特点
    子类的全部构造器，都会先调用父类的构造器，再执行自己。

子类构造器是如何实现调用父类构造器的：
    默认情况下，子类全部构造器的第一行代码都是 super() （写不写都有） ，它会调用父类的无参数构造器。
    如果父类没有无参数构造器，则我们必须在子类构造器的第一行手写super(...)，指定去调用父类的有参数构造器。

2.7子类构造器调用父类构造器的应用场景

我们经常在子类构造器中调用父类的有参构造器给父类传递参数来完成父类对象的初始化

public class Demo {
    public static void main(String[] args) {
        //需求: 使用Teacher的带参数构造创建对象,并对三个属性赋值
        Teacher teacher = new Teacher("张三",18,"讲课");
        System.out.println(teacher.getName());
        System.out.println(teacher.getAge());
        System.out.println(teacher.getSkill());
    }
}
class People {
    private String name;
    private int age;
    public People() {
    }
    public People(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}
class Teacher extends People {
    private String skill;
    public Teacher() {
    }
    public Teacher(String name,int age,String skill){
        super(name, age);
        this.skill = skill;
    }
    public String getSkill() {
        return skill;
    }
    public void setSkill(String skill) {
        this.skill = skill;
    }
}

2.8this调用兄弟构造器

this()
    任意类的构造器中，是可以通过this(…) 去调用该类的其他构造器的。

注意事项
    this(…) 、super(…) 都只能放在构造器的第一行，因此，有了this(…)就不能写super(…)了，反之亦然。

public class Demo {
    public static void main(String[] args) {
        //需求: 通过够全参构造创建对象并完成初始化
        Student stu1 = new Student("张三", 18);
        //需求: 如果用户没有指定学校, ,默认学校为"黑马程序员顺义校区"
        System.out.println(stu1);
        Student student = new Student("李四", 20);
        System.out.println(student);
    }
}
class Student {
    private String name;
    private int age;
    private String school;
    public Student() {
    }
    public Student(String name, int age) {
        this(name, age, "moren");
    }
    public Student(String name, int age, String school) {
        this.name = name;
        this.age = age;
        this.school = school;
    }
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", school='" + school + '\'' +
                '}';
    }
}

总结

以上就是第一天学习的内容，本文介绍了静态和继承的概念以及一些相关的用法。

filthy555

关注

34
点赞
踩
13

收藏

觉得还不错? 一键收藏
0
评论
每日总结Day01

每日总结Day01静态&继承1.静态1.1成员变量1.2类变量的应用场景1.3成员方法1.4成员方法的应用场景1.5注意事项1.6代码块2.继承2.1语法2.2权限修饰符2.3单继承&Object类2.4方法重写2.5子类中访问其他成员的特点2.6子类构造器的特点2.7子类构造器调用父类构造器的应用场景2.8this调用兄弟构造器
复制链接

扫一扫