澳门太阳娱乐集团官网-太阳集团太阳娱乐登录

Java面向对象
分类:脚本专栏

图片 1

Java和iOS的面向对象大体上没有什么区别,有几点需要注意:

作者:丁明祥

刚开始学习Java的时候,一个人跌跌撞撞摸索着往前走,很多东西理解的也懵懵懂懂,后来实践的多了,才慢慢清楚;许多东西虽然很基础但是却很重要,是需要反复思考和加深理解的。分享一些归纳总结后的技术干货,一张图能搞定的事,绝对不长篇大论。

  1. 抽象类
  2. 接口类
  3. 多继承
  4. 重载

邮箱:2780087178@qq.com

大家都知道,Java面向对象是Java的一个核心,也是初学者的一个难点,所以我们从这里开始,Let’s go !

说起来这篇文章还没有写完的,不过前后已经浪费了很多时间写了删删了写,如果再不发出来就永远不能开始干下一件事了。

图片 2

package JavaObject;

public class Animal {
    private String name;
    private int id;

    public Animal(String myName, int myId) {
        name = myName;
        id = myId;
    }

    public void eat() {
        System.out.println(name + "正在吃");
    }

    public void sleep() {
        System.out.println(name + "正在睡");
    }

    public void introduction() {
        System.out.println("大家好 我是" + id + "号" + name);
    }
}

package JavaObject;

public class Mouse extends Animal {

    public Mouse(String myName, int myId) {
        super(myName, myId);
    }

    @Override
    public void eat() {
//        super.eat();
        System.out.println("A little mouse eating");
    }
}

0.编码风格

Java面向对象

对象

package JavaObject;

public class CustomObject implements CustomInterface {

    public int test(){
        System.out.println("test1");
        return 1;
    }

    public void test(int a){
        System.out.println("test2");
    }

    //以下两个参数类型顺序不同
    public String test(int a,String s){
        System.out.println("test3");
        return "returntest3";
    }

    public String test(String s,int a){
        System.out.println("test4");
        return "returntest4";
    }

    public void eat() {

    }

    public void travel() {

    }

    public static void main(String[] args) {
        Mouse mouse = new Mouse("Tom", 5);
        Penguin penguin = new Penguin("Gaff", 10);

        mouse.eat();
        mouse.sleep();
        mouse.introduction();

        /*
        重写是子类对父类的允许访问的方法的实现过程进行重新编写, 返回值和形参都不能改变。即外壳不变,核心重写!
        重写的好处在于子类可以根据需要,定义特定于自己的行为。 也就是说子类能够根据需要实现父类的方法。

        重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。
        例如: 父类的一个方法申明了一个检查异常 IOException,但是在重写这个方法的时候不能抛出 Exception 异常,
        因为 Exception 是 IOException 的父类,只能抛出 IOException 的子类异常。*/

        /*
        重载(overloading) 是在一个类里面,方法名字相同,而参数不同。返回类型可以相同也可以不同。

        每个重载的方法(或者构造函数)都必须有一个独一无二的参数类型列表。

        最常用的地方就是构造器的重载。

        重载规则
        被重载的方法必须改变参数列表(参数个数或类型或顺序不一样);
        被重载的方法可以改变返回类型;
        被重载的方法可以改变访问修饰符;
        被重载的方法可以声明新的或更广的检查异常;
        方法能够在同一个类中或者在一个子类中被重载。
        无法以返回值类型作为重载函数的区分标准。*/

        CustomObject o = new CustomObject();
        System.out.println(o.test());
        o.test(1);
        System.out.println(o.test(1, "test3"));
        System.out.println(o.test("test4", 1));

        /*
        抽象类总结规定

        1. 抽象类不能被实例化(初学者很容易犯的错),如果被实例化,就会报错,编译无法通过。只有抽象类的非抽象子类可以创建对象。

        2. 抽象类中不一定包含抽象方法,但是有抽象方法的类必定是抽象类。

        3. 抽象类中的抽象方法只是声明,不包含方法体,就是不给出方法的具体实现也就是方法的具体功能。

        4. 构造方法,类方法(用static修饰的方法)不能声明为抽象方法。

        5. 抽象类的子类必须给出抽象类中的抽象方法的具体实现,除非该子类也是抽象类。*/
    }
}

1.面向对象导论

《java编程思想》第1章

OO-思想,OO-设计,OO-编码

