Java的三大特性 其实也很简单把？！

最新推荐文章于 2024-07-21 22:27:18 发布
最新推荐文章于 2024-07-21 22:27:18 发布
阅读量136 收藏
点赞数
分类专栏： java路 文章标签： java 多态 面向对象编程 编程语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44939430/article/details/115362091
版权

文章目录

Java的三大特性 其实也很简单把？！

封装

/**
白话：该露的露，该藏的藏
	制造厂家为了方便我们使用电视，把复杂的内部细节全部封装起来，只给我们暴露简单的接· 口，比如：电源开关。需要让用户知道的暴露出来，不需要让用户了解的全部隐藏起来。这就是封装。
	
专业：
	我们程序设计要追求“高内聚，低耦合”。高内聚就是类的内部数据操作细节自己完成，不允许外部干涉；低耦合：仅暴露少量的方法给外部使用。
**/
1、封装的步骤

    1. 使用private 修饰需要封装的成员变量。

    2. 提供一个公开的方法设置或者访问私有的属性

      设置 通过set方法，命名格式： set属性名（）; 属性的首字母要大写
      访问 通过get方法，命名格式： get属性名（）; 属性的首字母要大写

      //对象能在类的外部"直接"访问
public class Student{
  public String name;//留意public
  public void println(){
    System.out.println(this.name);
 }
}
public class Test{
  public static void main(String[] args){
    Student s = new Student();
    s.name = "tom";
 }
}

//在类中一般不会把数据直接暴露在外部的,而使用private(私有)关键字把数据隐藏起来
public class Student{
  private String name;//留意private
}
public class Test{
  public static void main(String[] args){
    Student s = new Student();
    //编译报错,在类的外部不能直接访问类中的私有成员
    s.name = "tom";
 }
}

/* 
如果在类的外部需要访问这些私有属性,那么可以在类中提供对于的get和set方法,以便让用户在类的外部可以间接的访问到私有属性
*/
//set负责给属性赋值
//get负责返回属性的值
public class Student{
  private String name;
  public void setName(String name){
    this.name = name;
 }
  public String getName(){
    return this.name;
 }
}
public class Test{
  public static void main(String[] args){
    Student s = new Student();
    s.setName("tom");
    System.out.println(s.getName());}
}
2、作用和意义
  1. 提高程序的安全性，保护数据。
  2. 隐藏代码的实现细节
  3. 统一用户的调用接口
  4. 提高系统的可维护性
  5. 便于调用者调用。

良好的封装：便于修改内部代码，提高可维护性；可进行数据完整性检测，保证数据的有效性。

3、方法重载

​ 类中有多个方法,有着相同的方法名,但是方法的参数各不相同,这种情况被称为方法的重载。 方法的重载可以提供方法调用的灵活性。

条件：

  1. 方法名必须相同

  2. 参数列表必须不同(参数的类型、个数、顺序的不同)

  3. public void test(Strig str){}
public void test(int a){}
public void test(Strig str,double d){}
public void test(Strig str){}
public void test(Strig str,double d){}
public void test(double d,Strig str){}

继承 extends

1、继承

为什么需要继承？继承的作用？

第一好处：继承的本质在于抽象。类是对对象的抽象，继承是对某一批类的抽象。
第二好处：为了提高代码的复用性

【注】JAVA中类只有单继承，没有多继承！ 接口可以多继承！

public class student extends Person{
    //student is a person
	//dog is a animal
}
/**
1. 继承是类和类之间的一种关系。除此之外,类和类之间的关系还有依赖、组合、聚合等。
2. 继承关系的俩个类，一个为子类(派生类),一个为父类(基类)。子类继承父类,使用关键字extends来表示。
3. 子类和父类之间,从意义上讲应该具有"is a"的关系.
4. 类和类之间的继承是单继承
5. 父类中的属性和方法可以被子类继承
	子类中继承了父类中的属性和方法后,在子类中能不能直接使用这些属性和方法,是和这些属性和方法原有的修饰符(public protected default private)相关的。
	例如 :
		父类中的属性和方法使用public修饰,在子类中继承后"可以直接"使用
		父类中的属性和方法使用private修饰,在子类中继承后"不可以直接"使用
	父类中的构造器是不能被子类继承的,但是子类的构造器中,会隐式的调用父类中的无参构造器(默认使用super关键字)。
**/

2、Object类

