Explore
For Enterprise
Join for Free
Log In

艺术与人文
商务
计算机科学
数据科学
信息技术
健康
数学和逻辑
个人发展
物理科学与工程
社会科学
语言学习
學位
證書

瀏覽 Coursera 的全部課程

瀏覽
搜索
企業版
登錄
免費加入

Core: Abstract Classes and Interfaces

Loading...

面向对象 Java 程序设计

加州大学圣地亚哥分校

4.7（3,558 個評分） | 160K 名學生已註冊

課程 3（共 4 門，面向对象 Java 程序设计專項課程）

Welcome to our course on Object Oriented Programming in Java using data visualization. People come to this course with many different goals -- and we are really excited to work with all of you! Some of you want to be professional software developers, others want to improve your programming skills to implement that cool personal project that you’ve been thinking about, while others of you might not yet know why you’re here and are trying to figure out what this course is all about. This is an intermediate Java course. We recommend this course to learners who have previous experience in software development or a background in computer science. Our goal is that by the end of this course each and every one of you feels empowered to create a Java program that’s more advanced than any you have created in the past and that is personally interesting to you. In achieving this goal you will also learn the fundamentals of Object Oriented Programming, how to leverage the power of existing libraries, how to build graphical user interfaces, and how to use some core algorithms for searching and sorting data. And this course is project-based, so we’ll dive right into the project immediately! We are excited to be offering a unique course structure, designed to support learners of different backgrounds in succeeding at their own pace. The first module explains how this will work and if this course is right for you. We also recommend taking a few minutes to explore the course site. A good place to start is the navigation bar on the left. Click Course Content to see what material we’ll cover each week, as well preview the assignments you’ll need to complete to pass the course. Click Discussions to see forums where you can discuss the course material with fellow students taking the class. Be sure to introduce yourself to everyone in the Meet and Greet forum. This course should take about 6 weeks to complete. You can check out the recommended course schedule below to see a quick overview of the lessons and assignments you’ll complete each week. We’re excited you’re here learning with us. Let’s get started!

查看授課大綱

您將學習的技能

Logic Programming, Java Programming, Object-Oriented Programming (OOP), Sorting Algorithm

審閱

4.7（3,558 個評分）

5 stars
2,724 ratings
4 stars
689 ratings
3 stars
97 ratings
2 stars
26 ratings
1 star
22 ratings

KP

Feb 21, 2016

Enroll this course if you intend to become a programmer and need fundamental knowledge in Object Oriented Programming. Here you can study the subject and apply new things in a real curious project.

OE

Aug 06, 2017

This course made me understand java concepts in an easy way, and made me realize certain internal workings in Java I haven't seen elsewhere. I love their method/process of tutoring. Awesome job!

從本節課中

Inheritance

Now that you’re in full swing with the project, let’s take a closer look at some concepts that you have already been using in your code. Specifically, the keyword “extends”. What exactly does it mean that your program “extends PApplet”? To answer this question we’ll need to dive into the details of how Java allows for Class Hierarchies through Inheritance and Polymorphism. These fundamental and powerful concepts will serve you well in the future! We’ll use these ideas to allow for displaying markers differently. If you feel you’re already comfortable with Inheritance and Polymorphism, feel free to dive straight into the project (programming assignment) for this week. As you work with the project, feel free to have some fun and introduce new levels of class hierarchies for improved functionality.

Core: Introduction to Polymorphism2:41

When I struggled: Polymorphism0:56

Core: Rules to Follow for Polymorphism4:01

Core: Casting Objects3:34

Concept Challenge: Polymorphism Part 16:08

Concept Challenge: Polymorphism Part 26:43

Core: Abstract Classes and Interfaces5:09

In the Real World: Inheritance 21:54

教學方

Mia Minnes
Assistant Teaching Professor
Leo Porter
Associate Teaching Professor
Christine Alvarado
Associate Teaching Professor

腳本

