首页 > 其他分享 >封装 static静态关键字 可变参数 递归

封装 static静态关键字 可变参数 递归

时间:2024-07-23 13:54:46浏览次数:17  
标签:调用 封装 name 递归 System static public String

一.封装

1.this

1.当成员变量和局部变量重名时,调用遵循"就近原则",先调用局部的

2.this代表的是当前对象,哪个对象调用this所在的方法,this就代表哪个对象

3.作用:区分重名的成员变量和局部变量(this后面肯定是成员的)

public class Person {
    String name;

    /**
     * 哪个对象调用的this所在的方法
     * this就代表哪个对象
     * @param name
     */
    public void speak(String name){
        System.out.println(this+"........this");
        System.out.println(this.name+"您好,我是"+name);
    }
}

public class Test01 {
    public static void main(String[] args) {
        Person person = new Person();
        System.out.println(person+".....person");
        person.name = "张三";
        person.speak("李四");

        System.out.println("===============");

        Person person1 = new Person();
        System.out.println(person1+".........person1");
        person1.name = "王五";
        person1.speak("赵六");
    }
}
image-20240723115436575

2.构造方法

1.空参构造方法

  • new对象使用
  • 没有返回值,没有void,方法名和类名一致
  • new就调用,构造方法会自动执行
public person(){

}

每一个类jvm都会给一个默认的空参构造,不写也有

2.有参构造方法

  • new对象使用
  • 为属性赋值
  • jvm不会提供有参构造,需要自己写
  • 如果写了有参构造,jvm不再提供空参构造,需要自己补上去
public person(参数){
	为属性赋值
}
    //空参构造
    public Person(){

    }

    //有参构造
    public Person(String name,int age){
        this.name = name;
        this.age = age;
    }

3.标准javabean

1.具有私有成员变量

2.有空参和有参构造方法

3.有get set方法

4.类必须是具体的(非抽象 abstract)和公共的,public class 类名

public class Person {
    private String name;
    private int age;

    //无参构造
    public Person(){

    }

    //有参构造
    public Person(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;
    }
}

二.static关键字

1.可以修饰一个成员变量,还可以修饰一个方法

2.特点

  • 被static修饰的成员随着类的加载而加载
  • 被static修饰的成员由于跟着类到内存,所以优先于对象存在
  • 被static修饰的成员属于类成员,不属于对象成员(成员方法,成员变量)
  • 根据static所在的类创建出来的对象,都会共享这个静态成员

3.使用

  • 修饰成员变量: static 数据类型 变量名
  • 修饰方法:
    修饰符 static 返回值类型 方法名(参数){
    方法体
    return 结果
    }

4.调用

  • 类名直接调用
image-20240626154023716
public class Student {
    String name;
    static String classRoom;

    //静态的方法
    public static void study(){
        System.out.println("学生要学习");
    }
}

public class Test01 {
    public static void main(String[] args) {
        //类名直接调用
        Student.classRoom = "222";


        Student s1 = new Student();
        s1.name = "张三";
        //s1.classRoom = "222";
        System.out.println(s1.name);
        System.out.println(s1.classRoom);

        //类名直接调用
        Student.study();

        System.out.println("====================");

        Student s2 = new Student();
        s2.name = "李四";
        //s2.classRoom = "222";
        System.out.println(s2.name);
        System.out.println(s2.classRoom);

        //类名直接调用
        Student.study();
    }
}

1.static修饰成员访问特点

  • 非静态的能直接访问静态成员

    a.在同一个类中:直接调用,类名调用(实际上是直接调用),new对象调用(即使new对象调用的实际上也是直接调用的)

    b.不在同一个类中:类名调用,new对象调用(实际上也是类名直接调用)

image-20240626160312655
  • 静态的能直接访问非静态成员

    ​ 不能-> 静态成员随着类的加载而加载优先于非静态成员产生

    ​ 但是new对象可以访问非静态成员

  • 非静态能直接访问非静态成员

    a.在同一个类中:直接调用,new对象调用

    b.不在同一个类中:new对象调用

  • 静态的能直接访问静态成员

    a.在同一个类中:直接调用,类名调用,new对象调用

    b.不在同一个类中:类名调用,new对象调用

总结:

1.不管在不在同一个类中,只要是访问静态的:都可以使用类名点

2.不管在不在同一个类中,只要是访问非静态的:都可以new对象调用

补充:

  • 静态成员随着类的加载而加载,如果所有成员都变成静态的,会过多的占用内存

  • 1.共享数据 2.抽取工具类时 可以使用静态方法

public class ArraysUtils {
 //工具类不需要new对象调用,只需要类名调用,所以我们可以将构造方法变成私有的
 private ArraysUtils(){
 }

 public static void print(int[] arr){
     System.out.print("[");
     for (int i = 0; i < arr.length; i++) {
         if (i==arr.length-1){
             System.out.print(arr[i]+"]");
         }else{
             System.out.print(arr[i]+", ");
         }
     }
 }
}
public class Test02 {
 public static void main(String[] args) {
     int[] arr = {1,2,3,4,5};
     ArraysUtils.print(arr);
 }
}
public class Test03 {
 public static void main(String[] args) {
     int[] arr = {1,2,3,4,5,5,6,89,7,8,8,64};
     ArraysUtils.print(arr);
 }
}

三.可变参数

修饰符 返回值类型 方法名(非可变参数形参列表,参数类型. . . 形参名)

其实这个书写约等于

修饰符 返回值类型 方法名(非可变参数形参列表,参数类型[] 形参名)

  • 一个方法最多有一个可变参数
  • 如果一个方法包含可变参数,那么可变参数必须是形参列表的最后一个

例:n个字符串进行拼接,每一个字符串之间使用某字符进行分隔,如果没有传入字符串,那么返回空字符串""

