全站资源开放下载,感谢广大网友的支持
链接失效请移步职涯宝平台的学习路线|资源下载分类
支持用户留言评论_客服实时在线_问题解决更快

第九天 面向对象-类,封装,对象,private,this【悟空教程】

154
发表时间:2018-08-18 19:29

第九天 面向对象-类,封装,对象,private,this【悟空教程】

第09天 面向对象

第1章 面向对象

1.1 面向对象

1.1.1 面向对象概述

1.1.1.1 概述

我们回想一下,这几天我们完成一个需求的步骤:首先是搞清楚我们要做什么,然后在分析怎么做,最后我们再代码体现。一步一步去实现,而具体的每一步都需要我们去实现和操作。这些步骤相互调用和协作,完成我们的需求。

在上面的每一个具体步骤中我们都是参与者,并且需要面对具体的每一个步骤和过程,这就是面向过程最直接的体现。

那么什么是面向过程开发呢? 面向过程开发,其实就是面向着具体的每一个步骤和过程,把每一个步骤和过程完成,然后由这些功能方法相互调用,完成需求。

面向过程的代表语言:C语言

当需求单一,或者简单时,我们一步一步去操作没问题,并且效率也挺高。可随着需求的更改,功能的增多,发现需要面对每一个步骤很麻烦了,这时就开始思索,能不能把这些步骤和功能在进行封装,封装时根据不同的功能,进行不同的封装,功能类似的封装在一起。这样结构就清晰了很多。用的时候,找到对应的类就可以了。这就是面向对象的思想。

1.1.1.2 特点

  • 是一种更符合我们思考习惯的思想

  • 可以将复杂的事情简单化

  • 将我们从执行者变成了指挥者

    • 角色发生了转换


1.1.1.3 举例

  • 买电脑

  • 洗衣服

  • 吃饭


1.1.1.4 面向对象特性

  • 封装

  • 继承

  • 多态


1.1.2 类与对象

面向对象的思维方式在Java代码中表现为类的定义与对象的使用。理清类与对象的概念与关系是面向对象的重点。

1.1.2.1 类的基本概念

类是具有相同特征(属性)和行为(功能)的一类事物的抽象。

我们将现实事物的特征抽象为类中的成员变量,现实事物的行为功能抽象为类中的成员方法。

注意:实际上所属关系是直接属于类的,均称为成员,如成员变量、成员方法、后边学习的成员内部类,并不单指成员变量。


1.1.2.2 类的定义格式

类在Java中代码的体现形式:

  • 使用class(类)来抽象一个现实生活中的事物

  • 定义成员变量对应事物的属性,一般使用private修饰,提供get/set方法

  • 定义成员方法对应事物的功能,一般使用public修饰

  • 定义格式:

  public class 类名{

  private 数据类型 变量名1;

  private 数据类型 变量名2;

  …其他成员变量

 

  public 返回值类型 方法名(参数类型 参数名,参数类型 参数名2…) {

  方法体;

  }

  每个属性对应的get/set方法,使用this区分成员变量与局部变量

  }

如:人类

public class Person {

private String name;

private int age;

public void eat() {

System.out.println(吃了);

}


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;

}

}

1.1.2.3 类的使用格式

类的使用非常简单,一般分为两个动作:创建对象与调用方法。

类的定义是现实事物的抽象,真正使用的是类创建的对象。通常使用对象来调用方法。

对象创建格式:

数据类型  对象名= new 数据类型();

对象方法的调用:

无返回值:

对象名.方法名(参数);

有返回值:

返回值类型  变量名 = 对象名.方法名(参数);

1.1.2.4 成员变量

直接定义在类中的变量称为成员变量,在面向对象思想设计上,是类的组成部分。

成员变量通常使用private修饰,阻止本类以外的其他类访问。

成员变量不能重名,局部变量不能重名,成员与局部变量可以重名,但是需要使用this区分。

使用this访问的为成员变量,直接访问的为局部。在方法内访问变量,如果没有该名称的局部变量会自动查找是否有该名称的成员变量。

1.1.2.5 成员方法

正常定义成员方法时,一般是不需要添加static修饰符的。static修饰符会在后边详细简介。

成员方法一般可分为两类

  • 没有业务的属性get/set方法,与属性对应

  • 有业务的普通方法,属于类的功能

package cn.javahelp;

/*

* 定义自定义类型 Person

*

* 属性(成员变量)

* 姓名  String

*  年龄  int

* 行为(成员方法)

* 吃饭

*  睡觉

*  打豆豆

*  

*  为成员变量赋值/获取成员变量的值的方法

*  

*  private 修饰的成员(成员变量,成员方法) 让外界无法直接访问 内部可以访问

*  

*  this区分成员变量与局部变量(注意:这是定义时所展现出来的功能,其功能本质,一会单独说)

*  

*  成员方法 一般不使用static修饰

*  分为两种

*   1.get/set方法

*   2.属于类的功能的方法

*/

public class Person {

//定义成员变量

private String name;


private  int age;


private String sex;



//吃饭

public  void eat(){

System.out.println(name+"吃了");

}


//睡觉

public void sleep(){


System.out.println(name+"睡了");

}


//打豆豆

public void hitBeanBean(){

System.out.println(name+"打了,爽了,敲代码了!");

}


//name赋值的方法   方法名  setName  参数  String name 返回值  void

public void setName(String name){

this.name=name;

}


//获取name的值的方法  方法名 getName  参数 无  返回值  String name

public String getName(){

return name;

}


//age赋值的方法  方法名  setAge 参数  int age  返回值  void

public void setAge(int age){


this.age=age;

}

//获取age的值的方法  方法名  getAge  参数  无   返回值 int age

public int getAge(){

return age;

}

public String getSex() {

return sex;

}

public void setSex(String sex) {

this.sex = sex;

}

}

package cn.javahelp;