这一部分等我有了软件架构的思想之后再写,在没有足够项目经验的条件下写这些东西没有意义。

面向对象(Oriented Object)

接口

package JavaObject;

interface CustomInterface {
    public void eat();
    public void travel();
}

2.操作符和流程控制

《java编程思想》第3,4章

这一部分完全不写,所有的编程语言都涉及的,没有必要学习。

是相对于面向过程而言的,过程其实就是函数,对象是将函数和属性进行了封装。

package JavaObject;

public class CustomPackage {

    /*
    包的作用

    1、把功能相似或相关的类或接口组织在同一个包中,方便类的查找和使用。

    2、如同文件夹一样,包也采用了树形目录的存储方式。同一个包中的类名字是不同的,
    不同的包中的类的名字是可以相同的,当同时调用两个不同包中相同类名的类时,应该加上包名加以区别。
    因此,包可以避免名字冲突。

    3、包也限定了访问权限,拥有包访问权限的类才能访问某个包中的类。*/
}

3.类和对象

《java编程思想》第2,5,6,7章

  • 面向对象的主要特点是(抽象),封装,继承,多态。(所有初级面试都喜欢问)

将复杂的事情简单化。

1.用引用操作对象

Java中定义的变量除了基本类型变量以外,其他都是引用类型的变量。

用下面这个例子分清楚什么是引用什么是对象

String s = "aaa",String s = new String("aaa")

面向对象将以前的过程中的执行者,变成了指挥者。

2.存储到什么地方
  • 寄存器,这个东西在C/C++中更容易说明,他们直接跑在机器(Register Machine)硬件上,可以直接使用通用寄存器存储数据,因为Java虚拟机是栈机器(Stack Machine),没有寄存器,所以不详细介绍。
  • 栈,用堆栈指针移动来分配和释放内存。Java中的引用变量放在其中。
  • 堆,用于存放对象
  • 常量,java中的常量放在ROM中
  • 非RAM存储,一些数据(比如流,持久化对象)直接存放在媒介之上。

面向对象思想是符合人们思考习惯的一种思想。

3.基本类型变量而非引用变量
  • 这里引出两个概念:装箱和拆箱
  • 了解一下:高精度计算类:BigInteger和BigDecimal

Java是面向对象的语言,然而有一类数据类型直接存储在栈中,称作基本数据类型,定义这些类型的变量不是引用对象,然而Java还是提供了对应的包装器类。基本类型和包装器类型直接相互转换称为装箱与拆箱。

基本类型:boolean,char,byte,short,int,long,float,double,void

包装器类型:Boolean,Character,Byte,Short,Integer,Long,Float,Double,Void

面向对象和面向过程区别

4.Java中的数组

Java中的数组是安全的:

  1. 保证被初始化
  2. 检查数组越界

创建数组对象实际是创建引用数组,例如String []a;a会直接被初始化为null

- 面向过程:事物比较简单,可以用线性的思维去解决。

5.垃圾回收

这一部分很有意思,但是我现在还没怎么搞明白,以后再写

参考资料:《深入理解Java虚拟机》

1.Java对象作用域

{
  String s = new String("aaa")
}

一个面试题:引用变量s和String对象"aaa"生命周期是一样的吗?

2.Java不使用析构函数回收内存,因为它没有析构函数概念。Java是自动垃圾回收的,虽然有三种方式可以通知垃圾回收器回收对象,但一般不推荐使用。

  1. finalize( )只是通知JVM的垃圾收集器当前的对象不再使用可以被回收了,但是垃圾回收器根据内存使用状况来决定是否回收。

finalize()最有用的地方是在JNI调用本地方法时(C/C++方法),调用本地方法的析构函数消耗对象释放函数。

  1. ** System.gc()**是强制析构,显式通知垃圾回收器释放内存,但是垃圾回收器也不一定会立即执行,垃圾回收器根据当前内存使用状况和对象的生命周期自行决定是否回收。
  2. RunTime.getRunTime().gc()System.gc()类似。

3.垃圾回收算法原理

(1).引用计数(ReferenceCounting)垃圾回收算法:

一种简单但是速度较慢的垃圾回收算法,每个对象拥有一个引用计数器(Reference Counter),当每次引用附加到这个对象时,对象的引用计数器加1。当每次引用超出作用范围或者被设置为null时,对象的引用计数器减1。垃圾回收器遍历整个对象列表,当发现一个对象的引用计数器为0时,将该对象移出内存释放。

