Chapter 1：Introduction to objects

最新推荐文章于 2024-03-18 03:34:49 发布
原创 最新推荐文章于 2024-03-18 03:34:49 发布 · 883 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#object #interface #iterator #each #uml #框架

本文介绍了面向对象程序设计语言的五大基本特征，包括一切皆对象、对象通过消息交互等。阐述了对象的接口、隐藏实现、继承与组成等概念，还提及对象的创建与毁灭方式。此外，说明了分析与设计的步骤，如建立用例图、使用UML等，最后提到XP极限编程的测试先行和搭档设计要点。
面向对象程序设计语言五大基本特征
1. Everything is an object. Think of an object as a fancy variable
2. A program is a bunch of objects telling each other what to do by sending messages.
3. Each object has its own memory made up of other objects.
4. Every object has a type.
5. All objects of a particular type can receive the same messages.

An object has an interface
“类型”与“接口”的等价或对应关系是面向对象程序设计的基础

The hidden implementation（public，private，protected，friendly）
有两方面的原因促使我们控制对成员的访问。
第一个原因是防止程序员接触他们不该接触的东西——通常是内部数据类型的设计思想
第二个原因是允许库设计人员修改内部结构，不用担心它会对客户程序员造成什么影响(所以这里要求接口要设计的好)

继承与组成
(继承的本意在于抽象，而非代码重用)
什么时候应该使用继承？只在抽象类中使用，其他情况下尽量不使用
如果我们会使用OO的多态性，则使用继承

abstract  interface

对象在何处？如何创建？
在一个内存池中动态创建对象，该内存池亦叫“堆”或者“内存堆”
对象如何毁灭？
垃圾收集器

Collection 对象集合
Iterator 提供了某种抽象层级，可将 容器实作细节 和 对容器进行存取动作的程序 分离开来

分析与设计
1 建立什么（Who What How and possible problems）use case diagrams简单为好（日程表）
2 如何建立 （UML）
3 打造核心 （建立框架）
4 一个一个模块的完成
5 维护