/**
java中的每一个类都是"直接" 或者 "间接"的继承了Object类.所以每一个对象都和Object类有"is a"的关系。从API文档中,可以看到任何一个类最上层的父类都是Object。(Object类本身除外)AnyClass is a Object
**/
System.out.println(任何对象 instanceof Object);
//输出结果:true
//注:任何对象也包含数组对象
//例如:
//编译后,Person类会默认继承Object
public class Person{}
//Student是间接的继承了Object
public class Student extends Person{}
/**
在Object类中,提供了一些方法被子类继承,那么就意味着,在java中,任何一个对象都可以调用这些被继承过来的方法。(因为Object是所以类的父类)
	例如:toString方法、equals方法、getClass方法等
注:Object类中的每一个方法之后都会使用到**/

3、Super关键字

简单来说：子类继承父类之后,在子类中可以使用this来表示访问或调用子类中的属性或方法,使用super就表示访问或调用父类中的属性和方法

1. super的使用
//①
public class Person{//【访问父类中的属性】
  protected String name = "zs";
}
public class Student extends Person{
  private String name = "lisi";
  public void tes(String name)t{
    System.out.println(name);
    System.out.println(this.name);
    System.out.println(super.name);//访问父类中的属性
 }
}
//②
public class Person{//【调用父类中的方法】
  public void print(){
    System.out.println("Person");
 }
}
public class Student extends Person{
  public void print(){
    System.out.println("Student");
 }
  public void test(){
    print();
    this.print();
    super.print();//调用父类中的方法
 }
}
//③
public class Person{//【调用父类中的构造器】
}
public class Student extends Person{
  //编译通过,子类构造器中会隐式的调用父类的无参构造器
  //super();
  public Student(){
 }
}

public class Person{
  protected String name;
  public Person(String name){ 
    this.name = name;
 }
}
//④
public class Student extends Person{//【显式的调用父类的有参构造器】
  //编译通过,子类构造器中显式的调用父类的有参构造器
  public Student(){
    super("tom");//显式的调用父类的有参构造器
 }
}
//注：不管是显式还是隐式的父类的构造器,super语句一定要出现在子类构造器中第一行代码。所以this和super不可能同时使用它们调用构造器的功能,因为它们都要出现在第一行代码位置

【super使用的注意的地方】

  1. 用super调用父类构造方法，必须是构造方法中的第一个语句。
  2. super只能出现在子类的方法或者构造方法中。
  3. super 和 this 不能够同时调用构造方法。（因为this也是在构造方法的第一个语句）

【super 和 this 的区别】

  1. 代表的事物不一样:
    this：代表所属方法的调用者对象。

    super：代表父类对象的引用空间。

  2. 使用前提不一致：
    this：在非继承的条件下也可以使用。

    super：只能在继承的条件下才能使用。

  3. 调用构造方法：

    this：调用本类的构造方法。

    super：调用的父类的构造方法

4、方法重写 override（要区别与 封装 里的重载）

先问 why：
子类继承父类,继承了父类中的方法,但是父类中的方法并不一定能满足子类中的功能需要,所以子类中需要把方法进行重写

/**
override
1. 方法重写只存在于子类和父类(包括直接父类和间接父类)之间。在同一个类中方法只能被重载，不能被重写.
2. 静态方法不能重写
	1. 父类的静态方法不能被子类重写为非静态方法 //编译出错
	2. 父类的非静态方法不能被子类重写为静态方法；//编译出错
	3. 子类可以定义与父类的静态方法同名的静态方法(但是这个不是覆盖
**/
//A类继承B类 A和B中都一个相同的静态方法test

B a = new A();
a.test();//调用到的是B类中的静态方法test
A a = new A();
a.test();//调用到的是A类中的静态方法test
//可以看出静态方法的调用只和变量声明的类型相关，这个和非静态方法的重写之后的效果完全不同
重写规则：
  1. 方法名必须相同
  2. 参数列表必须相同
  3. 访问控制修饰符可以被扩大,但是不能被缩小： public protected default private
  4. 抛出异常类型的范围可以被缩小,但是不能被扩大ClassNotFoundException —> Exception
  5. 返回类型可以相同,也可以不同,如果不同的话,子类重写后的方法返回类型必须是父类方法返回类型的子类型
    例如：父类方法的返回类型是Person,子类重写后的返回类可以是Person也可以是Person的子类型
    注：一般情况下,重写的方法会和父类中的方法的声明完全保持一致,只有方法的实现不同。(也就是大括号中代码不一样)
