类与对象、封装、构造方法

作者 : 开心源码 本文共14850个字,预计阅读时间需要38分钟 发布时间: 2022-05-12 共192人阅读

1. 面向对象思想

1.1 面向对象思想概述

概述
Java语言是一种面向对象的程序设计语言,而面向对象思想是一种程序设计思想,我们在面向对象思想的指引下,使用Java语言去设计、开发计算机程序。 这里的对象泛指现实中一切事物,每种事物都具有自己的属性和行为。面向对象思想就是在计算机程序设计过程中,参照现实中事物,将事物的属性特征、行为特征笼统出来,形容成计算
机事件的设计思想。 它区别于面向过程思想,强调的是通过调用对象的行为来实现功能,而不是自己一步一步的去操作实现。
特点
面向对象思想是一种更符合我们思考习惯的思想,它可以将复杂的事情简单化,并将我们从执行者变成了指挥者。
面向对象的语言中,包含了三大基本特征,即封装、继承和多态。


1.2 类和对象

什么是类

  • 类 :是一组相关属性和行为的集合。可以看成是一类事物的模板,使用事物的属性特征和行为特征来形容该类事物。
    现实中,形容一类事物:
  • 属性 :就是该事物的状态信息。
  • 行为 :就是该事物能够做什么。

什么是对象

  • 对象 :是一类事物的具体表现。对象是类的一个实例(对象并不是找个女朋友),必然具有该类事物的属性和行为。
    现实中,一类事物的一个实例:一只小猫。

类与对象的关系

  • 类是对一类事物的形容,是 笼统的。
  • 对象是一类事物的实例,是 具体的。
  • 类是对象的模板,对象是类的实体 。

1.3 类的定义

事物与类的比照
现实世界的一类事物:
属性:事物的状态信息。 行为:事物能够做什么。
Java中用class形容事物也是如此:
成员变量:对应事物的属性 成员方法:对应事物的行为

类的定义格式

public class ClassName {
//成员变量
//成员方法
}

  • 定义类 :就是定义类的成员,包括成员变量和成员方法。
  • 成员变量 :和以前定义变量几乎是一样的。只不过位置发生了改变。在类中,方法外。
  • 成员方法 :和以前定义方法几乎是一样的。只不过把static去掉。

类的定义格式举例:

public class Student {   //成员变量     String name;//姓名      int age;//年龄    //成员方法    //学习的方法    publicvoid study() {    System.out.println("好好学习,天天向上");  }  //吃饭的方法  publicvoid eat() {    System.out.println("学习饿了要吃饭");  }}

1.4 对象的使用

对象的使用格式
创立对象:

类名 对象名 = new 类名();

使用对象访问类中的成员:

对象名.成员变量;
对象名.成员方法();

对象的使用格式举例:

public class Test01_Student {  public static void main(String[] args) {    //创立对象格式:类名 对象名 = new 类名();    Student s = new Student();    System.out.println("s:"+s); //cn.itcast.Student@100363    //直接输出成员变量值    System.out.println("姓名:"+s.name); //null    System.out.println("年龄:"+s.age); //0    System.out.println("‐‐‐‐‐‐‐‐‐‐");    //给成员变量赋值    s.name = "赵丽颖";    s.age = 18;    //再次输出成员变量的值    System.out.println("姓名:"+s.name); //赵丽颖    System.out.println("年龄:"+s.age); //18    System.out.println("‐‐‐‐‐‐‐‐‐‐");    //调用成员方法    s.study(); // "好好学习,天天向上"    s.eat(); // "学习饿了要吃饭"  }}

成员变量的默认值


1.5 类与对象的练习

定义手机类:

public class Phone {  // 成员变量  String brand; //品牌  int price; //价格  String color; //颜色  // 成员方法  //打电话  public void call(String name) {    System.out.println("给"+name+"打电话");  }  //发短信  public void sendMessage() {    System.out.println("群发短信");  }}

定义测试类:

public class Test02Phone {  public static void main(String[] args) {    //创立对象    Phone p = new Phone();    //输出成员变量值    System.out.println("品牌:"+p.brand);//null    System.out.println("价格:"+p.price);//0    System.out.println("颜色:"+p.color);//null    System.out.println("‐‐‐‐‐‐‐‐‐‐‐‐");    //给成员变量赋值    p.brand = "锤子";    p.price = 2999;    p.color = "棕色";    //再次输出成员变量值    System.out.println("品牌:"+p.brand);//锤子    System.out.println("价格:"+p.price);//2999    System.out.println("颜色:"+p.color);//棕色    System.out.println("‐‐‐‐‐‐‐‐‐‐‐‐");    //调用成员方法    p.call("紫霞");    p.sendMessage();  }}

1.6 对象内存图

一个对象,调用一个方法内存图

两个对象,调用同一方法内存图

一个引用,作为参数传递到方法中内存图

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

变量根据定义位置的不同,我们给变量起了不同的名字。如下图所示:

