JAVA高级部分学习小结(2023.11.4)

简介: JAVA高级部分学习小结(2023.11.4)

一:对于static的认识

1:简单介绍:static实际上是一种修饰词语,大多数用作对于成员方法的一个静态化管理.

优点:将一个私有的变量转化为共享的数据,从而减少了代码的臃肿性,让代码看起来更加的简洁;

使用方法 :在需要进行修饰的变量类型的名称前进行修饰,如果对于成员方法进修修饰,需要在权限修饰符后面添加

2:使用特点

根据使用的对象的不同,大体可以分为两大类:

  1:对于成员变量的使用

对于成员变量进行修饰

1.能够让被修饰的成员变量变成一个在整个类当中所共享的一个东西,赋值一次所有的都会是这种的形式

2.能够变成被类名称.   比方说,在这里,类的名称是一个static01,再进行使用的时候,会提示是否使用这种变量,

而不用再新创建一个对象,使用对象来对其进行调用

3.在类被调用的时候,静态变量(也就是这里所提到的被static所修饰的成员变量)会首先加载出来,随着类的加载而加载,

直接在堆内存当中存在(相当于直接NEW了一次)

    2:对于成员方法的使用

关于成员方法的选择,我们应选择工具类型的,也就是说这个成员方法是可以对与

这个主方法进行协助的,除此之外没有其他的作用(打工人,打工魂)

上链接!

public static void main(String[] args){
        Scanner in=new Scanner(System.in);
        student stu=new student();
        stu.name="wang";
        stu.age=18;
        //在这里,已经知道了两个人是在同一个学校的,所以这个变量是可以确定是唯一的
        //在这个条件下,可知这个变量应该被共享,所以使用static
        student.school="嵩阳高中";
        System.out.println(stu.name+"-----"+student.school+"-----"+stu.age);
 
        student stu1=new student();
        stu1.age=19;
        stu1.name="王雷阳";
        //没有对与学校进行重新输入数值,在之前已经在输入过了一次,所以可以直接全部实现
        //共享
        System.out.println(stu1.name+"----"+student.school+"----"+stu1.age);
 
        //成员方法的static的使用
       //可以直接删除这一个变量类型,减少推内存的使用程度 student stu2=new student();
        int[] num={3,2,3};
        int max = student.getMax(num);
        System.out.println(max);
        int min = student.getMin(num);
        System.out.println(min);
        //以上两种求最大跟最小值也是可以运用同样的道理,直接只用类名称进行使用
        //如果对于这个遍历的方法进行static的修饰,那么也可以直接使用类的名称
        //直接进行调用
        student.getOrder(num);
 
        //当所有的成员方法都被修饰的时候,可以对于这个类型直接进行全部的修饰
        //目的是为了防止创建一个新的对象,从而让内存的使用变小,减少内存的浪费使用
    }
}

背后代码(这里所写的代码都可以算作是一个工具性质的成员方法,仅供参考)

public class student {
    String name;
    int age;
    static String school;
 
 
    public static int getMax(int[] num){
        int max=num[0];
        for (int i = 1; i < num.length; i++) {
            if(max<num[i]){
                max=num[i];
            }
        }
        return max;
    }
 
    public static int getMin(int[] num){
        int min=num[0];
        for (int i = 1; i < num.length; i++) {
            if(min>num[i]){
                min=num[i];
            }
        }
        return min;
    }
 
    public static void getOrder(int[] num){
        System.out.print("[");
        for (int i = 0; i < num.length-1; i++) {
            System.out.print(+num[i]+", ");
        }
        System.out.println(num[num.length-1]+"]");
    }
 
}


二:继承

1.简单介绍:继承用通俗易懂的话来说就是儿子继承父亲的东西,父亲有什么东西,儿子也就会有什么,子承父业,而且可以是全部的继承

tips:需要注意的是,可以是全部的继承,是不包括在父类当中所包含的  "构造方法"  这一个是子类所不能够使用的,所以子类如果要使用构造方法需要自己再重新进行构造.而且在这里,即使是private修饰过的成员变量.子类依然是可以去继承的,只不过是自己的访问权限不够,因此不能够直接调用,但是!在堆内存当中新添加子类方法的时候,会直接在子类下创建一个相同地址的SUPER的.


优点:采用继承的方式能够让原本比较冗长的代码看起来更加的简单,从而让代码看起来更加"美观".减少内存的过分使用

2.使用特点

在继承了之后,父当中的任何成员变量,子类都可以进行使用

使用的情况,一般实在对于多个的类型之间


构造的方法

class zi extends fu{
}

注意:在使用继承的时候需要考虑使用的合理性,保证有一定的共性,

并且满足 is a的一个特点

tips(有关JAVABEAN的疑问):

那么,在这里会有一个很~~~大的疑问,哎!JAVABEAN当中,所有的成员变量不是最好都不让被人看到,也就是最好都进行私人话修饰,添加private吗?私人化之后,子类怎么再去使用?


GOOD 想的很好

在这里,解决方案其实很简单,既然成员变量被私人化,那我先在子类放置一个父类的带参构造方法,先在父类当中完成初始化,进行赋值,之后在父类当中直接创建一个GET方法,调用数据不就OK了

上链接!