public class Person{
  public void run(){}
  protected Object test()throws Exception{
    return null;}
}
//编译通过,子类继承父类,重写了run和test方法.
public class Student extends Person{
  public void run(){}
  public String test(){
    return "";
 }
}
/**
1. override总结：
方法重写的时候，必须存在继承关系。
方法重写的时候，方法名和形式参数 必须跟父类是一致的。
方法重写的时候，子类的权限修饰符必须要大于或者等于父类的权限修饰符。( private < protected <
public，friendly < public )
方法重写的时候，子类的返回值类型必须小于或者等于父类的返回值类型。( 子类 < 父类 ) 数据类型没有
明确的上下级关系
方法重写的时候，子类的异常类型要小于或者等于父类的异常类型。**/

多态

"咩叫"多态：多态性是OOP中的一个重要特性，主要是用来实现动态联编的，换句话说，就是程序的最终状态只有在执行过程中才被决定而非在编译期间就决定了。

多态可以让我们不用关心某个对象到底是什么具体类型，就可以使用该对象的某些方法，从而实现更加灵活的编程，提高系统的可扩展性。

Demo

相同类域的不同对象,调用相同的方法,执行结果是不同的
  //  1. 一个对象的实际类型是确定的
    new Student(); new Person();等
  //  2. 可以指向对象的引用的类型有很多，一个对象的实现类型虽然是确定的,但是这个对象所属的类型可能有很多种。 
    //Person和Object都是Student的父类型
    Student s1 = new Student();
	Person s2  = new Student();
	Object s3  = new Student();
Xxxx xx  = new Sxxxx();//Xxxx 该对象引用的类型 ；xx : 对象  ；  Sxxxx： 实际类型
注:一个对象的实际类型是确定,但是可以指向这个对象的引用的类型,却是可以是这对象实际类型的任意父类型。
1. 一个父类引用可以指向它的任何一个子类对象
Object o = new AnyClass();
Person p = null;
p = new Student();
p = new Teacher();
p = new Person();
2. 多态中的方法调用

①子类继承父类,调用a方法，如果a方法在子类中没有重写,那么就是调用的是子类继承父类的a方法,如果重写了,那么调用的就是重写之后的方法

public class Person{
  public void run(){
       System.out.println("fu");
  }
}
public class Student extends Person{
}
//调用到的run方法,是Student从Person继承过来的run方法
//main:
Person p = new Student();
p.run();//结果 fu   ， 如果student中 有重写run 方法 则结果是调用了Student中的run方法 而不是Person中的run

​ ②一个变量x,调用一个方法test,编译器是否能让其编译通过,主要是看声明变量x的类型中有没有定义test方法,如果有则编译通过,如果没有则编译报错.而不是看x所指向的对象中有没有test方法.

//子类中独有方法的调用
public class Person{
  public void run(){}
}
public class Student extends Person{
  public void test(){
 }
}
main:
Person p = new Student();
//调用到继承的run方法
p.run();
//编译报错,因为编译器检查变量p的类型是Person,但是在Person类中并没有发现test方法,所以编译报错.
p.test();
//原理：编译看左边，运行不一定看右边
/**
编译看左边的意思：java 编译器在编译的时候会检测引用类型中含有指定的成员，如果没有就会报错。
子类的成员是特有的，父类的没有的，所以他是找不到的。**/
总结：子类引用和父类引用指向对象的区别
Student s = new Student();
Person p = new Student();

变量s能调用的方法是Student中有的方法(包括继承过来的),变量p能调用的方法是Person中有的方法(包括继承过来的)。

但是变量p是父类型的,p不仅可以指向Student对象,还可以指向Teacher类型对象等,但是变量s***只能***指Studnet类型对象,及Student子类型对象。变量p能指向对象的范围是比变量s大的。
Object类型的变量o,能指向所有对象,它的范围最大,但是使用变量o能调用到的方法也是最少的,只能调用到Object中的声明的方法,因为变量o声明的类型就是Object.
注：java中的方法调用,是运行时动态和对象绑定的,不到运行的时候,是不知道到底哪个方法被调用的。

3、多态的注意事项

  1. 多态是方法的多态，属性没有多态性。

  2. 编写程序时，如果想调用运行时类型的方法，只能进行类型转换。不然通不过编译器的检查。但是
    如果两个没有关联的类进行强制转换，会报：ClassCastException。 比如：本来是狗，我把它转成猫。就会报这个异常。

    补充：