引用计数算法的缺点是,当对象环状相互引用时,对象的引用计数器总不为0,要想回收这些对象需要额外的处理。

引用计数算法只是用来解释垃圾回收器的工作原理,没有JVM使用它实现垃圾回收器。

引用计数的改进算法:

任何存活的对象必须被在静态存储区或者栈(Stack)中的引用所引用,因此当遍历全部静态存储区或栈中的引用时,即可以确定所有存活的对象。每当遍历一个引用时,检查该引用所指向的对象,同时检查该对象上的所有引用,没有引用指向的对象和相互自引用的对象将被垃圾回收器回收。

(2).暂停复制(stop-and-copy)算法:

垃圾回收器的收集机制基于:任何一个存活的对象必须要被一个存储在栈或者静态存储区的引用所引用。

暂停复制的算法是:程序在运行过程中首先暂停执行,把每个存活的对象从一个堆复制到另一个堆中,已经不再被使用的对象被回收而不再复制。

暂停复制算法有两个问题:

a.必须要同时维护分离的两个堆,需要程序运行所需两倍的内存空间。JVM的解决办法是在内存块中分配堆空间,复制时简单地从一个内存块复制到另一个内存块。

b.第二个问题是复制过程的本身处理,当程序运行稳定以后,只会产生很少的垃圾对象需要回收,如果垃圾回收器还是频繁地复制存活对象是非常低性能的。JVM的解决方法是使用一种新的垃圾回收算法——标记清除(mark-and-sweep)。

一般来说标记清除算法在正常的使用场景中速度比较慢,但是当程序只产生很少的垃圾对象需要回收时,该算法就非常的高效。

(3).标记清除(mark-and-sweep)算法:

和暂停复制的逻辑类似,标记清除算法从栈和静态存储区开始追踪所有引用寻找存活的对象,当每次找到一个存活的对象时,对象被设置一个标记并且不被回收,当标记过程完成后,清除不用的死对象,释放内存空间。

标记清除算法不需要复制对象,所有的标记和清除工作在一个内存堆中完成。

注意:SUN的文档中说JVM的垃圾回收器是一个后台运行的低优先级进程,但是在早期版本的JVM中并不是这样实现的,当内存不够用时,垃圾回收器先暂停程序运行,然后进行垃圾回收。

(4).分代复制(generation-copy)算法:

一种对暂停复制算法的改进,JVM分配内存是按块分配的,当创建一个大对象时,需要占用一块内存空间,严格的暂停复制算法在释放老内存堆之前要求把每个存活的对象从源堆拷贝到新堆,这样做非常的消耗内存。

通过内存堆,垃圾回收器可以将对象拷贝到回收对象的内存堆中,每个内存块拥有一个世代计数(generation count)用于标记对象是否存活。每个内存块通过对象被引用获得世代计数,一般情况下只有当最老的内存块被回收时才会创建新的内存块,这主要用于处理大量的短存活周期临时对象回收问题。一次完整的清理过程中,内存块中的大对象不会被复制,只是根据引用重新获得世代计数。

JVM监控垃圾回收器的效率,当发现所有的对象都是长时间存活时,JVM将垃圾回收器的收集算法调整为标记清除,当内存堆变得零散碎片时,JVM又重新将垃圾回收器的算法切换会暂停复制,这就是JVM的自适应分代暂停复制标记清除垃圾回收算法的思想。

-

6.类型转换

Java中有两种常见的类型转换:向上类型转换(upcast)和向下类型转换(downcast):

  1. upcast:

向上类型转换是将子类对象强制类型转换为父类类型,经典用法是面向对象的多态特性。向上类型转换时,子类对象的特性将不可见,只有子类从父类继承的特性仍然保持可见,向上类型转换时编译器会自动检查是否类型兼容,通常是安全的。

  1. downcast:

向下类型转换是将父类类型强制转换为子类类型,转换过后父类中不可见的子类特性又恢复可见性,向下类型转换时,编译器无法自动检测是否类型兼容,往往会产生类型转换错误的运行时异常,通常不安全。

面向对象:事物比较复杂,使用简单的线性思维无法解决。

7.class类型

字段:成员数据

方法:成员函数

访问控制权限:

public:公共访问控制权限,既可以用来修饰类成员(字段和方法)的访问权限又可以修饰类的访问权限

protected:继承访问控制权限,只能用来修饰类的成员,不能用于修饰类(事实上也可以用于修饰内部类,以后再介绍吧)

private:内部访问控制权限,只能用来修饰类的成员,不能用于修饰类(事实上也可以用于修饰内部类,以后再介绍吧)

[default] :default包内访问控制权限,default就是指没有访问权限修饰符。如果是默认权限则在包内可以访问。

嵌套类:在一个类或者接口中声明一个类,类有两种形式,静态的和非静态的,非静态的称为内部类

内部类:非静态的嵌套类

static关键字:用于修饰类中的字段和方法。(这个东西感觉没有那么容易说清楚,以后对比C++和Java讨论这个话题)

final关键字:

继承:表达 is - a关系

组合:表达have-a关系,且关系紧密

聚合:表达have-a关系,且关系松散

委派:

以后介绍UML与设计模式的时候再探讨这个话题

- 共同点:都是解决实际问题的一种思维方式。解决复杂问题,通过面向对象方式便于我们从宏观上把握事物之间复杂的关系,方便我们分析整个系统;具体到微观操作,仍然使用面向过程方式来处理。

1.Java中的方法:

构造函数:当程序员不写构造函数时,Java编译器会自动生成默认构造器,如果程序员写了一个构造器,则编译器不会再生成了。

函数重载:函数重载是通过名字改编实现(name-magling),同一个函数名接受不同类型参数和不同个数的参数,注意不能以返回值重载函数。

对象

2.两个神奇的关键字:final和static

2.1.final

final的三种情况:数据,方法,类

final变量:不允许修改

final方法:不允许该方法被覆盖

final类:明确该类不会被继承

2.2static

接收消息的实体,一切皆为对象,对象都有属性和行为,对象都属于某个类,每个对象都是独一无二的。

3.Java中类的初始化顺序
  1. 在一个类中,初始化顺序由变量在类中的声明定义顺序决定,成员变量(非set方法和构造方法的初始化)的初始化发生在方法调用之前,包括构造方法。
  2. 静态变量在整个存储区只保留一份拷贝,本地变量不能使用静态关键字,基本类型的静态变量不需要初始化,它会根据类型获得初始化值,引用类型的静态变量默认初始化为null。
  3. 静态初始化块和静态变量类似的执行也在构造方法之前,并且仅执行一次。
  4. 动态初始化块(与静态初始化块类似,只是没有static关键字,即放在一对大括号中的代码块)在静态初始化块初始化结束后执行,动态初始化块每次创建新对象都会初始化一次。
  5. 构造方法执行时,先执行父类的构造方法,后执行子类的构造方法。
  6. 本地变量初始化最晚,在方法中初始化。

初始化顺序:

a.父类的静态变量/静态初始化块;

b.子类类的静态变量/静态初始化块;

c.父类的动态初始化块、非构造方法和set方法的成员变量初始化

d.子类的动态初始化块、非构造方法和set方法的成员变量初始化

e.父类的构造方法。

f.子类的构造方法。

g.父类本地变量。

h.子类的本地变量。

4.代码重用

创建对象的蓝图和模板

4.多态,抽象类和接口,内部类

《java编程思想》第8,9,10章

《Java与Android开发学习指南》第11章

类的属性:数据抽象

1.多态:

在面向对象编程中,子类覆盖父类方法,当调用子类方法的某个操作时,不必明确知道子类的具体类型,只需要将子类类型看作是父类的引用调用其操作方法,在运行时,JVM会根据引用对象的具体子类类型而调用应该的方法,这就是多态。

多态的三个条件:

一、要有继承;
二、要有重写;
三、父类引用指向子类对象。

满足条件之一则A a = new B();合法:

1)A是类,B继承A

2)A是接口,B实现A

这种方式叫做向上类型转换

如果B的方法没有在A中实现,则不能用a调用B该方法,

如果A的方法在B中被覆盖了,用a调用该方法实际调用的是B的方法,因为从运行时来看,a引用对象的实际类型是B类类型。

多态的主要实现原理是动态绑定,也即是java中的绑定是发生在运行时而不是编译时。

static方法和final方法特别需要注意,因为static方法是与类相关联而不是和对象关联,所以不可能实现多态,final方法不能够被重写,所以也不可能实现多态。