[MUSIC] All right, welcome back to our module on inheritance and polymorphism in Java. In this video, we're gonna be discussing abstract classes and interfaces. Specifically, we're gonna be talking about what it means to be an abstract class or an interface, and how to use keywords like abstract or interface. We're gonna be comparing inheritance of implementation against inheritance of interface. And we're gonna give you the tools to help decide between abstract class, or an interface, when designing your class hierarchy. To get started, let's look at our hypothetical with our Person class. So now we're still working in the university, but let's change things a bit. Let's change it so we're working for the accounting department. And here we're essentially responsible for handling bills and paychecks. Now in this context, it doesn't really make sense to have a generic Person object any more. Right, we're only gonna be working either with students or faculty. And we're also going to change the context in the sense that I want to be able to send out monthly statements. So, essentially, I wanna a method in the Person class, which sends out a monthly statement to either students or faculty. The features I'd like to have here is I'd like to be able to force my subclasses, both my student and my faculty class, to override this method. I'd like to stop having actual Person objects, because they don't make sense in this context anymore. But I'd like to keep having Person references. And I'd also like to keep that common code we had, like the name of the person. If I want to do all these things I want to use an abstract class. The way to define an abstract class is essentially just to use the keyword abstract. So if I say public abstract class Person, it means this class, you cannot create instances of objects of this type. So I can't actually create an object of type Person, but I now can create an objects of, say, derived classes, which are concrete. If I have any method within this class, be abstract then I have to make it the whole class abstract. But what I can do then is say, have a public abstract void monthlyStatement. I can say, my derived classes have to override this method. It's a nice way of forcing the subclasses to have methods. With an abstract class, you get two things. You get to inherit both implementation and interface. And what I mean by that is that with an implementation you get instance variables or methods, which essentially define that common behavior that any person should have. And you also get an interface. You say what methods and interests have to be overridden in my subclasses. Now, there's gonna be times when you don't necessarily want both. You may just want the interface. If you want just the interface, then you're gonna use interfaces. And if we go back to our example, I really believe an abstract class is appropriate for the hypothetical that we were just talking about. But let's say that you had no common code in the Person class. If there's something common there, then you just use an interface. And an interface will give us the ability to force subclasses to have a method, to stop having actual Person objects, and will allow us to keep having Person references. Now interfaces only define the methods that are required, and classes can inherit actually from multiple interfaces. So you can inherit from an abstract class and also inherit from multiple interfaces, all within one class. So let's look at an example of an interface. So the most common one discussed is the comparable interface. Now comparable gives you the ability to compare an object to another object of that same type. You're gonna notice some terminology here, those brackets with the E, that refers to Generics. We'll discuss those a bit more later. This allows us to compare two objects. Now why would I want an interface like this? Take a few seconds to think about it, I'll come back. All right. If you're thinking it's useful to be able to compare objects in case you, say, wanna sort them, that's exactly the purpose for having Comparable. So if you wanna have a data structure and know some way of storing and ordering among those objects, comparable's exactly what you wanna do for the objects. And the way that we would do this for say the Person class, is to say, have the Person class implement a Comparable interface. And then within that all I have to do is override that one method, compareTo, and then define the behavior I want. In this case, I define the behavior to be a comparison of the strings using the compareTo method in the string class, because the string class implements the Comparable interface. So if you're trying to design a class hierarchy, you're often gonna be wondering, should I be making this an interface or an abstract class? And the general rule of thumb is, if you just want to require methods, that's an interface. If you want to potentially require methods, you don't have to, but if you potentially want to require methods, and you wanna require a common behavior, that's where an abstract class comes in.

探索我們的目錄

免費加入並獲得個性化推薦、更新和優惠。

Coursera 致力於普及全世界最好的教育，它與全球一流大學和機構合作提供在線課程。

© 2019 Coursera Inc. 保留所有權利。

通過 App Store 下載

通過 Google Play 獲取

Coursera
關於
管理團隊
工作機會
目錄
證書
MasterTrack™ 證書
學位
企業版
政府版

社區
Learners
Partners
Developers
Beta Testers
Translators

連接
博客
Facebook
領英
Twitter
Instagram
YouTube
技術博客

更多
條款
隱私
幫助
內容訪問
媒體
聯繫我們
目錄
附屬公司