/*

* 测试Person

*

* 导包 在同一个文件夹下不需要导包

* 创建对象  数据类型  变量名 =  new 数据类型()

* 调用方法

* 返回值类型  新变量名 = 变量名.方法名(实际参数);

*

*

* 方法调用时,用static修饰的方法调用其他方法时,其他方法必须使用static修饰

* 指的是

*  在同一个类中,直接调用其他方法时,其他方法必须使用static修饰

*  如果使用对象名.方法名()这种方式 其他方法一般不使用static修饰

*/

public class Test {

public static void main(String[] args) {

//创建对象

Person   p=  new Person();

//调用方法

p.setName("柳岩");

p.setAge(38);

//因为ageprivate修饰了 所以外界不能直接访问了

//p.age = -1;


//如果使用对象名.方法名()这种方式 其他方法一般不使用static修饰

p.eat();

p.sleep();

p.hitBeanBean();


String name = p.getName();

System.out.println(name);

System.out.println(p.getAge());



//main方法直接调用method方法 method方法必须使用static修饰

//method();


}

public  void method(){


System.out.println("我是一个方法");

}

}

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

  • 在类中的位置不同

    • 成员变量:类中,方法外

    • 局部变量:方法中或者方法声明上(形式参数)

  • 在内存中的位置不同

    • 成员变量:堆内存

    • 局部变量:栈内存

  • 生命周期不同

    • 成员变量:随着对象的创建而存在,随着对象的消失而消失

    • 局部变量:随着方法的调用而存在,随着方法的调用完毕而消失

  • 初始化值的不同

    • 成员变量:有默认值

    • 局部变量:没有默认值。必须先定义,赋值,最后使用

public class DemoVariable {

int x;


public void show() {

int y = 0;


System.out.println(x);

System.out.println(y);

}

}

1.1.2.7 类与对象的关系

类是抽象概念,对象是类的具体实例。我们通常真正使用的是某个类的实例对象,进而调用该对象的方法。

一个类可以有多个对象,一个对象只属于一个类(在讲完多态后会有不同的理解)。

可以说创建对象并调用方法是类最主要的使用方式。

  • 我们学习编程语言,就是为了模拟现实世界的事物,实现信息化。比如:去超市买东西的计费系统,去银行办业务的系统。

  • 我们如何表示一个现实世界事物呢:

    • 属性 就是该事物的描述信息

    • 行为 就是该事物能够做什么

    • 举例:学生事物

  • 我们学习的Java语言最基本单位是类,所以我们就应该把事物用一个类来体现。

  • 类:是一组相关的属性和行为的集合

  • 对象:是该类事物的具体体现

  • 举例:

    • 类  学生

    • 对象 班长就是一个对象

1.1.2.8 类名作为形式参数和返回值(扩展)

类名作为形式参数案例: 需要的其实是该类的对象

public class Student {

public void study() {

System.out.println("好好学习,天天向上");

}

}

public class Teacher {

public void test(Student s) {

s.study();

}

}

public class Test {

public static void main(String[] args) {

Teacher t = new  Teacher();

Student s = new  Student();

t.test(s);

}

}

类名作为返回值案例: 返回的其实是该类的对象

public class Student {

public void study() {

System.out.println("好好学习,天天向上");

}

}

public class Teacher {

public Student getStudent() {

Student s = new Student();

return s;

}

}

public class Test {

public static void main(String[] args) {

Teacher t = new  Teacher();

Student s = t.getStudent();

s.study();

}

}

1.1.3 自定义类练习

在第6天自定义类型基础上,我们可以将现实生活中的任何事物抽象成一个更为完整的类,请自定义并使用一种数据类型。如人类、动物类、汽车类、衣服类、玩具类等


1.1.3.1 自定义人类:

/*

* 定义自定义类型 Person

*

* 属性(成员变量)

* 姓名  String

*  年龄  int

* 行为(成员方法)

* 吃饭

*  睡觉

*  打豆豆

*  

*  为成员变量赋值/获取成员变量的值的方法

*  

*  private 修饰的成员(成员变量,成员方法) 让外界无法直接访问 内部可以访问

*  

*  this区分成员变量与局部变量(注意:这是定义时所展现出来的功能,其功能本质,一会单独说)

*  

*  成员方法 一般不使用static修饰

*  分为两种

*   1.getset方法

*   2.属于类的功能的方法

*  

*  

*  

*

*/

public class Person {

//定义成员变量

private String name;


private  int age;


private String sex;



//吃饭

public  void eat(){

System.out.println(name+"吃了");

}


//睡觉

public void sleep(){


System.out.println(name+"睡了");

}


//打豆豆

public void hitBeanBean(){

System.out.println(name+"打了,爽了,敲代码了!");

}


//name赋值的方法   方法名  setName  参数  String name 返回值  void

public void setName(String name){

this.name=name;

}


//获取name的值的方法  方法名 getName  参数 无  返回值  String name

public String getName(){

return name;

}


//age赋值的方法  方法名  setAge 参数  int age  返回值  void

public void setAge(int age){


this.age=age;

}

//获取age的值的方法  方法名  getAge  参数  无   返回值 int age

public int getAge(){

return age;

}

public String getSex() {

return sex;

}

public void setSex(String sex) {

this.sex = sex;

}

}

/*

* 测试Person

*

* 导包 在同一个文件夹下不需要导包

* 创建对象  数据类型  变量名 =  new 数据类型()

* 调用方法

* 返回值类型  新变量名 = 变量名.方法名(实际参数);

*

*

* 方法调用时,用static修饰的方法调用其他方法时,其他方法必须使用static修饰

* 指的是

*  在同一个类中,直接调用其他方法时,其他方法必须使用static修饰

*  如果使用对象名.方法名()这种方式 其他方法一般不使用static修饰

*/

public class Test {

public static void main(String[] args) {

//创建对象

Person   p=  new Person();

//调用方法

p.setName("柳岩");

p.setAge(38);

//因为ageprivate修饰了 所以外界不能直接访问了

//p.age = -1;


//如果使用对象名.方法名()这种方式 其他方法一般不使用static修饰

p.eat();

p.sleep();

p.hitBeanBean();



String name = p.getName();

System.out.println(name);

System.out.println(p.getAge());



//main方法直接调用method方法 method方法必须使用static修饰

//method();


}


public  void method(){


System.out.println("我是一个方法");

}

}