多态的原理:

  1. JVM中的方法表:以数组的形式记录当前类及其所有父类的可见方法字节码在内存中的直接地址。
  2. 动态绑定原理:
  3. 首先会找到被调用方法所属类的全限定名
  4. 在此类的方法表中寻找被调用方法,如果找到,会将方法表中此方法的索引项记录到常量池中(这个过程叫常量池解析),如果没有,编译失败。
  5. 根据具体实例化的对象找到方法区中此对象的方法表,再找到方法表中的被调用方法,最后通过直接地址找到字节码所在的内存空间。

类的方法:行为抽象

2.从抽象方法到抽象类:

抽象方法:用abstract修饰的不提供实现(没有方法体)的方法,abstract void function();

抽象类是用abstract修饰指包含抽象方法的类(其实抽象类不一定要有抽象方法,但是含有抽象方法的类一定是抽象类),抽象类的一个主要特点是不能实例化。

继承抽象类的时候必须实现所有的抽象方法,如果没有实现则子类也是抽象类。

构造器

3.特殊的抽象类——接口

用interface修饰的一种高级抽象。

把接口称为特殊的抽象类是因为接口提供的所有方法都是抽象方法(不用显示声明)。

  • 一个类可以实现任意多个接口,但最多只能作为一个抽象类的子类。
  • 一个抽象类可以有若干个抽象方法(但到少要有一个),而接口的所有方法都是抽象的,无论是否将它的方法显示地声明为抽象的。
  • 一个抽象类可以声明实例变量,其子类可以继承这些实例变量。而一个接口不能声明实例变量,不过接口可以声明static final修饰域。
  • 抽象类可以有构造方法,而接口不能。
  • 抽象类的可见性修饰符可以是public、protected、private或无修饰符(表示包内可见);而接口的可见性修饰符只能是 public,或无修饰符(包内可见)。
  • 抽象类的方法的可见性修饰符可是以protected、private,或无(表示包内可见);而一个接口的方法的可见性修饰符只能是 public。
  • 抽象类是从object类派生而来,它继承了object的clone()和equals()方法。

接口

4.内部类

Java允许用户将一个类定义在另一个类的内部,并控制其对其他类的可见性。

1.使用内部类

public class Outter{  
    class inner{  
    }  
}  
Outter out = new Outter();  
Outter.Inner inner = out.new Inner();  

warnning:非静态的内部类必须要有外部类对象之后才能创建,因为外部类对象持有内部类的引用,如果内部类是静态的,则不需要外部类对象引用内部类对象。

2.内部类对外部类对象的引用

外部类中所有的元素对内部类都是可见的,内部类持有对外部类对象引用的语法:外部类名称.this。

3.内部类除了定义在类中还可以定义在某个作用域范围内(比如常在某个函数中使用匿名内部类)

{

}

4.静态内部类(嵌套类)

区别

(1).对于非静态的内部类来说,内部类和外部类必须保持对象引用,内部类可以访问外部类的任何元素.

(2).静态内部类不需要和外部类保持对象引用,静态内部类只能访问外部类的静态元素。

5.为什么使用内部类

  1. 解决多重继承问题
  2. 闭包问题

抽象方法的集合

6.枚举

《java编程思想》第19章

enum可以将一组值创建为一种新的类型,而这些值可以作为常规程序组件使用。

public enum Alpha{A,B,C}
public class HelloWorld{
  public static void main(String[]args){
    Alpha a = Alpha.A;
  }
}

enum中的一些有用的方法:

toString()
ordinal()
values()

enum的一个绝佳应用是在switch中作为选项。

创建enum时,编译器会自动生成一个相关类,继承自java.lang.Enum,Enum类实现了Comparable接口和Serializable接口。

enum不能被继承,但是可以有常规的方法。

作用:

能力,实现一个接口就代表具备了某方面的能力。

约定,一个类实现了接口就必须实现接口中的所有抽象方法否则要被声明为抽象类。

角色,一个类可以实现多个接口来扮演多种角色

接口之间可以继承而且支持多重继承

从Java

8开始接口中的方法允许有默认实现

常见的接口用法

单方法接口:Lambda表达式、@FunctionalInterface

- 标识性接口

- 普通接口

常量接口(接口最不正确的用法)

Java面向对象语言的三大特点

- 继承:从已有类创建新类的过程。

