第九天 面向对象-类,封装,对象,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);

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

//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.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;

}

}

/*

* 测试Person类

*

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

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

* 调用方法

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

*

*

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

* 指的是

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

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

*/

public class Test {

public static void main(String[] args) {

//创建对象

Person p= new Person();

//调用方法

p.setName("柳岩");

p.setAge(38);

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

//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与setterpublic 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与setterpublic 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;} // getter与setterpublic 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帮帮(javahelp)

原文发表时间:2018-05-23

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏技术小黑屋

说说依赖注入

在面向对象编程中,我们经常处理处理的问题就是解耦,程序的耦合性越低表明这个程序的可读性以及可维护性越高。控制反转(Inversion of Control或Io...

483
来自专栏CLEAN_CODER

Java泛型•认识泛型

这段代码看似功能强大,为什么呢?因为它似乎能够往集合添加各种类型的对象(int类型会被装箱成Integer对象类型),貌似一些老程序员也倾向于这么去做,而且他们...

1022
来自专栏Python小屋

Python中的依赖注入实现原理

依赖注入(Dependency Injection)又称控制反转(Inversion of Control)主要用来实现不同模块或类之间的解耦,可以根据需要动态...

3405
来自专栏Java帮帮-微信公众号-技术文章全总结

Java基础-07(02).总结private,this,封装,static,成员方法变量,局部变量匿名对象

9:面向对象的练习题(掌握) (1)标准的手机类的定义和测试 (2)Demo类有求和方法,Test类进行测试。 什么时候定义成员变量? 当该变量是用来描...

2783
来自专栏陈树义

大白话说Java泛型:入门、使用、原理

远在 JDK 1.4 版本的时候,那时候是没有泛型的概念的。当时 Java 程序员们写集合类的代码都是类似于下面这样: List list = new Arr...

3336
来自专栏Web 开发

JavaScript的对象引用

在一个函数体内,var变量声明的变量,其作用域只在该函数体内,对于函数体外而言,是不可见的(废话)。

670
来自专栏云霄雨霁

Java--运行期类型鉴定(RTTI)

1505
来自专栏LinkedBear的个人空间

唠唠SE的面向对象-01——对象 原

每个对象都有自己独特的状态标识和行为对象的属性(attribute),或者状态(state)。

592
来自专栏web前端-

面向对象的几种设计模式

其实面向对象是相对于面向过程而言,通俗来说就是创建对象,每个对象有自身的属性和方法,对象.属性  对象.方法 实际上这已经是一个面向对象的过程了,面向过程,是指...

984
来自专栏技术博客

Knockout.Js官网学习(加载或保存JSON数据)

Knockout可以实现很复杂的客户端交互,但是几乎所有的web应用程序都要和服务器端交换数据(至少为了本地存储需要序列化数据),交换数据最方便的就是使用JSO...

1002

扫码关注云+社区