1.1.3.2 自定义car

/*

* 车类

*

* 属性

* 颜色

*  品牌

*  价格

*  车牌号

*  车主

*  

* 功能

* 运输货物

* 兜风

*  get/set

*/

public class Car {

private String color;//颜色

private String pinPai;//品牌

private double price;//价格

private String number;//车牌号

private String admin;//车主


//运输方法  方法名yunShu  参数  String 货物    返回值 无

public void yunShu(String huoWu){

System.out.println(admin+"开着"+color+pinPai+"价值"+price

+"车牌号为"+number+"的车"+"运输了"+huoWu);

}


//兜风     方法名 douFeng 参数 String name 返回值 无

public void douFeng(String name){

System.out.println(admin+"开着"+color+pinPai+"价值"+price

+"车牌号为"+number+"的车"+"带着"+name+"去兜风");

}


//color赋值   方法名 setColor  参数  String color  返回值 void

public void setColor(String color){

this.color = color;

}


//获取color的值  方法名 getColor 参数  无   返回值  String color

public String getColor(){

return color;

}

//获取pinPai的值  

public String getPinPai() {

return pinPai;

}

//pinPai赋值

public void setPinPai(String pinPai) {

this.pinPai = pinPai;

}

//获取price的值  

public double getPrice() {

return price;

}

//price赋值

public void setPrice(double price) {

this.price = price;

}

//获取number的值  

public String getNumber() {

return number;

}

//number赋值

public void setNumber(String number) {

this.number = number;

}

//获取admin的值  

public String getAdmin() {

return admin;

}

//admin赋值

public void setAdmin(String admin) {

this.admin = admin;

}

}

/*

* 测试 自定义类型 车类

*

*/

public class Test {

public static void main(String[] args) {

Car c = new Car();

//调用方法

c.setAdmin("老王");

c.setColor("绿色");

c.setPinPai("三蹦子");

c.setPrice(250.38);

c.setNumber("JP74110");


c.yunShu("");

c.douFeng("柳岩");

}

}

1.1.3.3 自定义手机类

定义手机类

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 Demo02Phone {

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.1.4 对象的内存解释

对象在内存中的位置:

对象由new关键字创建,如同数组,实体存在于堆内存中

任何事物均可以定义成类,创建对象,属于引用类型

而对象的引用变量是一个普通变量。存储的值是该对象堆内存中的地址。

  • 定义Phone类

public class Phone {

String brand;

int price;

String color;


public void call(String name) {

System.out.println(""+name+"打电话");

}


public void sendMessage() {

System.out.println("群发短信");

}

}


1.1.4.1 一个对象的内存图

public class Demo01Phone {

public static void main(String[] args) {

Phone p = new Phone();

System.out.println(p.brand + "---" + p.price + "---" + p.color);


p.brand = "锤子";

p.price = 2999;

p.color = "棕色";


System.out.println(p.brand + "---" + p.price + "---" + p.color);


p.call("林青霞");

p.sendMessage();

}

}

1.1.4.2 两个对象,使用同一个方法的内存图

public class Demo02Phone {

public static void main(String[] args) {

Phone p1 = new Phone();

p1.brand = "小米5s";

p1.price = 1999;

p1.color = "银色";

System.out.println(p1.brand+"---"+p1.price+"---"+p1.color);

p1.call("林青霞");

p1.sendMessage();


Phone p2 = new Phone();

p2.brand = "IPhone7S";

p2.price = 7999;

p2.color = "土豪金";

System.out.println(p2.brand+"---"+p2.price+"---"+p2.color);

p2.call("张曼玉");

p2.sendMessage();

}

}

1.1.4.3 两个引用,指向同一个对象的内存图

public class Demo03Phone {

public static void main(String[] args) {

Phone p1 = new Phone();

p1.brand = "OPPO";

p1.price = 2999;

p1.color = "白色";

System.out.println(p1.brand+"---"+p1.price+"---"+p1.color);


Phone p2 = p1;

p2.brand = "魅族";

p2.price = 1999;

p2.color = "蓝色";

System.out.println(p1.brand+"---"+p1.price+"---"+p1.color);

System.out.println(p2.brand+"---"+p2.price+"---"+p2.color);

}

}

1.2 封装

1.2.1 封装的概述和好处

1.2.1.1 封装概述

  • 是面向对象三大特征之一

  • 是面向对象编程语言对客观世界的模拟,客观世界里成员变量都是隐藏在对象内部的,外界无法直接操作和修改。就像刚才说的年龄。


1.2.1.2 封装原则:

  • 将不需要对外提供的内容都隐藏起来。

  • 把属性隐藏,提供公共方法对其访问。

  • 成员变量private,提供对应的getXxx()/setXxx()方法

1.2.1.3 好处:

  • 通过方法来控制成员变量的操作,提高了代码的安全性

  • 把代码用方法进行封装,提高了代码的复用性


1.3 private关键字

1.3.1 private关键字:

  • 是一个权限修饰符。

  • 可以修饰成员(成员变量和成员方法)

  • 被private修饰的成员只在本类中才能访问。

public class Student {

String name;

//int age;

private int age;


public void setAge(int a) {

if(a<0 || a>200) {

System.out.println("你给的年龄有误");

}else {

age = a;

}

}


public int getAge() {

return age;

}


public void show() {

System.out.println("姓名是:"+name+",年龄是:"+age);

}

}

public class DemoStudent {

public static void main(String[] args) {

//创建学生对象

Student s = new Student();

s.show();


s.name = "柳岩";

//s.age = 18;

//s.age = -18;

//s.setAge(-18);

s.setAge(28);

s.show();

}

}


1.3.2 private最常见的应用:

  • 把成员变量用private修饰

  • 提供对应的getXxx()/setXxx()方法

  • 一个标准案例的使用


1.3.3 成员变量私有的标准代码

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;

}

}

public class DemoStudent {

public static void main(String[] args) {

//创建对象

Student s = new Student();

System.out.println(s.getName()+"---"+s.getAge());


s.setName("赵丽颖");

s.setAge(18);

System.out.println(s.getName()+"---"+s.getAge());

}

}