父类:提供继承信息的类

子类:得到继承信息的类

封装:隐藏一切可隐藏的实现细节提供简单的编程接口。私有属性,公有方法。好处:将变化隔离;便于使用;提高重用性,安全性。

- 多态:

方法重写:子类对父类的方法给出自己的实现版本。

对象造型:用父类型的引用去引用子类对象。

成员

定义在类中。成员有两种:

成员变量:其实对应的就是事物的属性。

成员函数:其实对应的就是事物的行为。

局部变量和成员变量的区别

成员变量直接定义在类中。

局部变量定义在方法中,参数上,语句中。

成员变量在这个类中有效。

局部变量只在自己所属的大括号内有效,大括号结束,局部变量失去作用域。

成员变量定义在堆内存中,随着对象的产生而存在,消失而消失。

局部变量存在于栈内存中,随着所属区域的运行而存在,结束而释放。

构造函数

用于给对象进行初始化 ,函数中的一种。构造函数是在对象创建时被调用的,而且 初始化动作只执行一次 。

特点:该函数的名称和所在类的名称相同。不需要指定返回值类型。该函数没有具体的返回值。

注意:在定义一个类的时候,如果没有定义一个构造函数,系统会自动生成一个无参构造函数,以便于该类对象的创建和初始化。如果类中自定了构造函数,那么默认的构造函数没有了。如果一个类中有多个构造函数,这些构造函数是以重载体现的。

构造代码块和构造函数的区别

构造代码块:是给所有的对象进行初始化 ,只要对象一建立就会调用这个代码块。

构造函数:是给与之对应的对象进行初始化。

创建一个对象内存中执行过程

Person p = new Person();

将硬盘中指定位置的Person.class文件加载进内存。

执行main方法时,在栈内存中开辟了main方法的空间,然后在main方法的栈区分配了一个变量P。

new。在堆内存中开辟一个实体空间,分配了一个内存首地址值。

在该实体空间中进行属性的空间分配,并进行了默认初始化。

对空间中的属性进行显示初始化。

进行实体的构造代码块初始化。

调用该实体对应的构造函数,进行构造函数初始化。

将首地址赋值给p,p变量就引用了该实体。

this关键字

代表对象。就是所在函数所属对象的引用。哪个对象调用了this所在的函数,this就代表哪个对象。

this是方法中存在的隐式参数,所以在方法中使用this。

普通方法中,this总是指向调用该方法的对象。this.xx; (调用的是成员属性和成员方法)

构造方法中,this总是指向正要初始化的对象。this; (调用本类对应参数的构造函数)

注意:

this调用构造函数,必须定义在构造函数的第一行。否则编译失败。

this不能用于static修饰的方法。

static关键字

关键字,是一个修饰符,用于修饰成员(成员变量和成员函数)

在类中,用static声明的成员变量为静态变量,或者叫做:类属性,类变量, 从属于类,给对象分配的内存里没有。

它为类的公用变量,属于类,被该类的所有实例共享,在类被载入时被显示初始化,

对于该类的所有对象来说,static成员变量只有一份。被该类的所有对象共享。

可以使用“对象.类属性”来调用。不过,一般都是用“类名.类属性”。

static变量置于方法区中。

用static声明的方法为静态方法。

类名.方法名的方式调用。

在调用该方法时,不会将对象的引用传递给它,所以在static方法中,不可访问非static的成员。

在静态方法中,不能是用this和supper关键字。

成员变量和静态变量的区别

成员变量所属与对象,所以也称为实例变量。

静态变量所属于类,所以也称为类变量。

成员变量存在于堆内存中。

静态变量存在于方法区中。

成员变量随着对象的创建而存在,随着对象被回收而消失。

静态变量随着类的加载而存在,随着类的消失而消失。

成员变量只能被对象所调用。

静态变量可以被对象调用,也可以被类名调用。

所以,成员变量可以称为对象的特有数据,静态变量称为对象的共享数据。

静态代码块

相信有很多学习java的道友,海量知识分享,绝对是Java干货,等各位的到来,我们一同从入门到精通吧!

Java学习交流 扣群:974

图片 3图片 4图片 5

本文由澳门太阳娱乐集团官网发布于脚本专栏,转载请注明出处:Java面向对象

上一篇:sqlserver 穷举 排列 组合 下一篇:没有了
猜你喜欢
热门排行
精彩图文