XP（极限编程）
1 测试先行
2 搭档设计
Datacamp: Introduction to R
weixin_51825567的博客
08-05 355
Datacamp: Introduction to R
CoreJava - Chapter 4: Objects and Classes
DreamyHacker的博客
06-14 960
Introduction to Object-Oritented Programming Introduction Each object has a specific functionality, exposed to its users, and a hidden implementation Basically, as long as an object satisfies your specifications, you don't care how the functionality is
《Thinking in C++, 2nd Edition》笔记－第一章（Introduction to Objects）
04-04 752
Alan Kay总结的SmallTalk（第一个成功的OO语言，C++发展的基础之一）的五个特性： 1.一切事物都是对象。把对象想象成一个变量，它存储数据，又可以向它提出请求，让它自己执行操作。理论上，可以把任何需要解决的问题的概念成分看成一个对象。 2.一个程序是一组通过发送消息告知彼此干什么的对象组成。 3.每个对象都有自己的内存，由其它的对象组成。 4.每个对象都有一个类型，对象是一
Introduction to Objects(Thinking in Java)
weixin_30800807的博客
08-01 125
1.Everything is an object. Think of an object as a fancy variable; it stores data, but you can “make requests” to that object, asking it to perform operations on itself. In theory, you can take any co...
Introduction to Objects
ucan23
11-18 1278
The progress of abstraction 1.  Everything is an object. Think of an object as a fancy variable; it stores data, but you can “make requests” to that object, asking it to perform operations on itsel
第一章: Introduction to Objects
良子
12-06 1000
第一章: Introduction to Objects：1、a pure approach to object-oriented programming:Everything is an object. A program is a bunch of objects telling each other what to do by sending messages.Each object has
introduction to objects
格物致知
02-15 615
1、关于接入控制的理解      在java提供的类库中（jar包）每个开发者都可以引用，利用里面提供的相关功能来进行开发，但是对于开发者不需要接触的方法的实现则需要进行控制接入，这样保证了方法的安全性，相当于jar中的class只对外提供方法接口，这样便于library提供者的维护工作。当然在最普通的java程序中是利用提供的字段来进行这方面的接入控制的。字段如下： private：私有字段
软件设计（II）教学课件：Chapter 14 Introduction to theStandard
11-30
Chapter 14 "Introduction to the Standard Template Library" (STL) 涉及C++编程中的核心组件，它被包含在C++标准库中，旨在标准化常用的数据结构和算法。STL由Alexander Stepanov在20世纪80年代开发，并于1994年2...
Chapter 1 - 2. Introduction to Congestion in Storage Networks
mounter625的专栏
03-18 1065
文件级访问抽象了块级细节，并以文件和目录的形式向应用程序或操作系统展示存储。在本书的范围内，重点关注这些协议如何最终在网络上形成数据包，以及如何对它们进行流量控制。换句话说，每种网络都定义了帧格式以及在物理介质（铜线或光纤）上传输比特的编码方案。对象存储的常见用途是存储可能不会经常变化的海量数据，如图像托管、视频流服务和数据备份。）抽象了较低层次的细节，不管是块存储、文件存储还是对象存储。，因此无需加载卷（与块存储一样）或文件系统（与文件存储一样）。），通过广域网链接到远程站点，或通过互联网连接到公共云。
An Introduction to Programming with C++
01-25
ChaptEr 1 an introduction to Programming 1 ChaptEr 2 Beginning the Problem-Solving Process 23 ChaptEr 3 Variables and Constants 51 ChaptEr 4 Completing the Problem-Solving Process 75 ChaptEr 5 The ...
Introduction To Objects
rainbow的专栏
04-14 680
1.The progress of abstraction All programming languages provide abstractions. It can be argued that the complexity of the problems you’re able to solve is directly related to the kind and quality of 
1．Introduction to Objects
I think, therefore I am.
10-22 565
  1．Introduction to ObjectsThe progress of abstraction：编程归根结底使用计算机语言解决现实世界中的问题，人所作的工作就是将现实中的问题进行抽象，得到能够被计算机“理解”的模型（这个模型是对实际问题的一种映射）。由于计算机只能理解当前其支持的计算机语言，所以在对实际问题进行模型化、抽象化的过程中，必需要趋向一种选定的语言；/**?
转帖：Three Ways to Inject Your Code into Another Process
weixin_30412577的博客
10-21 383
因为cnblogs随笔编辑器的粘贴功能不能很好的保留原有网页格式，所以最好还是看看原文，思路会更清晰： http://www.codeproject.com/KB/threads/winspy.aspx 另外，下载编译好的WinSpy好像有病毒，我的SAV是报了，所以下载源代码自己编译出执行文件为好。 Download e...
TypeError: ‘socket‘ object is not callable
Home to come
08-02 1593
socket编程写好服务端和客户端之后，居然报python库里面的错，难道是我python有问题，这个怎么解决吖？先放在这里
Chapter 5:Hiding the implementation
leon_sandy的专栏
02-25 953
每个编译单位有一个或者没有 public class, 类名与文件名相同
Chapter 4:Initialization & Cleanup
leon_sandy的专栏
02-25 889
类的成员变量会在成员函数（甚至构造式）之前完成初始化在这里有必要总结一下对象的创建过程。请考虑一个名为Dog的类：(1) 类型为Dog的一个对象首次创建时，或者Dog类的static方法／static字段首次访问时，Java解释器必须找到Dog.class（在事先设好的类路径里搜索）。(2) 找到Dog.class后（它会创建一个Class对象，这将在后面学到），它的所有static初始化模块都会
Chapter 8:Holding your objects
leon_sandy的专栏
01-25 881
有两方面的问题将数组与其他集合类型区分开来：效率和类型为容纳一组知道最终需要多少的对象，最适宜的选择应当是数组。而且假如容纳的是一系列基本数据类型，更是必须采用数组使用Java集合的“缺点”是在将对象置入一个集合时丢失了类型信息Vector BitSet Stack Hashtable
Chapter 6:Inheritance and Composition
leon_sandy的专栏
02-25 856
//: Beetle.java// The full process of initialization.class Insect { int i = 9; int j; Insect() { prt("i = " + i + ", j = " + j); j = 39; } static int x1 = prt("sta
Chapter 3: Introduction to Objects and Classes The Object-Oriented Paradigm Course: CS101: Java Language Programming Instructor: [Instructor Name] Date: September 22, 2025 Practical Session Objective Lab Goal: Refactor to an Object-Oriented Design Our goal is to stop using loose, primitive variables to represent our contact and instead create a proper Contact object. This is a foundational step in building professional software. Prerequisites: Java JDK 11 or higher installed. An IDE like IntelliJ IDEA or VS Code ready. Your MyContactManager project from the last lab. Final Result Preview: The console output will look exactly the same as before, but the underlying code structure will be vastly superior, organized, and ready for future expansion. Step 1: Create the Contact Class Blueprint First, we need to create the blueprint for what a "Contact" is in our application. 1. Goal: Create a new Contact.java file and define the state of a contact. 2. Instructions: 1. In your IDE's project explorer, right-click on your source folder and create a new Java Class. 2. Name the file Contact . This will generate Contact.java . 3. Inside the Contact class, declare the instance variables that every contact will have. These are the same variables that are currently cluttering up your main method. 3. Code Block (for Contact.java ): --- Contact Details --- Name: John Doe Age: 42 Phone: 555-1234 1 2 3 44. Expected Result: You now have two files in your project: MyContactManager.java and Contact.java . The code should compile without errors. Step 2: Instantiate a Contact Object Now that we have the blueprint, let's go back to our main application and create an actual contact from it. 1. Goal: In MyContactManager.java , replace the old primitive variables with a single Contact object. 2. Instructions: 1. Open MyContactManager.java . 2. Delete all the old variable declarations for the contact ( String firstName = "Jane"; , int age = 32; , etc.). 3. In their place, declare and instantiate a new Contact object. 3. Code Block (in main method of MyContactManager.java ): 4. Expected Result: Your main method is now much cleaner. Your code will no longer compile because the parts that used the old variables are now broken. This is good! We'll fix it next. Step 3: Set the Object's State Our contact1 object exists, but its instance variables are all empty ( null or 0 ). Let's fill them with data using dot notation. 1. Goal: Assign values to the instance variables of our new contact1 object. public class Contact { // Instance variables to hold the state of a single contact String firstName; String lastName; int age; String phoneNumber; boolean isFriend; } 1 2 3 4 5 6 7 8 public static void main(String[] args) { // Delete the old variables: // String firstName = "Jane"; (DELETE) // String lastName = "Doe"; (DELETE) // int age = 32; (DELETE) // ...and so on. // Create an object from our blueprint Contact contact1 = new Contact(); // Now we have a single variable, 'contact1', that holds all // the information about our contact. } 1 2 3 4 5 6 7 8 9 10 11 12 132. Instructions: 1. After the line Contact contact1 = new Contact(); , use the dot operator to access each instance variable and assign it a value. 3. Code Block (in main method of MyContactManager.java ): 4. Expected Result: The contact1 object in memory now holds all the data for John Doe. The code still won't compile because the System.out.println statements are broken. Step 4: Get the Object's State Finally, let's fix our print statements to read the data back from the object, again using dot notation. 1. Goal: Update the System.out.println statements to use the object's fields. 2. Instructions: 1. Find your old println statements that are showing compile errors. 2. Prefix each old variable name with contact1. to tell Java to get the value from the object. 3. Code Block (in main method of MyContactManager.java ): 4. Expected Result: All compile errors should now be gone! Your application is fully refactored. // ... after creating the contact object Contact contact1 = new Contact(); // Use dot notation to set the object's state contact1.firstName = "John"; contact1.lastName = "Doe"; contact1.age = 42; contact1.phoneNumber = "555-1234"; contact1.isFriend = false; 1 2 3 4 5 6 7 8 9 // ... after setting the object's state System.out.println("\n--- Contact Details ---"); // OLD: System.out.println("Name: " + firstName + " " + lastName); // NEW: System.out.println("Name: " + contact1.firstName + " " + contact1.lastName); // OLD: System.out.println("Age: " + age); // NEW: System.out.println("Age: " + contact1.age); // OLD: System.out.println("Phone: " + phoneNumber); // NEW: System.out.println("Phone: " + contact1.phoneNumber); 1 2 3 4 5 6 7 8 9 10 11 12 13 14Final Code and Verification Let's look at the final, refactored MyContactManager.java and verify that it works. 1. Goal: Run the application and confirm the output is correct. 2. Code Block (Complete MyContactManager.java ): 3. Expected Output: Success! The output is the same, but our code structure is infinitely better. Optional Challenge Task For Those Who Finish Early... 🚀 If you've completed the refactoring, this challenge will solidify your understanding of objects. Challenge: Create a Second, Independent Object 1. In your main method, create a second Contact object called contact2 . 2. Set the state for contact2 with completely different data (e.g., "Jane Smith", age 35, etc.). 3. Add println statements to display the details for contact2 after displaying the details for contact1 . public class MyContactManager { public static void main(String[] args) { // 1. Create an object (an instance) from the Contact class blueprint Contact contact1 = new Contact(); // 2. Set the state of the object using dot notation contact1.firstName = "John"; contact1.lastName = "Doe"; contact1.age = 42; contact1.phoneNumber = "555-1234"; contact1.isFriend = false; // 3. Get the state of the object using dot notation System.out.println("--- Contact Details ---"); System.out.println("Name: " + contact1.firstName + " " + contact1.lastName); System.out.println("Age: " + contact1.age); System.out.println("Phone: " + contact1.phoneNumber); } } 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 --- Contact Details --- Name: John Doe Age: 42 Phone: 555-1234 1 2 3 4This will prove that contact1 and contact2 are two separate objects in memory, each with its own independent state, even though they were built from the same class blueprint. Q&A and Wrap-up Questions? Today's Most Important Lesson Organizing code into classes that model real-world concepts is the single most powerful strategy for managing complexity in software. We took a chaotic collection of variables and transformed it into a clean, intuitive structure. A Contact is now a "thing" in our program, just as it is in the real world. This is the foundation upon which all large-scale, professional applications are built. What's Next? Up Next: Protecting Our Objects Right now, our code has a major flaw. Anyone using our Contact class can do this: contact1.age = -99; contact1.phoneNumber = "this is not a phone number"; This is dangerous and leads to bugs! An object should be in control of its own data. Next Lecture: Chapter 4: Deeper Dive into Classes - Encapsulation We'll learn about encapsulation, a core OOP principle for data hiding and protection. We'll introduce private variables and public getter/setter methods to create robust, bug-resistant objects. 以上问题的答案是什么
最新发布
09-21
#### 1. 分析原始代码 假设原始代码使用多个独立的变量来存储联系人信息，例如： ```java // 原始代码使用独立变量存储联系人信息 String contactName = "John Doe"; String contactPhone = "123-456-7890"; String ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值