重写、重载和多态的关系
	重载是编译时多态
		调用重载的方法,在编译期间就要确定调用的方法是谁,如果不能确定则编译报错 
	重写是运行时多态
		调用重写的方法,在运行期间才能确定这个方法到底是哪个对象中的。这个取决于		调用方法的引用,在运行期间所指向的对象是谁,这个引用指向哪个对象那么调用		的就是哪个对象中的方法。(java中的方法调用,是运行时动态和对象绑定的)
		
补充again
既然多态存在必须要有“子类重写父类方法”这一条件，那么以下三种类型的方法是没有办法表现出多态特性的（因为不能被重写）：
	1. static方法，因为被static修饰的方法是属于类的，而不是属于实例的
	2. final方法，因为被final修饰的方法无法被子类重写
	3. private方法和protected方法，前者是因为被private修饰的方法对子类不可	见，后者是因为尽管被protected修饰的方法可以被子类见到，也可以被子类重写，	但是它是无法被外部所引用的，一个不能被外部引用的方法，怎么能谈多态呢

  3. 多态的存在要有3个必要条件：要有继承，要有方法重写，父类引用指向子类对象

4、多态存在的条件
  1. 有继承关系
  2. 子类重写父类方法
  3. 父类引用指向子类对象
5、方法绑定(method binding)

执行调用方法时，系统根据相关信息，能够执行内存地址中代表该方法的代码。分为静态绑定和动态绑定

静态绑定：
在编译期完成，可以提高代码执行速度。
动态绑定：
通过对象调用的方法，采用动态绑定机制。这虽然让我们编程灵活，但是降低了代码的执行速度。这也是JAVA比C/C++速度慢的主要因素之一。JAVA中除了final类、final方、static方法，所有方法都是JVM在运行期才进行动态绑定的。

多态：如果编译时类型和运行时类型不一致，就会造成多态。

6、instanceof和类型转换
1. instanceof
public class Person{
  public void run(){}
}
public class Student extends Person{
}
public class Teacher extends Person{
}

main:
Object o = new Student();
System.out.println(o instanceof Student);//true
System.out.println(o instanceof Person);//true
System.out.println(o instanceof Object);//true
System.out.println(o instanceof Teacher);//false
System.out.println(o instanceof String);//false
\---------------------------
Person o = new Student();
System.out.println(o instanceof Student);//true
System.out.println(o instanceof Person);//true
System.out.println(o instanceof Object);//true
System.out.println(o instanceof Teacher);//false
//编译报错
System.out.println(o instanceof String);    
\---------------------------
  Student o = new Student();
System.out.println(o instanceof Student);//true
System.out.println(o instanceof Person);//true
System.out.println(o instanceof Object);//true
//编译报错
System.out.println(o instanceof Teacher);
//编译报错
System.out.println(o instanceof String);

//【分析1】
System.out.println(x instanceof Y);
该代码能否编译通过,主要是看声明变量x的类型和Y是否存在子父类的关系.有"子父类关"系就编译通过,没有子父类关系就是编译报错.
之后学习到的接口类型和这个是有点区别的
 //【分析2】
    System.out.println(x instanceof Y);
输出结果是true还是false,主要是看变量x所指向的对象实际类型是不是Y类型的"子类型".
 main:
Object o = new Person();
System.out.println(o instanceof Student);//false
System.out.println(o instanceof Person);//true
System.out.println(o instanceof Object);//true
System.out.println(o instanceof Teacher);//false
System.out.println(o instanceof String);//false
2. 类型转换
public class Person{
  public void run(){}
}
public class Student extends Person{
  public void go(){}
}
public class Teacher extends Person{
}

//【为什么要类型转换】

	//①编译报错,因为p声明的类型Person中没有go方法
Person p = new Student();
p.go();
	//需要把变量p的类型进行转换
	Person  p = new Student();
	Student s = (Student)p;
	s.go();
或者
	//注意这种形式前面必须要俩个小括号
	((Student)p).go();  
===========================================================
//【类型转换中的问题】
即:
X x = (X)o;
运行是否报错,主要是变量o所指向的对象实现类型,是不是X类型的子类型,如果不是则运行就会报错。
//编译通过 运行没问题
Object o = new Student();
Person p = (Person)o;
----------
Object o = new Student();
Student s = (Student)o;
----------
    //编译通过,运行报错