1.4 this关键字

1.4.1 this关键字

一般出现在类的一个方法的定义当中,代表当前对象的引用。我们通常用其将本对象中的成员与其他作用域区分开来。

当一个类定义好之后,如果不创建对象this是没有意义的。

一个类可以有多个对象。每个对象都有各自的属性值,各个对象的方法均是类中定义的那个方法逻辑。定义中的this就代表调用方法的这个对象。

1.4.2 this关键字的由来

  • this:代表所在类的对象引用

  • 记住:方法被哪个对象调用,this就代表那个对象


1.4.3 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;

}

}

public class DemoStudent {

public static void main(String[] args) {

//创建对象

Student s = new Student();

System.out.println(s.getName()+"---"+s.getAge());


s.setName("柳岩");

s.setAge(18);

System.out.println(s.getName()+"---"+s.getAge());

}

}

第2章 知识点相关题

2.1 定义“书”类,Book,包含以下成员:

  成员属性:

  名称:String

  作者:String

  出版社:String

  出版日期:String

  单价:double

成员方法:

1). get/set方法

2).showMe()方法,打印所有内部属性的值;

定义类:Test1,定义main()方法,按以下要求编写代码:

  • 实例化一个Book对象,调用set()方法为属性赋值:

  • “Java实战”,”Jack”,”javahelp”,”2011-03-15”,88.5

  • 实例化一个Book对象,调用set()方法为属性赋值:

  • “JavaEE高级”,”Anson”,”javahelp”,”2012-02-05”,66.70

  • 分别调用两个Book对象的showMe()方法打印各自的属性值;

   

2.2 定义“猫”类,Cat,包含以下成员:

  成员属性:

  名称:String

  性别:char

  年龄:int

  出生日期:String

成员方法:

1). get/set方法

2).showMe()方法,打印所有内部属性的值;

3).eat()方法,打印:小猫吃鱼;

定义类:Test2,定义main()方法,按以下要求编写代码:

  • 实例化一个Cat对象,调用set()方法为属性赋值:

    “波斯猫”,’公’,2,”2011-05-06”

  • 实例化一个Cat对象,调用set()方法为属性赋值:

    “机器猫”,’公’,5,”2012-08-06”

  • 分别调用两个Cat对象的showMe()方法打印各自的属性值;

  • 分别调用两个Cat对象的eat()方法;


2.3 定义 “手机类” , Phone  包含以下成员:

成员属性:

品牌brand,

价格price

颜色 color

行为:打电话call,  调用方法打印***手机正在给10086打电话

发短信sendMessage,  调用方法打印***手机正在发短信

玩游戏,playGame,调用方法打印***手机正在玩王者农药

定义测试类,定义main方法,要求如下:

  • 创建一个华为手机对象,调用方法设置颜色为黑色,价格为2399

  • 创建一个苹果手机对象,调用方法设置颜色为玫瑰金,价格为5699

  • 创建一个三星手机对象,调用方法设置颜色为钻石白,价格为4699

  • 华为调用打电话的方法, 苹果调用发短息的方法,三星调用玩游戏的方法

2.4 定义一个人类,包含以下成员:

成员属性:

name  姓名

age    年龄

方法:

Show()  

要求打印出对象的所有属性

要求在类中定义构造方法(有参数和无参数两种)和get、set方法

然后创建出测试类,然后创建三个对象

1).通过有参构造创建一个对象---(小明,20)

2)通过有参构造创建一个对象---(小红,22)

3)通过有参构造创建一个对象---(小新,16)

2).然后通过show方法打印这个对象的所有属性  

   

2.5 定义类Person1,为其添加“默认无参构造方法”:打印:“构造一个Person对象”

定义测试类:Demo,添加main()方法,填写如下内容:

Person1 p1 = new Person1();

System.out.println(“--------------------“);

Person1 p2 = new Person1();

System.out.println(“--------------------“);

Person1 p3;

观察执行结果,请回答以下问题:

A. 构造方法的名称有什么特点?

B. 构造方法是否有“返回值类型”和“形参”的定义?

C. 此构造方法什么时候被执行?


2.6 创建Test_1类的main方法,并按以下要求完成代码内容:

  • 在主方法中创建int 类型的对象a并赋值

  • 创建static void method(int a)方法传入的参数为int 类型,并对传入的数据进行修改

  • 在主方法中调用method方法后,打印a并查看数值

2.7 创建Test_2类的main方法,并按以下要求完成代码内容:

  • 在主方法中创建String类型的对象str并赋值

  • 创建static void method(String str)方法传入的参数为String 类型,并对传入的数据进行修改

  • 在主方法中调用method方法后,打印str并查看数据


2.8 自定义类,并自定义测试方法,调用方法证明this可以区分成员变量和局部变量

第3章 代码题

3.1 定义一个空调类和对应的测试类

该题考查点:属性和方法的使用!

要求:

1.空调有品牌和价格两个属性,并且将属性私有化,提供公有的getXxx与setXxx方法对属性赋值和取值;

2.提供一个无返回值的无参数的开机的方法,内容打印一句话:“空调开机了...”;

3.提供一个无返回值的带1个int类型参数的定时关机的方法,(int类型的参数表示设定的分钟数),内容打印一句话:“空调将在xxx分钟后自动关闭...”;

4.在测试类中创建出空调对象,并给空调的品牌和价格赋任意值;

5.使用空调对象获取空调的品牌和价格并打印到控制台上;

6.使用空调对象调用开机方法;

7.使用空调对象调用定时关机方法,并传递具体数据值,在控制台上可以看到的效果为:空调将在xxx分钟后自动关闭...

其中语句中的“xxx”是调用方法时传递的具体数据值;

答案:

/*

* 空调类:

* 属性:

*  品牌

*  价格

* 方法:

*  开机

*  定时关机

*  getXxx与setXxx

*/