  • 在类中的位置不同
    • 成员变量:类中,方法外
    • 局部变量:方法中或者者方法公告上 (形式参数)
  • 作用范围不一样
    • 成员变量:类中
    • 局部变量:方法中
  • 初始化值的不同
    • 成员变量:有默认值
    • 局部变量:没有默认值。必需先定义,赋值,最后使用
  • 在内存中的位置不同
    • 成员变量:堆内存
    • 局部变量:栈内存
  • 生命周期不同
    • 成员变量:随着对象的创立而存在,随着对象的消失而消失
    • 局部变量:随着方法的调用而存在,随着方法的调用完毕而消失

2. 封装

2.1 封装概述

概述
面向对象编程语言是对客观世界的模拟,客观世界里成员变量都是隐藏在对象内部的,外界无法直接操作和修改。封装可以被认为是一个保护屏障,防止该类的代码和数据被其余类随便访问。要访问该类的数据,必需通过指定的方式。适当的封装可以让代码更容易了解与维护,也增强了代码的安全性。
准则
将属性隐藏起来,若需要访问某个属性,提供公共方法对其访问。

2.2 封装的步骤

  1. 使用 private 关键字来修饰成员变量。
  2. 对需要访问的成员变量,提供对应的一对 getXxx 方法 、 setXxx 方法。

2.3 封装的操作——private关键字

private的含义

  1. private是一个权限修饰符,代表最小权限。
  2. 可以修饰成员变量和成员方法。
  3. 被private修饰后的成员变量和成员方法,只在本类中才能访问。
    private的使用格式

private 数据类型 变量名 ;