Object o = new Teacher();
Student s = (Student)o;//运行是否报错,主要是变量o所指向的对象实现类型（Teacher）,是不是Student类型的子类型,如果不是则运行就会报错。
来个 繁冗的总结：

【总结】

1、父类引用可以指向子类对象，子类引用不能指向父类对象。 
				Father son = new Son();
2、把子类对象直接赋给父类引用叫upcasting向上转型，向上转型不用强制转型。
			如Father father = new Son();
3、把指向子类对象的父类引用赋给子类引用叫向下转型（downcasting），要强制转型。
	如father就是一个指向子类对象的父类引用，把father 赋给 子类引用son
				即Son son =（Son）father；
			其中father前面的（Son）必须添加，进行强制转换。
4、upcasting（向上转型） 会丢失子类 特有 的方法,但是子类overriding 父类的方法，子类方法有效
5、向上转型的作用，减少重复代码，父类为参数，调有时用子类作为参数，就是利用了向上转型。这样使代码变得简洁。体现了JAVA的抽象编程思想。
我不是程序猿儿
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
访问类中私有属性的方式（两种）
我是狗蛋哥哥的博客
07-26 6493
1.首先要理解私有属性：    私有属性主要是指  Python中单下划线和双下划线的区别  （比较直白的意思是：） _x: 单前置下划线,私有化属性或方法，from somemoudle import *禁止导入,类对象和子类可以访问 __xx：双前置下划线,避免与子类中的属性命名冲突，无法在外部直接访问(名字重整所以访问不到) 接下来用代码解释： 2. class People(...
java三大特征_java三大特性是什么？
热门推荐
weixin_32838901的博客
02-12 1万+
java三大特性：1、封装，是指隐藏对象的属性和实现细节，仅对外提供公共访问方式；2、继承，从已有的类中派生出新的类，新的类能吸收已有类的数据属性和行为，并能扩展新的能力；3、多态，一个方法可以有多种实现版本，即“一种定义， 多种实现”。Java 三大特性，算是Java独特的表现，提到Java 的三大特性， 我们都会想到封装， 继承和多态 这是我们Java 最重要的特性。封装(Encapsulat...
类的成员变量不要定义在public中
qq_40967752的博客
03-28 1723
#include "Point.h" void Point::Set(int x, int y) { m_x = x; m_y = y; } void Point::SetX(int x) { m_x = x; } void Point::SetY(int y) { m_y = y; } int Point::GetX() { return m_x...
秋招总结------C++面试题总结四
努力成为Al风口的猪
03-22 419
1.C++中类成员的访问权限和继承权限问题 三种访问权限 public:用该关键字修饰的成员表示公有成员，该成员不仅可以在类内可以被 访问，在类外也是可以被访问的，是类对外提供的可访问接口； private:用该关键字修饰的成员表示私有成员，该成员仅在类内可以被访问，在类体外是隐藏状态； protected:用该关键字修饰的成员表示保护成员，保护成员在类体外同样是隐藏状态，但是对于该...
java 对象中必须有属性和方法_Java反射机制（三）：调用对象的私有属性和方法...
weixin_36368715的博客
02-13 1414
一、 通过反射调用类中的方法在正常情况下，得到类的对象后，我们就可以直接调用类中的方法了，如果要想调用的话，则肯定必须清楚地知道要调用的方法是什么，之后通过Class类中的getMethod方法，可得到Method对象。publicMethodgetMethod(Stringname,Class>...parameterTypes)throws NoSuchMethodExcepti...
java 运行时绑定,Java中的绑定和分派有什么区别？
weixin_39976413的博客
02-25 75
There are too many associated names: Early and Late Binding, Static and Dynamic Dispatch, Runtime vs. Compile-time Polymorphism, etc. that I don't understand the difference.I found a clear explanation...
java三大科技
09-14
Java三大技术指的是Hibernate、Struts和Spring，它们是Java开发中的关键框架，常用于构建企业级Web应用程序。这些框架各自负责不同的职责，协同工作以提高开发效率和代码可维护性。 1. Hibernate：这是一个对象关系...
先解压！humbnailator-0.4.2.jar 很好用很强大的java图像处理工具，免费分享给大家，文件名称已被我更改，但是不影响使用
12-17
thumbnailator库还提供了很多高级特性，比如批量处理、自定义处理器、读取和写入流以及保持图像比例等。在处理大量图像或者需要自定义复杂操作的场景下，thumbnailator的灵活性和性能表现都非常出色。 总的来说，...
java02——Java概述
08-12
答：编译的动作其实就是翻译，把操作系统看不懂的内容变成操作系统能看懂的内容->产生新的class文件（字节码文件） 3）①Java SE： Java 语言的标准版，用于桌面应用的开发，是其他两个版本的基础； ②Java ME：...
Snake:Java上的简单Snake游戏
04-28
《Snake:Java上的简单Snake游戏》 这是一款基于Java编程语言开发的经典Snake游戏。Snake游戏，也被称为贪吃蛇，是电子游戏历史上的一个标志性作品，以其简单的规则和上瘾的游戏性深受玩家喜爱。在这个Java版本中，...
JAVA上百实例源码以及开源项目
01-03
　用JAVA编写的指针式圆形电子钟，效果图如下所示，其实代码很简单，希望对你有帮助。 Message-Driven Bean EJB实例源代码 2个目标文件 摘要:Java源码,初学实例,EJB实例 　Message-Driven Bean EJB实例源代码，演示...
redis+spring面试题
github_36510643的博客
07-21 152
redis+spring面试题
Java-Lambda
最新发布
lizhiwei21的博客
07-21 139
lambda表达式可以理解为对匿名内部类的一种简化 , 但是本质是有区别的面向对象思想 :强调的是用对象去完成某些功能函数式编程思想 :强调的是结果 , 而不是怎么去做。
Promise 详解（原理篇）
山重水复疑无路，柳暗花明又一村。
07-20 486
Promise 是一种异步编程的解决方案。在异步操作中，callback 会导致回调地狱的问题，Promise 解决了这个问题。一个 Promise对象有以下三种状态:pending：初始状态，既不是成功，也不是失败状态。：意味着操作成功完成。rejected：意味着操作失败。当 new Promise() 被实例化后，即表示 Promise 进入 pending 初始化状态，准备就绪，等待运行。
接口防刷！利用redisson快速实现自定义限流注解
架构师小吴的博客
07-18 1126
如登录接口，当用户使用手机号+验证码登录时，一般我们会生成6位数的随机验证码，并将验证码有效期设置为1-3分钟，如果对登录接口不加以限制，理论上，通过技术手段，快速重试100000次，即可将验证码穷举出来。解决思路：对登录接口加上限流操作，如限制一分钟内最多登录5次，登录次数过多，就返回失败提示，或者将账号锁定一段时间。在日常开发中，一些重要的对外接口，需要加上访问频率限制，以免造成资��损失。ok，通过以上两步，即可完成我们的限流注解了，下面通过一个接口验证下效果。
JVM-垃圾回收与内存分配
m0_50846237的博客
07-19 1121
JVM-垃圾回收与内存分配
java算法day19
TOMOT77的博客
07-20 174
我第一时间想到的方法是遍历二叉树+哈希。哈希用来统计数字出现的次数。之后遍历map收集结果。利用了BST的性质，即BST的中序序列是有序序列。
【Java算法】前缀和 下
2302_79806056的博客
07-18 1048
这段代码实现了一个寻找数组中具有相等数量的0和1的最长子数组长度的算法。具体来说，它使用了前缀和（prefix sum）的概念以及哈希映射（HashMap）来优化查找过程。初始化哈希映射：计算前缀和：检查相等数量的0和1：更新哈希映射：返回结果：这种方法的时间复杂度为O(n)，因为我们只遍历数组一次，并且对每个元素执行常数时间的操作。空间复杂度也是O(n)，最坏情况下需要存储n个前缀和值。 初始化阶段:开始遍历数组:继续
华为OD机试 - 分披萨 - 递归（Java 2024 D卷 200分）
学Java，找哪吒
07-21 500
递归算法通过函数调用自身解决问题，每次递归调用都处理问题的一个子部分，直到达到基准条件，从而构建最终解。
Java入门教程：PPT版535页详述
在【21天学通JAVA.pdf 其实是PPT】这份教程中，我们首先接触到的是Java语言的基础知识。Java作为一种广泛应用于网络编程的语言，以其简洁性、灵活性、面向对象、跨平台和安全性等特性受到青睐。它分为三个主要版本：...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值