public class Demo03{
    public static void main(String[] args) {
        String result = concat("-", "张无忌", "张翠山", "张三丰", "金毛狮王", "白眉鹰王", "青翼蝠王", "紫衫龙王");
        System.out.println("result = " + result);
    }

    public static String concat(String s, String... arr) {
        String str = "";
        for (int i = 0; i < arr.length; i++) {
            if (i == arr.length - 1) {
                str += arr[i];
            } else {
                str += arr[i] + s;
            }
        }
        return str;
    }
}

四.递归

  • 递归:指在当前方法内调用自己的这种现象。
  • 递归的分类:
    • 递归分为两种,直接递归和间接递归。
    • 直接递归称为方法自身调用自己。
    • 间接递归可以A方法调用B方法,B方法调用C方法,C方法调用A方法。
  • 注意事项
    • 递归一定要有条件限定,保证递归能够停止下来,否则会发生栈内存溢出(因为会不断的压栈)。
    • 在递归中虽然有限定条件,但是递归次数不能太多。否则也会发生栈内存溢出。

示例一:需求:利用递归输出3到1

public class Demo01 {
    public static void main(String[] args) {
        method(3);
    }

    public static void method(int n) {
        if(n==1){
            System.out.println(n);
            return;
        }
        System.out.println(n);
        n--;
        method(n);
    }
}

示例二:求n!

public class Demo02 {
    public static void main(String[] args) {
        int result = method(4);
        System.out.println("result = " + result);
    }

    private static int method(int n) {
        if(n==1){
            return 1;
        }else{
            return n*method(n-1);
        }

    }
}

标签:调用,封装,name,递归,System,static,public,String
From: https://blog.csdn.net/m0_73627305/article/details/140634246

相关文章

  • Pandas:递归的性能优化
    我有一个代码,看起来像forindex,rowindata.iterrows():data.loc[index,"myCol"]=someFunc(data.loc[index-1,"myCol")该代码正在使用递归,因此我无法对其进行矢量化,因为在许多与iterrows性能相关的问题中都建议使用递归。我在性能方面优化它的最佳方法是什......
  • 使用递归函数计算阶乘时,我在 python 中遇到类型错误
    defcalc_fact(n):如果(n==1或n==0):返回1别的:n*calc_fact(n-1)print(calc_fact(5))试图创建函数来计算阶乘,不支持类型错误操作数*:对于int或Nonetype我不知道为什么谢谢Python代码中出现“类型错误:不支持的操作数类型为*:'int'和'NoneType'”表明你......
  • android在一个TextView中设置不同字体大小、不同字体颜色封装
    一、概述在开发过程中遇到过这样一种业务,有很多单行文本字体。字符串中每一部分的字体样式、大小、颜色都不相同。传统的做法是放多个TextView以达到效果。但是当这个页面中的这样的元素非常多,且非常复杂的时候,就会出现页面加载缓慢的问题(view加载=深度(递归)+平铺),也就是......
  • python面向对象三大特性(继承、多态、封装)之继承
    来吧,下面来具体说一下面向对象的三大特性:所谓封装、多态和继承。我们先来说一下继承。所谓继承,顾名思义,子类继承父类的属性,包括数据属性和函数属性。写个简单的例子吧:1.简单的继承classAnimal:need_substance='water'def__init__(self):print('这是一......
  • C++ 学习笔记十一 封装
    封装4.1.1封装的意义封装是C++面向对象三大特性之一封装的意义:将属性和行为作为一个整体,表现生活中的事物将属性和行为加以权限控制封装意义一:​在设计类的时候,属性和行为写在一起,表现事物语法:class类名{访问权限:属性/行为};**示例1:**设计一个圆类,求圆的周......
  • 手写Kd树(C++模板非递归实现)
    手写Kd树(C++模板非递归实现)1.Kd树1.1Kd树简介1.2Kd树的建立1.3Kd树的查找2.C++完整代码实现3.测试代码3.1代码实现3.2测试结果4.与PCL中的Kd树做对比本文实现的Kd树实现参考了高翔博士的书《自动驾驶与机器人中的slam技术从理论到实践》;高博士原书中是递归......
  • (算法)合并两个有序链表————<递归>
    1.题⽬链接:21.合并两个有序链表 2.题⽬描述: 3.解法(递归):算法思路:1.递归函数的含义:交给你两个链表的头结点,你帮我把它们合并起来,并且返回合并后的头结点;2.函数体:选择两个头结点中较⼩的结点作为最终合并后的头结点,然后将剩下的链表交给递归函数去处理;3.递归出......
  • (算法)汉诺塔————<递归>
    1.题⽬链接:329.矩阵中的最⻓递增路径 2.题⽬描述:3.解法(暴搜->记忆化搜索):算法思路:这是⼀道递归⽅法的经典题⽬,我们可以先从最简单的情况考虑:•假设n=1,只有⼀个盘⼦,很简单,直接把它从A中拿出来,移到C上;•如果n=2呢?这时候我们就要借助B了,因为⼩盘⼦必须时刻都在⼤盘......
  • LocalStorage封装
    前言localStorage 使用是一个老生常谈的话题,本文不讲解基础 api,主要教你如何封装一个优雅的localStorage 工具,以及一些 localStorage中一些你不知道的知识点。优雅的 Storage 工具类如何封装(支持前缀key、加密存储、过期时间,ts封装等)localStorage 真实存储大小......
  • 函数的传参,递归函数,宏定义,头文件
    数组传递中,形参和实参操作的是同一个数组 1.带参宏#definePRINTF(x,y,z)do{\      printf("x=%d\n",x);\           printf("y=%d\n",y);\      printf("z=%d\n",z);\}while(0)\是连接字符,宏定义只能写成一行,\可以把两行连......