下载文档原格式
常用封装总结常用封装是软件开发中的一种常见技术手段，用于将一组相关的功能或操作封装在一个独立的模块中，方便重复使用和维护。
下面是一些常用封装的总结，包括函数封装、类封装和接口封装。
1.函数封装：函数封装是最基本也是最常用的封装方式之一、通过将一组相关的语句封装在一个函数中，可以提高代码的可读性和可维护性，同时也方便重复使用。
常见的函数封装包括：-输入检查：在函数中对输入参数进行检查，判断其是否符合预期的类型、范围或格式，如果不符合，则抛出异常或返回错误码。
-错误处理：在函数中对可能发生的错误进行处理，例如网络连接错误、文件读取错误等，可以通过异常处理机制来处理这些错误，提高代码的健壮性。
-日志记录：在函数中添加日志记录功能，可以用于排查问题和性能优化。
-代码复用：将一段常用的代码逻辑封装为函数，可以方便其他地方调用，减少重复代码。
-容错处理：在函数中处理异常情况，确保程序的正常运行。
例如，对于文件读取操作，如果文件不存在，可以在函数中进行处理，避免程序崩溃。
2.类封装：类封装是以面向对象的思想来进行封装的一种方式。
通过将属性和方法封装在一个类中，可以将相关的功能和数据组织在一起，提高代码的可维护性和可扩展性。
-封装属性：将对象的属性封装在类的内部，通过提供公共的接口方法来访问和修改属性的值，实现属性的封装和保护，避免外部直接访问和修改属性值。
-封装方法：将一组相关的操作封装在类的方法中，通过对象的方法来实现对属性的操作，实现了数据与操作的封装。
-继承封装：通过继承机制，派生出不同的子类，实现代码的复用和扩展。
子类可以继承父类的属性和方法，并可以通过重写父类的方法来实现个性化的功能。
-抽象封装：通过接口或抽象类定义一组规范，由具体的子类来实现该规范，实现了数据与操作的解耦。
3.接口封装：接口是一种将功能逻辑与实现逻辑相分离的封装方式，通过定义接口规范，将不同的实现类解耦。
接口封装的常见场景有：-多态封装：通过接口来实现多态，将对象的具体类型与其使用的方式解耦，提高代码的灵活性和可扩展性。
类的封装规则一、类的封装规则概述1.1 定义与概念类的封装规则是一种面向对象编程的策略，其核心思想是将对象的属性和行为封装成一个独立的实体，称为类。
类的封装性是一种把数据（变量）和与数据相关的操作（函数）结合在一起的特性。
这种特性有效地隐藏了数据的细节，只通过类的方法来与外界交互。
类的封装性可以增强代码的安全性、可读性和可维护性。
1.2 历史与发展类的封装规则源于20世纪70年代的面向对象编程（OOP）思想。
在早期的程序设计中，为了提高代码的可维护性和可重用性，人们开始尝试将数据和操作封装在一起，形成了类的概念。
随着计算机技术的不断发展，面向对象编程逐渐成为主流的编程范式，类的封装规则也得到了广泛应用。
二、类的封装规则基本概念2.1 封装定义封装是指将数据（变量）和与数据相关的操作（函数）结合在一起，形成一个独立的实体，即类。
这个实体可以对外界隐藏其内部实现细节，只通过类的方法来与外界进行交互。
2.2 封装原则类的封装原则通常包括：隐藏数据、只通过公共方法访问数据、封装可变性和封装实现细节。
这些原则有助于提高代码的可维护性和可重用性。
2.3 封装方法常见的封装方法包括：构造函数、访问器方法（getter和setter）、私有变量、公共变量等。
这些方法可以帮助我们实现数据的封装和控制，确保数据的正确性和安全性。
三、类的封装规则在编程中的应用3.1 面向对象编程应用面向对象编程是一种基于对象概念的编程范式，它使用类和对象来描述现实世界中的实体和它们之间的关系。
类的封装规则是面向对象编程的核心特征之一，它可以将数据和相关操作封装在一起，形成一个独立的实体，以实现代码的可重用性和可维护性。
3.2 数据抽象应用类的封装规则可以通过数据抽象来实现对数据的隐藏和控制。
通过将数据封装在类中，我们可以实现对数据的访问控制和安全性保护，避免外部代码直接访问和修改数据的细节，从而提高了代码的可维护性和可重用性。
3.3 信息隐蔽应用类的封装规则还可以实现信息隐蔽，即将类的实现细节隐藏起来，只向外部提供必要的接口和方法。
java中类的构造方法Java中的类的构造方法在Java中，类是面向对象编程中最基本的概念之一。
类用于封装数据和操作，它是创建对象的模板。
在创建类时，我们通常需要定义一个或多个构造方法来初始化对象。
构造方法是在实例化类时被调用的特殊方法，它用于设置类的初始状态。
一、什么是构造方法？构造方法是一种特殊的方法，它没有返回类型，并且与类名相同。
构造方法在创建一个新的对象时被调用，它负责初始化对象的数据成员。
每当使用new关键字创建一个对象时，构造方法就会被自动调用。
构造方法的主要任务是为对象分配内存，并对实例变量进行初始化。
它可以确保对象在被使用之前处于一个有效的状态。
构造方法负责执行任何必要的设置操作，例如设置默认值、创建其他对象或者连接到数据库。
构造方法可以有不同的参数列表。
它可以接受零个或多个参数，并且可以通过参数的类型和数量来区分不同的构造方法。
二、为什么需要构造方法？构造方法的主要目的是初始化对象。
在Java中，如果类没有显式定义构造方法，编译器将自动生成一个默认的构造方法。
默认构造方法不接受任何参数，它仅仅执行一些基本的初始化操作，例如为实例变量设置默认值。
然而，在实际开发中，我们往往需要根据不同的需求来创建不同类型的对象。
通过定义不同的构造方法，我们可以根据不同的参数组合来初始化对象的属性，从而提供更灵活、更易用的对象创建方式。
构造方法还可以用于执行其他额外的初始化工作，例如建立数据库连接、加载配置文件或者执行某些设置操作。
通过在构造方法中执行这些工作，我们可以确保对象在被使用之前处于正确的状态。
三、如何定义构造方法？在Java中，定义构造方法与定义普通方法类似，但有几个关键点需要注意：1. 构造方法没有返回类型，包括void。
因此，构造方法不需要使用return 语句来返回值。
2. 构造方法的名称必须与类名完全相同。
3. 可以定义多个构造方法，只要它们的参数列表不同。
这被称为构造方法的重载。
封装知识点总结一、封装的概念封装是面向对象编程中的一个重要概念，它指的是将数据和方法封装到一个抽象的数据类型中，从而隐藏数据的实现细节，只暴露必要的接口给外部使用。
通过封装，我们可以将一个复杂的系统拆分成几个相互独立的模块，提高代码的可复用性和可维护性。
在封装中，通常会使用访问修饰符来控制类的成员变量和方法的访问权限。
常见的访问修饰符包括public、private和protected，它们分别表示公有、私有和受保护的成员，用来控制外部对类的成员的访问。
二、封装的优点封装具有以下几个优点：1. 隐藏细节：通过封装，可以隐藏数据的实现细节，只暴露必要的接口给外部使用。
这样可以降低类与类之间的耦合度，提高系统的灵活性和可维护性。
2. 简化接口：封装可以将一组相关的数据和方法组织成一个抽象的数据类型，从而简化系统的接口。
这样可以降低使用者对系统的理解和使用难度，提高系统的易用性。
3. 信息隐藏：通过封装，可以控制类的成员的访问权限，只暴露必要的接口给外部使用。
这样可以保护数据的安全性，防止数据被直接访问和修改，提高系统的安全性。
4. 提高可复用性：封装可以将功能代码封装到一个模块中，从而提高代码的可复用性。
这样可以降低系统开发和维护的成本，提高系统的效率和可靠性。
5. 方便维护：封装可以将功能代码封装到一个模块中，从而提高代码的可维护性。
这样可以方便对模块进行修改和扩展，提高系统的灵活性和可维护性。
三、封装的实现方式在面向对象编程中，通常会使用类和对象来实现封装。
一个类可以包含成员变量和方法，成员变量用来存储数据，方法用来操作数据。
通过访问修饰符，可以控制成员变量和方法的访问权限，从而实现数据的封装。
在Java语言中，可以通过访问修饰符来实现封装。
常见的访问修饰符包括public、private和protected，它们分别表示公有、私有和受保护的成员。
通过这些访问修饰符，可以控制类的成员的访问权限，只暴露必要的接口给外部使用。
杨校⽼师课堂之Java类与对象、封装、构造⽅法杨校⽼师课堂之Java类与对象、封装、构造⽅法本篇⽂章内容如下：⾯向对象类与对象三⼤特征——封装构造⽅法教学⽬标能够理解⾯向对象的思想能够明确类与对象关系能够掌握类的定义格式能够掌握创建对象格式，并访问类中的成员能够完成⼿机类的练习能够理解对象的内存图能够说出成员变量和局部变量的区别能够理解private关键字的含义能够说出this关键字可以解决的问题能够理解构造⽅法的含义能够⽤封装的思想定义⼀个标准类第1章⾯向对象思想1.1 ⾯向对象思想概述概述Java语⾔是⼀种⾯向对象的程序设计语⾔，⽽⾯向对象思想是⼀种程序设计思想，我们在⾯向对象思想的指引下，使⽤Java语⾔去设计、开发计算机程序。
这⾥的对象泛指现实中⼀切事物，每种事物都具备⾃⼰的属性和⾏为。
⾯向对象思想就是在计算机程序设计过程中，参照现实中事物，将事物的属性特征、⾏为特征抽象出来，描述成计算机事件的设计思想。
它区别于⾯向过程思想，强调的是通过调⽤对象的⾏为来实现功能，⽽不是⾃⼰⼀步⼀步的去操作实现。
举例洗⾐服:⾯向过程：把⾐服脱下来-->找⼀个盆-->放点洗⾐粉-->加点⽔-->浸泡10分钟-->揉⼀揉-->清洗⾐服-->拧⼲-->晾起来⾯向对象：把⾐服脱下来-->打开全⾃动洗⾐机-->扔⾐服-->按钮-->晾起来区别:⾯向过程：强调步骤。
⾯向对象：强调对象，这⾥的对象就是洗⾐机。
特点⾯向对象思想是⼀种更符合我们思考习惯的思想，它可以将复杂的事情简单化，并将我们从执⾏者变成了指挥者。
⾯向对象的语⾔中，包含了三⼤基本特征，即封装、继承和多态1.2 类和对象环顾周围，你会发现很多对象，⽐如桌⼦，椅⼦，同学，⽼师等。
桌椅属于办公⽤品，师⽣都是⼈类。
那么什么是类呢？什么是对象呢？什么是类类：是⼀组相关属性和⾏为的集合。
可以看成是⼀类事物的模板，使⽤事物的属性特征和⾏为特征来描述该类事物。
类的封装与构造方法首先来回顾一下前面文章的一个知识点：面向对象的三个基本特征是封装、继承和多态。
这次我们主要来学习一下封装。
封装的特点：1.让使用者只能通过实现制定好的方法来访问数据，可以方便地加入控制逻辑来限制对属性的不合理操作。
2.便于修改，增强代码的可维护性。
一．类封装的实现我们首先还是来分析一段代码：class Person{String name;int age;public String shout(){return "姓名:"++"\n年龄"+this.age;}}public class oDemo02{public static void main(String args[])Person p1=new Person();="小明";p1.age=-30;System.out.println(p1.shout());}}我们不难看出，这段代码与前面文章所出现的代码是很类似的，这里只把一些前面没有出现过的新特点分析一下：代码中Person类的shout方法是带有返回值的，并且规定了返回值的类型是String。
这个方法被public类中的主方法所调用，我们前面提到过，把功能模块放到其他的类中，使得public类就像一个客户端，这是Java中比较推荐的做法。
下面是程序执行的结果：看完结果我们会提出一个问题：这段代码可以正常运行，说明在语法上来说是完全正确的。
但是从输出的数值来看，年龄为-30岁，这在逻辑上是说不通的。
因此我们想要为程序添加一个检错机制，当有不适合的值输入或调用时，就会报错，这也是保证程序健壮性的要求。
我们可以用一个简单的封装来解决这个问题，先来看下面改进后的代class Person{private String name;private int age;public void setName(String n) {name=n;}public void setAge(int a){if(a>0&&a<150){age=a;}else{age=-1;}}public String getName(){return name;}public int setAge(){return age;}public String shout(){return "姓名:"++"\n年龄"+this.age;}}public class oDemo02{public static void main(String args[]){Person p1=new Person();p1.setName("小明");p1.setAge(-30);System.out.println(p1.shout());}}对以上代码的几点说明：1.蓝字部分是用关键字private定义属性的私有类，如此定义之后，外部类的方法就不能再直接使用对象中的这些属性，而必须通过调用红字部分的方法（getName、setName、getAge、setAge）来实现对这些属性值的传递和更改。
java基础：封装、继承、多态封装⼀、封装的好处1、提⾼安全性2、提⾼复⽤性3、将复杂的事情简单化⼆、Java中的封装体1、⽅法安全性：调⽤者不知道⽅法的具体实现2、复⽤性：⽅法可以被重复使⽤3、简单化：将繁多的代码以⼀个⽅法的⽅式呈现，仅通过调⽤⽅法就可以实现功能；代码维护也变得简单类三、private修饰成员变量四、构造⽅法构建、创造，也叫构造器，⽤来帮助创建对象的⽅法，准确的说，构造⽅法的作⽤是初始化对象格式：修饰符构造⽅法名(参数列表){//⽅法体}public class Student {public Student(String name, int age) { = name;this.age = age;}public String name;private int age;public void study() {System.out.println();System.out.println("-------------------");System.out.println(this.age);}}要求：1、⽅法名必须与类名相同2、没有返回值3、没有返回值类型注意事项1、若未提供任何构造⽅法，系统会给出默认⽆参构造2、若已提供任何构造⽅法，系统不再提供⽆参构造3、构造⽅法可以重载Java中封装的概念将⼀系列相关事物共同的属性和⾏为提取出来，放到⼀个类中，隐藏对象的属性和实现细节，仅对外提供公共的访问⽅式。
隐藏对象数据的实现细节，意味着⼀个类可以全⾯的改变存储数据的⽅式，只要使⽤同样的⽅法操作数据，其它对象就不会知道或介意所发⽣的变化。
封装的关键==绝对不能让类中的⽅法直接访问其它类的数据（属性），程序仅通过对象的⽅法与对象的数据进⾏交互继承⼀、Java中的继承通过扩展⼀个类来建⽴另外⼀个类的过程，叫做继承（inheritance）通俗地说，所谓继承，就是让类与类之间产⽣⽗⼦关系。
python封装方法Python是一种高级编程语言，它支持面向对象编程。
在面向对象编程中，封装是一种重要的概念。
封装是指将数据和方法打包在一起，以便于隐藏数据并确保数据的安全性。
Python提供了多种方法来实现封装。
本文将介绍Python中的封装方法。
一、属性属性是一种特殊的方法，它用于控制类的实例变量的访问。
属性提供了对变量的访问控制，以确保变量不被错误地修改或访问。
Python中使用@property和@setter装饰器来定义属性。
1. @property@property装饰器用于定义只读属性。
只读属性是指不能修改值的属性。
下面是一个例子：```class Person:def __init__(self, name):self._name = name@propertydef name(self):return self._name```在这个例子中，Person类有一个只读属性name。
该属性返回私有变量_name的值。
2. @setter@setter装饰器用于定义可写属性。
可写属性是指可以修改值的属性。
下面是一个例子：```class Person:def __init__(self, name):self._name = name@propertydef name(self):return self._name@name.setterdef name(self, value):self._name = value```在这个例子中，Person类有一个可写属性name。
该属性允许修改私有变量_name的值。
二、方法方法是一种用于执行操作的函数。
在Python中，方法可以被定义为类的成员函数。
方法通常用于封装数据，以确保数据不被错误地修改或访问。
1. 公有方法公有方法是指可以从类的外部访问的方法。
公有方法通常用于执行操作并返回结果。
下面是一个例子：```class Calculator:def add(self, x, y):return x + y```在这个例子中，Calculator类有一个公有方法add。
vue组件封装的方法
Vue组件封装的方法有很多种，以下是一些常用的方法：
1. 使用vue-cli创建组件：可以使用vue-cli创建一个新的组件，该组件包含了基本的结构和配置，可以直接进行开发。
2. 单文件组件封装：将Vue组件的模板、样式和逻辑代码封
装在一个单文件组件中。
单文件组件使用.vue的后缀名，在该文件中可以写模板、样式和逻辑代码。
3. 使用插件封装：将一些通用的功能封装成插件，提供给其他组件使用。
可以使用e()方法来安装插件，然后在组件
中使用插件提供的功能。
4. 使用mixin混入：使用mixin可以将一些公共的代码混入到
多个组件中去。
可以在mixin中定义一些通用的方法、数据和
生命周期钩子函数，然后在组件中使用mixins选项来混入这
些功能。
5. 使用slot插槽：插槽可以用于在组件中插入内容，可以根据需要在组件中定义插槽，并在组件的使用者中填充插槽的内容。
这样可以让组件更加灵活和可复用。
6. 使用props属性传递数据：可以使用props属性在父组件和
子组件之间传递数据，父组件通过props属性向子组件传递数据，子组件通过props属性接收父组件传递过来的数据。
这些都是常用的Vue组件封装方法，可以根据实际情况选择适合自己的方法进行组件封装。
1面向对象1.1万物皆对象我们是怎么认识世界的？人类从小就不断的接触到各种各类存在世界上的各种生物，然后通过事物的公共特性，将它们归类，所以以后就不会出现见到猫叫老虎。
那么我们在现实生活中，是通过具体的某个事物归纳总结它们的公共特性然后产生类那么类就描述了该种事物的的共别。
性，相当于造事物的图纸，我们可以根据这个图纸去做出具体的实体对象。
对象：在现实生活中存在具体的一个事物。
;类：实际就是对某种类型事物的共性属性与行为的抽取。
人类认识世界：对象----→类。
在java中：类-----→对象。
使用计算机语言就是不断的在描述现实生活中的事物。
java中描述事物通过类的形式体现，类是具体事物的抽象，概念上的定义。
对象即是该类事物实实在在存在的个体。
类与对象的关系如图图纸汽车A 汽车B 汽车C可以理解为：类就是图纸汽车就是堆内存中的对象1.2 面向对象的概述“面向对象”(英语：Object Oriented,简称OO)是一种以事物为中心的编程思想。
面向对象程序设计（英语：Object-oriented programming，缩写：OOP），是一种程序开发的方法。
它将对象作为程序的基本单元，将程序和数据封装其中，以提高软件的重用性、灵活性和扩展性。
面向对象时相对于面向过程而已的（c则是一个典型的面向过程的语言），站在面向对象的角度去看问题，你则是对象的动作的指挥者。
如果站在面向过程的角度去看问题，你则是动作的执行者。
1.3 面向对象与面向过程对比“万物皆对象”。
1：买电脑1：面向过程1：查资料2：电脑城砍价3：被黑4：痛苦归来1：面向对象1：找对象。
老师2：老师.砍价3：老师.检测电脑4：电脑成功购买2：吃饭1：面向过程1：自己动手做2：买菜3：洗菜4：煮饭炒菜5：很难吃，浪费时间2：面向对象1：找专业对象2：餐馆.点餐3：餐馆，做饭4：饭好吃，节约时间，精力4：找对象1：求介绍，相亲，找现成的对象。
（面向对象的思想先找有的对象，直接拿来使用）2：不满意，没有对象，自己造一个。
（sun没有提供，自己造对象）再例如：人开门，人开电视，人画园。
1.4 面向过程强调的是功能行为，面向过程”是一种以过程为中心的编程思想。
“面向过程”他们不支持丰富的“面向对象”特性（比如继承、多态），就是分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，使用的时候一个一个依次调用就可以了。
面向过程在这一系列工作的执行中，强调的是工作的执行。
1.5 对象对象（object）代表现实世界中可以明确标识的一个实体。
例如：一个学生、一张桌子、一间教室，一台电脑都可以看做是一个对象。
每个对象都有自己独特的状态标识和行为对象的属性（attribute，或者状态（state）），学生有姓名和学号，该学生特有的姓名和学号就是该学生（对象）的属性。
对象的行为（behavior），是由方法定义，调用对象的一个方法，其实就是给对象发消息，要求对象完成一个动作。
可以定义学生对象具备学习的行为。
学生对象可以调用学习的方法，执行学习的动作1.6面向对象的特征封装(encapsulation)继承(inheritance)多态(polymorphism)开发的过程：其实就是不断的创建对象，使用对象，指挥对象做事情。
设计的过程：其实就是在管理和维护对象之间的关系.1.7使用java来描述事物案例：通过Java语言定义一个汽车类，并生产出汽车，有颜色，轮胎个数，有运行的功能。
分析：如何描述现实世界中的事物，描述该事物的属性和行为，汽车具有颜色和轮胎数的属性，具备运行的行为。
如何使用Java语言进行转换？根据对应关系：属性：类中的成员变量行为：类中的成员函数那么定义Java类就是定义一个类的成员。
汽车类具备的成员是：颜色，轮胎数，运行方法。
Car类定义流程：1.使用class 关键字定义类，1.class空格类名。
类名就是标识符，命名规则，单词的首字母大写，多个单词的首字母大写。
注意：不是规定，但是最好遵守2.类名后紧跟一对{}表示类的开始和结束。
2.汽车有轮胎数 int num;1.不需要给num初始化值，因为汽车轮胎数不确定，有4，有6，有8。
3.有颜色String color1.为什么使用String 例如定义颜色"红色"是字符串类型。
2.也不需要初始化值。
4.跑的行为(方法、函数) void run(){}1.方法中执行输出语句。
syso("跑啦。
");public class Car {String color;// 成员变量int num; // 成员变量// 成员函数void run() {System.out.println(color+ "的车，轮胎数："+ num+ "个，跑起来了");}}1.8对象的创建创建Car对象1.使用new关键词，就像new数组一样2.需要给型的汽车起一个名字，car3.变量都是有类型的，car属于什么类型，属于Car类型，叫做类类型4.Car car=new Car();图纸画好了，类定义成功了。
如何根据图纸生产汽车，在Java中如何根据类来生产一个对象。
Java中生产汽车比较简单，通过一个关键字”new”, 通过 new Car(); 就在内存中产生了一个实体，汽车对象就生产出来了。
汽车对象生产出来后，还没有名字，为了方便使用，需要起一个名字。
就用小写的C 来表示新车的名字。
Java中的变量都需要有类型。
那么c 是什么类型呢？c 是Car类型，所以c也叫做类类型变量。
class CarDemo {public static void main(String[] args) {// java 中创建对象，使用new关键字。
在堆内存中开辟了空间。
产生了一个实体。
Car c = new Car();//为了方便使用生产的汽车，就起了一个名字。
//那么c是什么类型,是Car类型。
叫做类类型变量。
//注意 c是持有的引用，新生产的汽车并没有直接赋值给c，持有的只是一个引用。
c 就想电视遥控器一样。
c.run(); //使用对象的功能。
}}1.9对象成员的调用有了car对象，调用对象成员1.成员变量2.成员方法public class CarDemo {public static void main(String[] args) {Car c = new Car();//对象名.成员变量名将返回成员变量中存储的数值int num=c.num;System.out.println(num);//对象名.成员变量名,也可以给成员变量赋值c.num = 4;c.color = "black";//对象名.成员方法();c.run();}}1.8 局部变量和成员变量成员变量: 定义在类中变量局部变量: 定义在方法中变量成员变量与局部变量的区别：1.应用范围1.成员变量在整个类内都有效2.局部变量只在其声明的方法内有效2.生命周期1.成员变量: 它属于对象，它随着对象的创建而创建，随着对象的消失而消失2.局部变量: 使用完马上释放空间。
void show(int id){for(int i=0;i<10;i++){for(int j=0;j<10;j++){System.out.println(id);}}}这时候id,i,j者是在方法内声明的，全是局部变量j当里层for循环执行它的生命周期开始，当里层for结束，j消失i当外层for循环执行它的生命周期开始，当外层for结束，j消失id在方法被调用时开始，方法结束时，id消失.3.存储位置成员变量属于对象，它存储在堆内，堆内的实体，当没有引用指向其时，才垃圾回收清理局部变量存在栈内存中，当不在使用时，马上就会被释放。
4.初始值成员变量它存储在堆中，如果没有赋初值，它有默认值。
1.整数byte、short、int、long =0；2.char='\uoooo'；3.boolean =flase；4.String =null;5.类类型=null；6.数组=null；局部变量，如果要想使用必须手动初始化.i.方法中，参数列表中，语句中。
ii.必须给初始化值，没有初始值，不能使用iii.在栈内存中1.9内存分析案例一：//汽车class Car {//汽车应该具备的属性int num;//汽车具备的颜色String color;//汽车跑的行为public void run(){System.out.println(num+"轮子的汽车跑起来啦");}}public class CarDemo{public static void main(String[] args){ //创建实体，并且给该实体起一个名字Car c = new Car();c.color = "red";c.num = 4;c.run();//指挥车进行运行。
调用格式：对象.对象成员}}(图1 )案例二分析：public static void main(String[] args){ //创建实体，并且给该实体起一个名字Car c = new Car();Car c1 = new Car();c.color = "red";c1.num = 4;System.out.println(c1.color);c.run();//指挥车进行运行。
调用格式：对象.对象成员}内存图：(图二)案例三public static void main(String[] args){ //创建实体，并且给该实体起一个名字Car c = new Car();Car c1 = c;c.color = "red";c1.num = 4;c1.color = "green";System.out.println(c1.color);c.run();//指挥车进行运行。
调用格式：对象.对象成员}内存图三(图三)1.10 面向对象练习1：完成修理汽车的功能2：分析1：面向对象的思想思考需要什么对象1：汽车1：汽车有轮子2：有颜色3：有名字4：有运行的方法2：汽车修理厂1：有名字2：有地址3：有修理汽车的方法3：代码实现1：定义汽车类2：定义汽车修理厂类4：测试代码1：创建汽车对象2：汽车少了轮子无法运行。
3：创建汽车修理厂1：设置厂名2：设置地址3：将汽车拖进修理厂1：运行汽车修理厂的修车方法，修理汽车4：取车1：开走汽车package oop01;/*面向对象之练习完成修理汽车的功能汽车类汽车修理厂类名字，地址，修理汽车的功能*/public class Demo1 {public static void main(String[] args) {SCar sc = new SCar();sc.run();//将汽车轮子改为3个sc.num = 3;sc.run();CarFactory cf = new CarFactory(); = "幸福修理厂";cf.addr = "天河区棠东东路预付科贸园a栋206";cf.repairCar(sc);sc.run();System.out.println();}}class SCar {String name = "smart";String color = "red";int num = 4;void run() {if (num < 4) {System.out.println("汽车坏了，赶紧修理吧。