public class KongTiao {

//属性

private String name;

private double price;

//getter与setter

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public double getPrice() {

return price;

}

public void setPrice(double price) {

this.price = price;

}

//开机

public void kaiJi(){

System.out.println("空调开机了...");

}

//定时关机

public void dingShiGuanJi(int fenZhong){

System.out.println("空调将在"+fenZhong+"分钟后自动关闭...");

}

}

/*

* 空调测试类

*/

public class KongTiaoTest {

public static void main(String[] args) {

//1、创建对象

KongTiao kt = new KongTiao();

//2、赋值

kt.setName("格力");

kt.setPrice(2999.99);

//3、取值

String name = kt.getName();

double price = kt.getPrice();

//4、打印值

System.out.println("空调的品牌为:"+name);

System.out.println("空调的价格为:"+price);

//5、开机

kt.kaiJi();

//6、定时关机

kt.dingShiGuanJi(30);

}

}

3.2 定义一个学生类和对应的测试类

该题考查点:this关键字的使用!

要求:

1.学生有姓名和年龄两个属性,并且将属性私有化,提供公有的getXxx与setXxx方法对属性赋值和取值;

2.提供一个无返回值的无参数的自我介绍的方法,内容打印一句话:

“大家好,我叫xxx,今年xxx岁了!”

3.提供一个返回值为String类型,参数为学生类型的比较年龄差值的方法,如果当前对象的年龄比参数中的学生的年龄大,则返回:“我比同桌大xxx岁!”;如果当前对象的年龄比参数中的学生的年龄小,则返回:“我比同桌小xxx岁!”;如果当前对象的年龄和参数中的学生的年龄一样大,则返回:“我和同桌一样大!”

4.在测试类中分别创建你和你同桌两个人的对象,并分别给你和你同桌的姓名和年龄属性赋上对应的值;

5.调用你自己的对象的自我介绍的方法,展示出你自己的姓名和年龄;

6.用你自己的对象调用比较年龄差值的方法,把你同桌作为参数使用,并打印方法返回的字符串的内容;

答案:

/*

* 学生类:

* 属性:

*  姓名

*  年龄

* 方法:

*  自我介绍

*  比较年龄差值

*  getXxx与setXxx

*/

public class XueSheng {

//属性

private String name;

private int age;

//getter与setter

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 void ziWoJieShao(){

System.out.println("大家好,我叫"+this.name+",今年"+this.age+"岁了!");

}

//比较年龄差

public String biJiaoNianLingCha(XueSheng xs){

//1、获取参数中学生的年龄

int age2 = xs.getAge();

if(this.age > age2){

return "我比同桌大"+(this.age-age2)+"岁!";

}else if(this.age < age2){

return "我比同桌小"+(age2-this.age)+"岁!";

}else{

return "我和同桌一样大!";

}

}

}

/*

* 学生测试类

*/

public class XueShengTest {

public static void main(String[] args) {

//1、分别创建两个对象

XueSheng wo = new XueSheng();

XueSheng tongZhuo = new XueSheng();

//2、分别赋值

wo.setName("学全");

wo.setAge(18);

tongZhuo.setName("学友");

tongZhuo.setAge(19);

//3、调用自我介绍的方法

wo.ziWoJieShao();

//4、调用比较年龄差的方法

String cha = wo.biJiaoNianLingCha(tongZhuo);

System.out.println(cha);

}

}


3.3 定义一个商品类和对应测试类

要求:

1.定义商品类,有名称和价格两个属性,并且将属性私有化,提供公有的getXxx与setXxx方法对属性赋值和取值;设置有参无参构造方法

2.编写测试类,在测试类中通过构造分别创建3个商品对象,并分别给3个商品对象的名称和价格赋值;

3.然后求出是三个商品的平均价格;

public class Shangpin {

// 属性

private String name;

private double price;

public Shangpin() {

super();

// TODO Auto-generated constructor stub

}

public Shangpin(String name, double price) {

super();

this.name = name;

this.price = price;

}

// gettersetter

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public double getPrice() {

return price;

}

public void setPrice(double price) {

this.price = price;

}

}

public class Demo {

public static void main(String[] args) {

Shangpin d1 = new Shangpin("洗衣机",300.5);

Shangpin d2 = new Shangpin("电视机",888.5);

Shangpin d3 = new Shangpin("吹风机",49.2);

double num = 0;

double price1 = d1.getPrice();

double price2 = d2.getPrice();

double price3 = d3.getPrice();

num = price1+price2+price3;

double pingJun = num/3 ;

System.out.println("所有商品的平均价格为:"+pingJun);

}

}