  1. 使用 private 修饰成员变量,代码如下:
public class Student {  private String name;  private int age;}
  1. 提供 getXxx 方法 / setXxx 方法,可以访问成员变量,代码如下:
public class Student {  private String name;  private int age;  public void setName(String n) {    name = n;  }  public String getName() {    return name;  }  public void setAge(int a) {    age = a;  }  public int getAge() {    return age;  }}

2.4 封装优化1——this关键字

我们发现 setXxx 方法中的形参名字并不符合见名知意的规定,那么假如修改与成员变量名一致,能否就见名知意了呢?代码如下:

public class Student {  private String name;  private int age;  public void setName(String name) {    name = name;  }  public void setAge(int age) {    age = age;  }}

经过修改和测试,我们发现新的问题,成员变量赋值失败了。也就是说,在修改了 setXxx() 的形参变量名后,方法并没有给成员变量赋值!这是因为形参变量名与成员变量名重名,导致成员变量名被隐藏,方法中的变量名,无法访问到成员变量,从而赋值失败。所以,我们只能使用this关键字,来处理这个重名问题。
this的含义
this代表所在类的当前对象的引用(地址值),即对象自己的引用。

记住 :方法被哪个对象调用,方法中的this就代表那个对象。即谁在调用,this就代表谁。

this使用格式

this.成员变量名;

使用 this 修饰方法中的变量,处理成员变量被隐藏的问题,代码如下:

public class Student {  private String name;  private int age;  public void setName(String name) {    //name = name;    this.name = name;  }  public String getName() {    return name;  }  public void setAge(int age) {    //age = age;    this.age = age;  }  public int getAge() {    return age;  }}

小贴士:方法中只有一个变量名时,默认也是使用 this 修饰,可以省略不写。

2.5 封装优化2——构造方法

当一个对象被创立时候,构造方法用来初始化该对象,给对象的成员变量赋初始值。

小贴士:无论你与否自己设置构造方法,所有的类都有构造方法,由于Java自动提供了一个无参数构造方法,一旦自己定义了构造方法,Java自动提供的默认无参数构造方法就会失效。

构造方法的定义格式

修饰符 构造方法名(参数列表){// 方法体    }

构造方法的写法上,方法名与它所在的类名相同。它没有返回值,所以不需要返回值类型,甚至不需要void。使用构造方法后,代码如下:

public class Student {  private String name;  private int age;  // 无参数构造方法  public Student() {}  // 有参数构造方法  public Student(String name,int age) {    this.name = name;    this.age = age;  }}

注意事项

  1. 假如你不提供构造方法,系统会给出无参数构造方法。
  2. 假如你提供了构造方法,系统将不再提供无参数构造方法。
  3. 构造方法是可以重载的,既可以定义参数,也可以不定义参数。

2.6 标准代码——JavaBean

JavaBean 是 Java语言编写类的一种标准规范。符合 JavaBean 的类,要求类必需是具体的和公共的,并且具备无参数的构造方法,提供用来操作成员变量的 set 和 get 方法。

public class ClassName{  //成员变量  //构造方法  //无参构造方法【必需】  //有参构造方法【建议】  //成员方法     //getXxx()  //setXxx()}

编写符合 JavaBean 规范的类,以学生类为例,标准代码如下:

public class Student {  //成员变量  private String name;  private int age;  //构造方法  public Student() {}  public Student(String name,int age) {    this.name = name;    this.age = age;  }  //成员方法  publicvoid setName(String name) {    this.name = name;  }  public String getName() {    return name;  }  publicvoid setAge(int age) {    this.age = age;  }  publicint getAge() {    return age;  }}

测试类,代码如下:

public class TestStudent {  public static void main(String[] args) {    //无参构造使用    Student s= new Student();    s.setName("柳岩");    s.setAge(18);    System.out.println(s.getName()+"‐‐‐\"+s.getAge());    //带参构造使用    Student s2= new Student("赵丽颖",18);    System.out.println(s2.getName()+"‐‐‐\"+s2.getAge());  }}

3.代码

3.1

import java.util.Arrays;/*面向过程:当需要实现一个功能的时候,每一个具体的步骤都要亲力亲为,详细解决每一个细节。面向对象:当需要实现一个功能的时候,不关心具体的步骤,而是找一个已经具备该功能的人,来帮我做事儿。 */public class Demo01PrintArray {    public static void main(String[] args) {        int[] array = { 10, 20, 30, 40, 50, 60 };        // 要求打印格式为:[10, 20, 30, 40, 50]        // 使用面向过程,每一个步骤细节都要亲力亲为。        System.out.print("[");        for (int i = 0; i < array.length; i++) {            if (i == array.length - 1) { // 假如是最后一个元素                System.out.println(array[i] + "]");            } else { // 假如不是最后一个元素                System.out.print(array[i] + ", ");            }        }        System.out.println("==============");        // 使用面向对象        // 找一个JDK给我们提供好的Arrays类,        // 其中有一个toString方法,直接就能把数组变成想要的格式的字符串        System.out.println(Arrays.toString(array));    }}
/*通常情况下,一个类并不能直接使用,需要根据类创立一个对象,才能使用。1. 导包:也就是指出需要使用的类,在什么位置。import 包名称.类名称;import cn.itcast.day06.demo01.Student;对于和当前类属于同一个包的情况,可以省略导包语句不写。2. 创立,格式:类名称 对象名 = new 类名称();Student stu = new Student();3. 使用,分为两种情况:使用成员变量:对象名.成员变量名使用成员方法:对象名.成员方法名(参数)(也就是,想用谁,就用对象名点儿谁。)注意事项:假如成员变量没有进行赋值,那么将会有一个默认值,规则和数组一样。 */public class Demo02Student {    public static void main(String[] args) {        // 1. 导包。        // 我需要使用的Student类,和我自己Demo02Student位于同一个包下,所以省略导包语句不写        // 2. 创立,格式:        // 类名称 对象名 = new 类名称();        // 根据Student类,创立了一个名为stu的对象        Student stu = new Student();        // 3. 使用其中的成员变量,格式:        // 对象名.成员变量名        System.out.println(stu.name); // null        System.out.println(stu.age); // 0        System.out.println("=============");        // 改变对象当中的成员变量数值内容        // 将右侧的字符串,赋值交给stu对象当中的name成员变量        stu.name = "赵丽颖";        stu.age = 18;        System.out.println(stu.name); // 赵丽颖        System.out.println(stu.age); // 18        System.out.println("=============");        // 4. 使用对象的成员方法,格式:        // 对象名.成员方法名()        stu.eat();        stu.sleep();        stu.study();    }}
/*定义一个类,用来模拟“学生”事物。其中就有两个组成部分:属性(是什么):    姓名    年龄行为(能做什么):    吃饭    睡觉    学习对应到Java的类当中:成员变量(属性):    String name; // 姓名    int age; // 年龄成员方法(行为):    public void eat() {} // 吃饭    public void sleep() {} // 睡觉    public void study() {} // 学习注意事项:1. 成员变量是直接定义在类当中的,在方法外边。2. 成员方法不要写static关键字。 */public class Student {    // 成员变量    String name; // 姓名    int age; // 姓名    // 成员方法    public void eat() {        System.out.println("吃饭饭!");    }    public void sleep() {        System.out.println("睡觉觉!");    }    public void study() {        System.out.println("学习!");    }}

3.2

/*定义一个类,用来模拟“手机”事物。属性:品牌、价格、颜色行为:打电话、发短信对应到类当中:成员变量(属性):    String brand; // 品牌    double price; // 价格    String color; // 颜色成员方法(行为):    public void call(String who) {} // 打电话    public void sendMessage() {} // 群发短信 */public class Phone {    // 成员变量    String brand; // 品牌    double price; // 价格    String color; // 颜色    // 成员方法    public void call(String who) {        System.out.println("给" + who + "打电话");    }    public void sendMessage() {        System.out.println("群发短信");    }}
public class Demo01PhoneOne {    public static void main(String[] args) {        // 根据Phone类,创立一个名为one的对象        // 格式:类名称 对象名 = new 类名称();        Phone one = new Phone();        System.out.println(one.brand); // null        System.out.println(one.price); // 0.0        System.out.println(one.color); // null        System.out.println("=========");        one.brand = "苹果";        one.price = 8388.0;        one.color = "黑色";        System.out.println(one.brand); // 苹果        System.out.println(one.price); // 8388.0        System.out.println(one.color); // 黑色        System.out.println("=========");        one.call("乔布斯"); // 给乔布斯打电话        one.sendMessage(); // 群发短信    }}
public class Demo02PhoneTwo {    public static void main(String[] args) {        Phone one = new Phone();        System.out.println(one.brand); // null        System.out.println(one.price); // 0.0        System.out.println(one.color); // null        System.out.println("=========");        one.brand = "苹果";        one.price = 8388.0;        one.color = "黑色";        System.out.println(one.brand); // 苹果        System.out.println(one.price); // 8388.0        System.out.println(one.color); // 黑色        System.out.println("=========");        one.call("乔布斯"); // 给乔布斯打电话        one.sendMessage(); // 群发短信        System.out.println("=========");        Phone two = new Phone();        System.out.println(two.brand); // null        System.out.println(two.price); // 0.0        System.out.println(two.color); // null        System.out.println("=========");        two.brand = "三星";        two.price = 5999.0;        two.color = "蓝色";        System.out.println(two.brand); // 三星        System.out.println(two.price); // 5999.0        System.out.println(two.color); // 蓝色        System.out.println("=========");        two.call("欧巴"); // 给欧巴打电话        two.sendMessage(); // 群发短信    }}
public class Demo03PhoneSame {    public static void main(String[] args) {        Phone one = new Phone();        System.out.println(one.brand); // null        System.out.println(one.price); // 0.0        System.out.println(one.color); // null        System.out.println("=========");        one.brand = "苹果";        one.price = 8388.0;        one.color = "黑色";        System.out.println(one.brand); // 苹果        System.out.println(one.price); // 8388.0        System.out.println(one.color); // 黑色        System.out.println("=========");        one.call("乔布斯"); // 给乔布斯打电话        one.sendMessage(); // 群发短信        System.out.println("=========");        // 将one当中保存的对象地址值赋值给two        Phone two = one;        System.out.println(two.brand); // 苹果        System.out.println(two.price); // 8388.0        System.out.println(two.color); // 黑色        System.out.println("=========");        two.brand = "三星";        two.price = 5999.0;        two.color = "蓝色";        System.out.println(two.brand); // 三星        System.out.println(two.price); // 5999.0        System.out.println(two.color); // 蓝色        System.out.println("=========");        two.call("欧巴"); // 给欧巴打电话        two.sendMessage(); // 群发短信    }}
public class Demo04PhoneParam {    public static void main(String[] args) {        Phone one = new Phone();        one.brand = "苹果";        one.price = 8388.0;        one.color = "土豪金";        method(one); // 传递进去的参数其实就是地址值    }    public static void method(Phone param) {        System.out.println(param.brand); // 苹果        System.out.println(param.price); // 8388.0        System.out.println(param.color); // 土豪金    }}
public class Demo05PhoneReturn {    public static void main(String[] args) {        Phone two = getPhone();        System.out.println(two.brand); // 苹果        System.out.println(two.price); // 8388.0        System.out.println(two.color); // 玫瑰金    }    public static Phone getPhone() {        Phone one = new Phone();        one.brand = "苹果";        one.price = 8388.0;        one.color = "玫瑰金";        return one;    }}

3.3

/*问题形容:定义Person的年龄时,无法阻止不正当的数值被设置进来。处理方案:用private关键字将需要保护的成员变量进行修饰。一旦使用了private进行修饰,那么本类当中依然可以随便访问。但是!超出了本类范围之外就不能再直接访问了。间接访问private成员变量,就是定义一对儿Getter/Setter方法必需叫setXxx或者者是getXxx命名规则。对于Getter来说,不能有参数,返回值类型和成员变量对应;对于Setter来说,不能有返回值,参数类型和成员变量对应。 */public class Person {    String name; // 姓名    private int age; // 年龄    public void show() {        System.out.println("我叫:" + name + ",年龄:" + age);    }    // 这个成员方法,专门用于向age设置数据    public void setAge(int num) {        if (num < 100 && num >= 9) { // 假如是正当情况            age = num;        } else {            System.out.println("数据不正当!");        }    }    // 这个成员方法,专门私语获取age的数据    public int getAge() {        return age;    }}
/*对于基本类型当中的boolean值,Getter方法肯定要写成isXxx的形式,而setXxx规则不变。 */public class Student {    private String name; // 姓名    private int age; // 年龄    private boolean male; // 是不是爷们儿    public void setMale(boolean b) {        male = b;    }    public boolean isMale() {        return male;    }    public void setName(String str) {        name = str;    }    public String getName() {        return name;    }    public void setAge(int num) {        age = num;    }    public int getAge() {        return age;    }}
/*局部变量和成员变量1. 定义的位置不一样【重点】局部变量:在方法的内部成员变量:在方法的外部,直接写在类当中2. 作用范围不一样【重点】局部变量:只有方法当中才可以使用,出了方法就不能再用成员变量:整个类全都可以通用。3. 默认值不一样【重点】局部变量:没有默认值,假如要想使用,必需手动进行赋值成员变量:假如没有赋值,会有默认值,规则和数组一样4. 内存的位置不一样(理解)局部变量:位于栈内存成员变量:位于堆内存5. 生命周期不一样(理解)局部变量:随着方法进栈而诞生,随着方法出栈而消失成员变量:随着对象创立而诞生,随着对象被垃圾回收而消失 */public class Demo01VariableDifference {    String name; // 成员变量    public void methodA() {        int num = 20; // 局部变量        System.out.println(num);        System.out.println(name);    }    public void methodB(int param) { // 方法的参数就是局部变量        // 参数在方法调用的时候,必然会被赋值的。        System.out.println(param);        int age; // 局部变量//        System.out.println(age); // 没赋值不能用//        System.out.println(num); // 错误写法!        System.out.println(name);    }}
/*面向对象三大特征:封装、继承、多态。封装性在Java当中的表现:1. 方法就是一种封装2. 关键字private也是一种封装封装就是将少量细节信息隐藏起来,对于外界不可见。 */public class Demo02Method {    public static void main(String[] args) {        int[] array = {5, 15, 25, 20, 100};        int max = getMax(array);        System.out.println("最大值:" + max);    }    // 给我一个数组,我还给你一个最大值    public static int getMax(int[] array) {        int max = array[0];        for (int i = 1; i < array.length; i++) {            if (array[i] > max) {                max = array[i];            }        }        return max;    }}
public class Demo03Person {    public static void main(String[] args) {        Person person = new Person();        person.show();        person.name = "赵丽颖";//        person.age = -20; // 直接访问private内容,错误写法!        person.setAge(20);        person.show();    }}
public class Demo04Student {    public static void main(String[] args) {        Student stu = new Student();        stu.setName("鹿晗");        stu.setAge(20);        stu.setMale(true);        System.out.println("姓名:" + stu.getName());        System.out.println("年龄:" + stu.getAge());        System.out.println("是不是爷们儿:" + stu.isMale());    }}

3.4

/*当方法的局部变量和类的成员变量重名的时候,根据“就近准则”,优先使用局部变量。假如需要访问本类当中的成员变量,需要使用格式:this.成员变量名“通过谁调用的方法,谁就是this。” */public class Person {    String name; // 我自己的名字    // 参数name是对方的名字    // 成员变量name是自己的名字    public void sayHello(String name) {        System.out.println(name + ",你好。我是" + this.name);        System.out.println(this);    }}
/*构造方法是专门用来创立对象的方法,当我们通过关键字new来创立对象时,其实就是在调用构造方法。格式:public 类名称(参数类型 参数名称) {    方法体}注意事项:1. 构造方法的名称必需和所在的类名称完全一样,就连大小写也要一样2. 构造方法不要写返回值类型,连void都不写3. 构造方法不能return一个具体的返回值4. 假如没有编写任何构造方法,那么编译器将会默认赠送一个构造方法,没有参数、方法体什么事情都不做。public Student() {}5. 一旦编写了至少一个构造方法,那么编译器将不再赠送。6. 构造方法也是可以进行重载的。重载:方法名称相同,参数列表不同。 */public class Student {    // 成员变量    private String name;    private int age;    // 无参数的构造方法    public Student() {        System.out.println("无参构造方法执行啦!");    }    // 全参数的构造方法    public Student(String name, int age) {        System.out.println("全参构造方法执行啦!");        this.name = name;        this.age = age;    }    // Getter Setter    public void setName(String name) {        this.name = name;    }    public String getName() {        return name;    }    public void setAge(int age) {        this.age = age;    }    public int getAge() {        return age;    }}
public class Demo01Person {    public static void main(String[] args) {        Person person = new Person();        // 设置我自己的名字        person.name = "王健林";        person.sayHello("王思聪");        System.out.println(person); // 地址值    }}
public class Demo02Student {    public static void main(String[] args) {        Student stu1 = new Student(); // 无参构造        System.out.println("============");        Student stu2 = new Student("赵丽颖", 20); // 全参构造        System.out.println("姓名:" + stu2.getName() + ",年龄:" + stu2.getAge());        // 假如需要改变对象当中的成员变量数据内容,依然还需要使用setXxx方法        stu2.setAge(21); // 改变年龄        System.out.println("姓名:" + stu2.getName() + ",年龄:" + stu2.getAge());    }}

3.5

/*一个标准的类通常要拥有下面四个组成部分:1. 所有的成员变量都要使用private关键字修饰2. 为每一个成员变量编写一对儿Getter/Setter方法3. 编写一个无参数的构造方法4. 编写一个全参数的构造方法这样标准的类也叫做Java Bean */public class Student {    private String name; // 姓名    private int age; // 年龄    public Student() {    }    public Student(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;    }}
public class Demo01Student {    public static void main(String[] args) {        Student stu1 = new Student();        stu1.setName("迪丽热巴");        stu1.setAge(20);        System.out.println("姓名:" + stu1.getName() + ",年龄:" + stu1.getAge());        System.out.println("=================");        Student stu2 = new Student("古力娜扎", 21);        System.out.println("姓名:" + stu2.getName() + ",年龄:" + stu2.getAge());        stu2.setAge(22);        System.out.println("姓名:" + stu2.getName() + ",年龄:" + stu2.getAge());    }}

说明
1. 本站所有资源来源于用户上传和网络,如有侵权请邮件联系站长!
2. 分享目的仅供大家学习和交流,您必须在下载后24小时内删除!
3. 不得使用于非法商业用途,不得违反国家法律。否则后果自负!
4. 本站提供的源码、模板、插件等等其他资源,都不包含技术服务请大家谅解!
5. 如有链接无法下载、失效或广告,请联系管理员处理!
6. 本站资源售价只是摆设,本站源码仅提供给会员学习使用!
7. 如遇到加密压缩包,请使用360解压,如遇到无法解压的请联系管理员
开心源码网 » 类与对象、封装、构造方法

发表回复