manager in=new manager("王森",18);
        in.method();
 
        coder sc=new coder("孙雨生",19);
        sc.method();
    }
}
//创建父类
//需要考虑的一点是,在JAVABEAN当中,所有的成员变量都是要进行私有化的
/*
这个时候,子类不能直接调用,但是可以调用其中父类的获取方法!
 */
class empoler{
    private String name;
    private int age;
 
 
    //父类的带参构造方法
    public empoler(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;
    }
}
//这两个实际上都可以算作是代码当中的一部分,所以可以当作code的子类
class manager extends empoler{
    //构造方法
    public manager(String name,int age){
        //将变量值直接初始化给父类
        super(name,age);
    }
    public void method(){
        System.out.println(getAge()+"岁,叫做"+getName());
    }
 
 
}
 
class coder extends empoler{
 
    public coder(String name, int age) {
        super(name, age);
    }
    public void method(){
        System.out.println(super.getAge()+"岁,叫做"+super.getName());
    }
}

3.关于THIS跟SUPER

       1.this.通常适用于同一个类型当中,在一个构造方法当中,出现了一个与在同一个类当中的一个成员变量相同,如果要使用成员变量,那么就要使用this来进行使用,比较常见的使用方式有

class people{
    int name;
//使用构造方法的时候
    public  method(String name){
    this.name=name;    
}
}

      2.super.通常是使用在了继承的关系当中的,如果在子类当中有跟父类一样的变量名称,那么就可以使用super来直接调用父类当中的变量,如果不这样,那么就会遵循就近的原则,调用最近的成员方法以及相应的成员变量!(在tips的链接中有详细的情况,可以反复观看);

4.有关子类与父类的权限关系;

子类的关系跟父类的关系,在权限上,必须是子类>=父类,否则是不能够使用父类的

关于权限修饰符大小排序

private<(default)(默认值)<protected<public
 


三:final

1.简单介绍:final是一个JAVA当中的关键词,主要起到了固定具体类型数值的作用,自然也可以是一个成员方法

2.使用特点

根据使用场景的不同,大体分为三大类

1.成员变量:

凡是被FINAL所修饰的成员变量都必修要进行赋值,可以直接进行赋值,也可以在构造方法当中进行一个赋值,但是默认值是不可以的,在这里面默认值是一个无效值!

修饰过后,这个变量也就无法进行修改,只进行一次初始化就变成了一个常量(可以这样理解,但不是一个常量)

2.成员方法:

在这里,final也是可以对成员方法进行修饰的,一旦被修饰,比如说在继承关系当中,父类中的某个方法一旦被修饰,那么子类是不能够再调用父类的这个方法了

3.类

如果使用FINAL直接对类进行修饰,那么这个类将不能够作为一个父类存在,只能够成为一个子类!相当于一个太监,没有了孩子,但是仍然可以有父亲,可以当作一个子类来进行再次的使用

相关文章
|
18天前
|
Java
Calendar类在Java中的高级应用与使用技巧
Calendar类在Java中的高级应用与使用技巧
|
21天前
|
缓存 安全 Java
《volatile使用与学习总结:》多层面分析学习java关键字--volatile
《volatile使用与学习总结:》多层面分析学习java关键字--volatile
14 0
|
2天前
|
Java UED 开发者
Java中的异常处理:从基础到高级
【7月更文挑战第17天】Java的异常处理机制是其健壮性的关键所在,它允许程序在遇到错误时优雅地恢复或终止。本文将深入探讨Java的异常处理,从基本的try-catch-finally结构到更复杂的创建自定义异常类和异常链追踪。我们将通过具体代码示例来展示如何有效地处理异常,确保程序的稳定性和可靠性。
|
5天前
|
Java 调度 开发者
Java中的并发编程:从基础到高级
【7月更文挑战第14天】在Java的世界中,并发编程是提升应用性能和响应能力的关键。本文将带领读者从线程的基础概念出发,深入探讨Java内存模型,逐步过渡到高级并发工具类如Executors框架和并发集合,最后通过案例分析展示如何在实际开发中运用这些知识解决并发问题。文章旨在为初学者提供清晰的学习路径,同时为有经验的开发者提供深度参考。
14 4
|
6天前
|
NoSQL Java 应用服务中间件
Java高级面试题
Java高级面试题
|
18天前
|
安全 Java 网络安全
Java网络编程:高级应用与安全性探讨
Java网络编程:高级应用与安全性探讨
|
18天前
|
安全 Java 开发者
Calendar类在Java中的高级应用与使用技巧
Calendar类在Java中的高级应用与使用技巧
|
21天前
|
安全 Java 编译器
杭州 【Java基础知识 11】java泛型方法的定义和使用(学习+改进+自己理解,想法) (借鉴-侵-删)
杭州 【Java基础知识 11】java泛型方法的定义和使用(学习+改进+自己理解,想法) (借鉴-侵-删)
15 1
|
23天前
|
消息中间件 负载均衡 Java
学习Java中的反应式编程
学习Java中的反应式编程
|
1天前
|
Java 开发者 UED
Java中的异常处理:从基础到高级
本文将深入探讨Java的异常处理机制,从基本概念出发,逐步过渡到高级用法。我们将通过具体案例分析如何正确捕获和处理异常,并讨论如何设计自定义异常类来增强程序的健壮性。此外,文章还将介绍一些最佳实践,帮助开发者避免常见的陷阱,提高代码的可维护性和性能。
7 0