3.4 创建student类,包含年龄,姓名,成绩属性,本类中有对学生成绩打等级的方法,并返回该等级(A,B,C

在主方法中: 创建三个Student对象并传入method(ArrayList<Student> stu)方法中

method方法内要求: 该方法内有对等级进行判断的方法,如果为A等级则打印该学生姓名,并奖励一朵小红花~~~~

答案:

public class Student{


private String name;

private int age;

private double grade;

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 double getGrade() {

return grade;

}

public void setGrade(double grade) {

this.grade = grade;

}

public Student(String name, int age, double grade) {

super();

this.name = name;

this.age = age;

this.grade = grade;

}

public Student() {

super();

}

public char getMyGrade(){


if(80<grade&&grade<=100){

return 'A';

}

if(60<grade&&grade<=80){

return 'B';

}

if(0<grade&&grade<=60){

return 'C';

}

return 0 ;


}


}

public class Test_3 {


public static void main(String[] args) {


ArrayList<Student>  arr = new ArrayList<>();

arr.add(new Student("张三",11,100));

arr.add(new Student("李四",12,80));

arr.add(new Student("王五",13,70.5));

mehtod(arr);

}

private static void mehtod(ArrayList<Student> arr) {


for (int i = 0; i < arr.size(); i++) {

Student student = arr.get(i);

if(student.getMyGrade()=='A'){

System.out.println("奖励"+student.getName()+"同学一个小红花");

}

}


}

}

第4章 ArrayList集合封装练习

4.1 存储自定义对象并遍历

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 Demo03ArrayListTest {

public static void main(String[] args) {

//创建集合对象

ArrayList<Student> array = new ArrayList<Student>();


//创建学生对象

Student s1 = new Student("赵丽颖",18);

Student s2 = new Student("唐嫣",20);

Student s3 = new Student("景甜",25);

Student s4 = new Student("柳岩",19);


//把学生对象作为元素添加到集合中

array.add(s1);

array.add(s2);

array.add(s3);

array.add(s4);


//遍历集合

for(int x=0; x<array.size(); x++) {

Student s = array.get(x);

System.out.println(s.getName()+"---"+s.getAge());

}

}

}


4.2 创建一个集合,存储学生对象,学生对象的数据来自于键盘录入,最后,遍历集合

public class Student {

private String name;

private String age;

public Student() {

}

public Student(String name, String age) {

this.name = name;

this.age = age;

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public String getAge() {

return age;

}

public void setAge(String age) {

this.age = age;

}

}

public class Demo04ArrayListTest {

public static void main(String[] args) {

//创建集合对象

ArrayList<Student> list = new ArrayList<Student>();


//为了提高代码的复用性,我把键盘录入数据给学生对象,并存储到集合中的动作用一个方法来实现


//调用方法

addStudent(list);

addStudent(list);

addStudent(list);


//遍历集合

for(int x=0; x<list.size(); x++) {

Student s = list.get(x);

System.out.println(s.getName()+"---"+s.getAge());

}

}


/*

* 两个明确:

* 返回值类型:void

* 参数列表:ArrayList<Student> list

*/

public static void addStudent(ArrayList<Student> list) {

//键盘录入数据,创建学生对象,把键盘录入的数据赋值给学生对象的成员变量

Scanner sc = new Scanner(System.in);

System.out.println("请输入学生姓名:");

String name = sc.nextLine();

System.out.println("请输入学生年龄:");

String age = sc.nextLine();


Student s = new Student();

s.setName(name);

s.setAge(age);


//把学生对象作为元素存储到集合中

list.add(s);

}

}

4.3 学生管理系统ArrayList集合

4.3.1 学生管理系统项目演示

4.3.2 学生管理系统之标准学生类

public class Student {

//学号

private String id;

//姓名

private String name;

//年龄

private String age;

//居住地

private String address;

public Student() {


}

public Student(String id, String name, String age, String address) {

this.id = id;

this.name = name;

this.age = age;

this.address = address;

}

public String getId() {

return id;

}

public void setId(String id) {

this.id = id;

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public String getAge() {

return age;

}

public void setAge(String age) {

this.age = age;

}

public String getAddress() {

return address;

}

public void setAddress(String address) {

this.address = address;

}

}


4.3.3 学生管理系统的主类

public class StudentManager {

public static void main(String[] args) {

//创建集合对象,用于存储学生数据

ArrayList<Student> list = new ArrayList<Student>();


//为了让程序能够回到这里来,我们使用循环

while(true) {

//这是学生管理系统的主界面

System.out.println("--------欢迎来到学生管理系统--------");

System.out.println("1 查看所有学生");

System.out.println("2 添加学生");

System.out.println("3 删除学生");

System.out.println("4 修改学生");

System.out.println("5 退出");

System.out.println("请输入你的选择:");

//创建键盘录入对象

Scanner sc = new Scanner(System.in);

String choiceString = sc.nextLine();

//switch语句实现选择

switch(choiceString) {

case "1":

//查看所有学生

findAllStudent(list);

break;

case "2":

//添加学生

addStudent(list);

break;

case "3":

//删除学生

deleteStudent(list);

break;

case "4":

//修改学生

updateStudent(list);

break;

case "5":

//退出

//System.out.println("谢谢你的使用");

//break;

default:

System.out.println("谢谢你的使用");

System.exit(0); //JVM退出

break;

}

}

}


/*

* 修改学生的方法

* 修改学生的思路:键盘录入一个学号,到集合中去查找,看是否有学生使用的是该学号,如果有就修改该学生

*/

public static void updateStudent(ArrayList<Student> list) {

//创建键盘录入对象

Scanner sc = new Scanner(System.in);

System.out.println("请输入你要修改的学生的学号:");

String id = sc.nextLine();


//定义一个索引

int index = -1;


//遍历集合

for(int x=0; x<list.size(); x++) {

//获取每一个学生对象

Student s = list.get(x);

//拿学生对象的学号和键盘录入的学号进行比较

if(s.getId().equals(id)) {

index = x;

break;

}

}


if(index == -1) {

System.out.println("不好意思,你要修改的学号对应的学生信息不存在,请回去重新你的选择");

}else {

System.out.println("请输入学生新姓名:");

String name = sc.nextLine();

System.out.println("请输入学生新年龄:");

String age = sc.nextLine();

System.out.println("请输入学生新居住地:");

String address = sc.nextLine();


//创建学生对象

Student s = new Student();

s.setId(id);

s.setName(name);

s.setAge(age);

s.setAddress(address);


//修改集合中的学生对象

list.set(index, s);


//给出提示

System.out.println("修改学生成功");

}

}


/*

* 删除学生的方法

* 删除学生的思路:键盘录入一个学号,到集合中去查找,看是否有学生使用的是该学号,如果有就删除该学生

*/

public static void deleteStudent(ArrayList<Student> list) {

//创建键盘录入对象

Scanner sc = new Scanner(System.in);

System.out.println("请输入你要删除的学生的学号:");

String id = sc.nextLine();


//我们必须给出学号不存在的时候的提示

//定义一个索引

int index = -1;


//遍历集合

for(int x=0; x<list.size(); x++) {

//获取到每一个学生对象

Student s = list.get(x);

//拿这个学生对象的学号和键盘录入的学号进行比较

if(s.getId().equals(id)) {

index = x;

break;

}

}


if(index == -1) {

System.out.println("不好意思,你要删除的学号对应的学生信息不存在,请回去重新你的选择");

}else {

list.remove(index);

System.out.println("删除学生成功");

}

}

//添加学生的方法

public static void addStudent(ArrayList<Student> list) {

//创建键盘录入对象

Scanner sc = new Scanner(System.in);


//为了让id能够被访问到,我们就把id定义在了循环的外面

String id;


//为了让代码能够回到这里,用循环

while(true) {

System.out.println("请输入学生学号:");

//String id = sc.nextLine();

id = sc.nextLine();


//判断学号有没有被人占用

//定义标记

boolean flag = false;

//遍历集合,得到每一个学生

for(int x=0; x<list.size(); x++) {

Student s = list.get(x);

//获取该学生的学号,和键盘录入的学号进行比较

if(s.getId().equals(id)) {

flag = true; //说明学号被占用了

break;

}

}


if(flag) {

System.out.println("你输入的学号已经被占用,请重新输入");

}else {

break; //结束循环

}

}



System.out.println("请输入学生姓名:");

String name = sc.nextLine();

System.out.println("请输入学生年龄:");

String age = sc.nextLine();

System.out.println("请输入学生居住地:");

String address = sc.nextLine();


//创建学生对象

Student s = new Student();

s.setId(id);

s.setName(name);

s.setAge(age);

s.setAddress(address);


//把学生对象作为元素添加到集合

list.add(s);


//给出提示

System.out.println("添加学生成功");

}


//查看所有学生

public static void findAllStudent(ArrayList<Student> list) {

//首先来判断集合中是否有数据,如果没有数据,就给出提示,并让该方法不继续往下执行

if(list.size() == 0) {

System.out.println("不好意思,目前没有学生信息可供查询,请回去重新选择你的操作");

return;

}


//\t 其实就是一个tab键的位置

System.out.println("学号\t\t姓名\t年龄\t居住地");

for(int x=0; x<list.size(); x++) {

Student s = list.get(x);

System.out.println(s.getId()+"\t"+s.getName()+"\t"+s.getAge()+"\t"+s.getAddress());

}

}

}

第5章 综合案例---随机点名案例重构

5.0.1 案例介绍与演示

将第6天的随机点名的案例由之前简单的Person对象,重构为相对完整的Person对象并使用。

5.0.2 案例回顾

在全班同学中随机地打印出一名同学名字。

共三个步骤:

1.存储全班同学(Person对象)

2.打印全班同学每一个人的名字

3.在班级总人数范围内,随机产生一个随机数索引,查找该随机数索引所对应的同学(Person对象),并通过该对象访问name属性

5.0.3 重构内容分析

将原来使用的简单Person类,封装为包装成员变量和成员方法的相对完整的Person类,并将所有访问属性的地方改为通过get/set方法访问。

/*

自定义类型 人类

属性

姓名  String

年龄  int

性别  String

身高  double

是否热爱java  boolean

*/

public class Person {

// 姓名

String name;

// 年龄

int age;

// 性别

String sex;

// 身高

double height;

// 是否喜欢java

boolean isLoveJava;

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 String getSex() {

return sex;

}

public void setSex(String sex) {

this.sex = sex;

}

public double getHeight() {

return height;

}

public void setHeight(double height) {

this.height = height;

}

public boolean isLoveJava() {

return isLoveJava;

}

public void setLoveJava(boolean isLoveJava) {

this.isLoveJava = isLoveJava;

}

}

/*

随机点名器

用集合存储所有同学

总览全班同学姓名

随机点名其中一人,打印到控制台

1.定义一个集合用来存储所有同学

导包  

创建对象 存储的是Person

调用方法

2.向集合中添加人


3.遍历集合,依次获取每个人,打印每个人的名字

4.随机点名

生成一个最大不超过集合最大索引的随机数   0 - 集合最大索引的一个随机数

依据随机数得到集合中相对应的人,打印其名字

*/

//导入集合ArrayList

import java.util.ArrayList;

import java.util.Random;

public class RandomName

{

public static void main(String[] args)

{

//定义一个集合用来存储所有人

ArrayList<Person> list = new ArrayList<Person>();


//向集合中添加人  创建Person对象 将Person添加到集合中

Person p = new Person();

p.setName("柳岩");

Person p2 = new Person();

p2.setName("唐嫣");

Person p3 = new Person();

p3.setName("金莲");


list.add(p);

list.add(p2);

list.add(p3);


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

//遍历集合,依次获取每个人,打印每个人的名字

for(int i = 0 ;i < list.size();i++){

Person thisP = list.get(i);

//调用getName方法 获取每个人的名字

System.out.println(thisP.getName());  

}


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

//随机点名

Random r = new Random();

//生成一个最大不超过集合最大索引的随机数   0 - 集合最大索引的一个随机数

int randomIndex = r.nextInt(list.size());

//依据随机数得到集合中相对应的人

Person person = list.get(randomIndex);

System.out.println("今天你答题:"+person.getName());  

}

}

第6章  超市购物小票

6.1 案例介绍与演示

模拟真实购物逻辑,以上述图片为需求原型,根据不同购物物品完成购物小票内容打印到控制台。(简化项目逻辑,票脚部分只完成数据统计)

数据:

  • 将超市购物小票案例中零散数据(名称、货号、单价、数量、计价单位、金额)封装为货物对象。

  • 所有的货物对象放置到集合中统一管理。

逻辑:

用户循环进行三个操作:

  • 输入购买数量,代表为所有货物的数量赋值,从而计算每项商品金额

  • 打印小票,将已有数据打印

  • 退出系统(因为该程序为循环操作,无法终止,如果不想再进行操作,则退出系统)


6.1.1 案例分析

a) 涉及SE基础内容

变量定义:记录部分数据

集合的使用:用于存储多个完整数据

运算符的使用:计算变量

流程控制语句的使用:

  • if语句:用于判断是否购买了商品

  • switch语句:用于进行三个操作(输入购买数量、打印小票、退出系统)的分支

  • for/while语句:switch外部使用for/while循环,当执行一个操作后,继续进行下一个操作选择

方法封装:

由于代码量比较多,可以将输入购买数量、打印小票封装为方法使用

字符串/键盘录入:

打印小票完整过程均为字符串的拼写及打印,数量输入为键盘录入Scanner完成


b) 实现步骤

  • 定义GoodsItem类(名称、货号、单价、数量、计价单位、金额)

/*

* 定义商品项类:

* 名称,货号,单价,数量,计价单位,金额

*/

public class GoodsItem {

// 成员变量

private String name;

private String id;

private double price;

private int number;

private String unit;

private double money;

// 构造方法

public GoodsItem() {

}

public GoodsItem(String name, String id, double price, int number, String unit, double money) {

this.name = name;

this.id = id;

this.price = price;

this.number = number;

this.unit = unit;

this.money = money;

}



// getters/setters

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public String getId() {

return id;

}

public void setId(String id) {

this.id = id;

}

public double getPrice() {

return price;

}

public void setPrice(double price) {

this.price = price;

}

public int getNumber() {

return number;

}

public void setNumber(int number) {

this.number = number;

}

public String getUnit() {

return unit;

}

public void setUnit(String unit) {

this.unit = unit;

}

public double getMoney() {

return money;

}

public void setMoney(double money) {

this.money = money;

}

}

  • 成员位置定义集合,定义方法向集合中存储所有GoodsItem数据

public class ShoppingReceipt {

//成员位置定义集合,存储所有的商品项对象

 static ArrayList<GoodsItem> data = new ArrayList<GoodsItem>();

}

  • 实现主干逻辑

    • 打印欢迎语句

public static void main(String[] args) {


//打印欢迎语句

       System.out.println("欢迎使用超市管理系统!");

    • 物品展示与购买界面  initData()方法

      //main方法中添加 为集合准备数据

initData();

//定义方法,向成员位置的集合赋值

public static void initData() {


//创建多个商品项对象

GoodsItem sls = new GoodsItem("少林寺核桃", "090115", 15.5, 0, "个", 0);

GoodsItem shk = new GoodsItem("尚康饼干", "090027", 14.5, 0, "个", 0);

//将多个商品项对象放入集合中

data.add(sls);

data.add(shk);

}

使用for/while进行循环进行操作  

使用switch给出操作选择:1输入购买数量2打印小票3退出

完成switch中三个case的逻辑

//使用死循环完成反复操作的逻辑

//for(;;) {}

while(true) {

//使用switch给出操作选择:1输入购买数量2打印小票3退出

//提示信息

System.out.println("请输入您要进行的操作:1输入购买数量   2打印小票   3退出");


//通过键盘录入得到数据

Scanner sc = new Scanner(System.in);

int optNumber = sc.nextInt();

//完成switch中三个case的逻辑

switch (optNumber) {

case 1:

//调用给所有数据的数量与金额赋值方法

enterNumber();

break;

case 2:

//调用打印购物小票的方法

printReceipt();

break;

case 3:

System.out.println("欢迎下次光临");

//退出程序

System.exit(0);

default:

System.out.println("请输入正确的数字!");

break;

}

}

运用方法封装功能:将1输入购买数量、2打印小票封装为独立方法,在case中调用,提高代码可读性。

   /**

* 为所有的数据赋值数量与金额

*/

public static void enterNumber() {


//集合的遍历

for (int i = 0; i < data.size(); i++) {

//依次获取到集合中每一个元素

GoodsItem thisGoods = data.get(i);


//提示用户,输入该商品项的数量

//获取该商品项名称

String thisGoodsName = thisGoods.getName();

System.out.println("请输入"+thisGoodsName+"的购买数量");


//键盘录入接受商品数量

Scanner sc = new Scanner(System.in);

int thisGoodsNumber = sc.nextInt();

//根据数量计算金额     金额 = 单价 * 数量

double thisGoodsMoney = thisGoods.getPrice() * thisGoodsNumber;


//为该商品的数量与金额赋值

thisGoods.setNumber(thisGoodsNumber);

thisGoods.setMoney(thisGoodsMoney);

}

}


/**

* 定义打印小票方法

*/

private static void printReceipt() {

//static ArrayList<GoodsItem> data = new ArrayList<GoodsItem>();

//票头

System.out.println("    欢  迎  光  临");

System.out.println("品名    售价   数量    单位  金额");

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

//票体

//定义变量,记录所有的商品数量

int totalNumber = 0;

//定义变量,记录所有的商品金额

double totalMoney = 0;

//便利集合

for (int i = 0; i < data.size(); i++) {

//依次获取每一个商品项

GoodsItem g = data.get(i);

//打印商品项

System.out.println(""+g.getName()+g.getId()+"  "+g.getPrice()+"  "+g.getNumber()+"  "+g.getUnit()+"  "+g.getMoney());


//累加数量与金额

totalNumber += g.getNumber();

totalMoney += g.getMoney();

}

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

//票脚

System.out.println("共"+data.size()+"项商品");

System.out.println("共"+totalNumber+"件商品");

System.out.println("共"+totalMoney+"元");

System.out.println();

}




支付宝赞助-Java帮帮社区
微信赞助-Java帮帮社区
Java帮帮公众号生态

Java帮帮公众号生态

总有一款适合你

Java帮帮-微信公众号

Java帮帮-微信公众号

将分享做到极致

Python帮帮-公众号

Python帮帮-公众号

人工智能,爬虫,学习教程

大数据驿站-微信公众号

大数据驿站-微信公众号

一起在数据中成长

九点编程-公众号

九点编程-公众号

深夜九点学编程

程序员生活志-公众号

程序员生活志-公众号

互联网,职场,程序员那些事儿

Java帮帮学习群生态

Java帮帮学习群生态

总有一款能帮到你

Java学习群

Java学习群

与大牛一起交流

大数据学习群

大数据学习群

在数据中成长

九点编程学习群

九点编程学习群

深夜九点学编程

python学习群

python学习群

人工智能,爬虫

测试学习群

测试学习群

感受测试的魅力

Java帮帮生态承诺

Java帮帮生态承诺

一直坚守,不负重望

初心
勤俭
诚信
正义
分享
合作品牌 非盈利生态-优质内容分享传播者
友链交换:加帮主QQ2524138991 留言即可 24小时内答复  
会员登录
获取验证码
登录
登录
我的资料
留言
回到顶部