DEV Community: Yuehui Ruan

Three characteristics of OOP: Polymorphism

Yuehui Ruan — Fri, 28 Jan 2022 02:31:03 +0000

Polymorphism:

Finally, I begin to write about POLYMORPHISM section. This section needs me get much more familier with the core knowledge of Three Main Features Of Java.

Inheritance maybe not the most popular in code, but the most important part of programming (at least, I think so XD).

1. What is Polymorphism:

Polymorphism is the implementation of an object having different manifestations.

For example, pressing the same button "ENTER" in different applications, computer will show up different reactions, like acting
"Line Feed" function in Word application, acting "Send" function after you type the text in chat box, etc. Just like invoking the same function, pressing "ENTER" button plays an different roles in different applications. This is also kind of Polymorphism.

2. Significance of Polymorphism :

Remove coupling between classes
Replaceability
Scalability
Working as interface (like a real interface in Java)
Flexibility
Simplicity

Before describing all of its significance, there are three necessary conditions for the existence of polymorphisms that you should know:

The implementance of inheritance: So you can see, the implementance of polymorphsm is also the implementance of
Override
An reference of father class points to an object of a sub class: Parent p = new Child();

Now we have classes in our program:

And we have codes for these:

class Shape {
    void draw() {}// is overridden
}

class Circle extends Shape {
    void draw() {//override function draw() of class Shape
        System.out.println("Circle.draw()");
    }
}

class Square extends Shape {
    void draw() {//override function draw() of class Shape
        System.out.println("Square.draw()");
    }
}

class Triangle extends Shape {
    void draw() {//override function draw() of class Shape
        System.out.println("Triangle.draw()");
    }
}

When a method is called in polymorphic mode, it is first checked to see if the method exists in the parent class. If it does not, a compile error occurs. If so, call the method of the same name in the subclass. The phenomenon of calling a function in a subclass with the same name as the one of father class, but showing different results is called Override.

The best way to demonstrate these 6 advantages is to look at the following code:

abstract class Animal {// Abstraction
    abstract void eat();
}

class Cat extends Animal {
    public void eat() {// Interface
        System.out.println("Eat fish.");
    }
    public void work() {
        System.out.println("Catch mouse.");
    }
}

class Dog extends Animal {
    public void eat() {
        System.out.println("Eat bone.");
    }
    public void work() {
        System.out.println("Guard.");
    }
}

public class Test {

    public static void main(String[] args) {
        show(new Cat());  // Invoke the show() through the object of class Cat
        show(new Dog());  // Invoke the show() through the object of class Cat

        Animal a = new Cat();  // Upcasting
        a.eat();               // Invoke eat() of class Cat
        Cat c = (Cat)a;        // Downcasting
        c.work();        // Invoke work() of class Cat
    }

    public static void show(Animal a)  {
        a.eat();
        // Judging the class type
        if (a instanceof Cat)  {  // What a cat does
            Cat c = (Cat)a;
            c.work();
        } else if (a instanceof Dog) { // What a dog does
            Dog c = (Dog)a;
            c.work();
        }
    }
}

And you can see the output:

Eat fish.
Catch mouse.
Eat bone.
Guard.
Eat fish.
Catch mouse.

3. How to implement Polymorphism:

1. Override:

Override exists for polymorphisms.

We've already discussed method overrides, which are methods that can be overridden by a sub class.

When a subclass object calls an overridden method, the method in the subclass is called, not the overridden method in the superclass.

To call an overridden method in a parent class, you must use the super keyword.

2. Interface

Interfaces in Java are similar to interfaces in life, which are collections of method characteristics, but no method implementation. See the Java Interfaces section for details.

3. Abstract classes and abstract functions (vitural function)

Virtual functions also exist for polymorphisms.

Of course, the implementation of polymorphism is not only about the interation among classes. It also can be implemented by abstract function() and abstract class {}(like the vitural func() in c++).

Last but not least

Those concepts of abstract and override could be written in another blogs. However, this blog is the first blog of mine, I hope I could get some feedbacks and advice from our members of DEV community, and then move forward again.

Your advice and comments are the power of my moving forward. Thank you for your reading.

Never know how good you will be if you don't push yourself.
Ricky Ruan:

E-mail: yruan@umass.edu

Three characteristics of OOP: Inheritance

Yuehui Ruan — Fri, 28 Jan 2022 02:28:30 +0000

Inheritance : W W H

1. Defination (What):
Key word: extend

When multiple classes have common attributes (member variables) and behavior (member methods), these common parts are extracted and defined in a public class. Other classes and classes can form an inheritance relationship with this public class, so that there is no need to redefine the public part in multiple classes! This common class is the parent class, also known as the superclass or base class, and the other classes are the subclasses. Subclasses can access non-private member variables of the parent class directly, and private member variables of the parent class can be accessed using the super.get() method.

Now we have the codes at the following:

class Father{
    String car = "Toyota";
    String books = "Harry Potter";
}

class Son extends Father{ // son extends from his father

}

public class Test {

    public static void main(String[] args) {
        Father Howard_Stark = new Father();
        Son Tony_Stack = new Son();

        System.out.println(Tony_Stack.car);
    }
}

Seems like son has nothing. However, once the son extends from his father, Tony now could drive the car from his father and read the books, which his father "confer" to him.

public class Test {

    public static void main(String[] args) {
        Father Howard_Stark = new Father();
        Son Tony_Stack = new Son();

        System.out.println(Tony_Stack.car); // output: Toyota
        System.out.println(Tony_Stack.books);// output: Harry Potter
    }
}

Some features that you should pay attention about the Inheritance in Java:

Every sub class is prowerful than base class, which means sub class would have or cover more vars and funcs than father class has. (Of course, Iron man Tony is much more greater than his father Howard haha)
Even son extends from his father, son could not "change" the feature of his father. The reason why son could not change his father's feature is that, father and son are two independent instances of class Son and class Father.

public class Test {

    public static void main(String[] args) {
        Father Howard_Stark = new Father();
        Son Tony_Stack = new Son();

        Tony_Stack.car = "Mercedes";//Tony changes his car to Mercedes, but could not change Howard's car.

        System.out.println(Howard_Stark.car); // output: Toyota
        System.out.println(Tony_Stack.car); // output: Mercedes
    }
}

Hence, what Tony has in the future does not Howard's business, including his Mark One and Mark Two. That's why son class is absolutely greater than father class.

class Father{
    String car = "Toyota";
    String books = "Harry Potter";
}

class Son extends Father{ // son extends from his father
    String suit1 = "Mark One";
    String suit2 = "Mark Two";
}

Java is single inheritance, not multiple inheritance (unlike C++). However, it is possible to build multi-level subclasses of inheritance.

Like Tony extends from Howard, Morgan Stark (Tony's daughter) extends from Tony, but Morgan could not extend from Howard and Tony at the same time.

Tony_Stark <-(extends)-- Howard_Stark
Morgan_Stark <-(extends)-- Tony_Stark

Morgan_Stark <--X-- Howard_Stark, Tony_Stark

2. Significance(Why):

If a class want to get a same function from another class, it can set up an inheritance. (Save your time to coding, and increase the reusing rate of code)

2.Encapsulation and inheritance are the prerequisites for polymorphism implementation.

Of course, when you edit the feature of father class, the common features that the son has would be changed too, unless the son change these common features independently.

3. Implementation(How):

It is the best time to implement inheritance among classes:

When those classes have many properties in common.
When there are obviously relationship among those classes (like class animals includes class dog and class cat, so class cat and class dog extends the proteries from class animals).

After knowing when to use inheritance, you can try to build up the relationship and have a rough frame in your mind.

I'm going to talk about the six points of inheritance.

1.When construct an instance of sub class, the complier will invoke the constructor of base class first, and then invoke the constuctor of sub class.

class Father{
    String car = "Toyota";
    String books = "Harry Potter";

    Father(){
        System.out.println("Father's constructor invoked");
    }
}

class Son extends Father{ // son extends from his father
    String suit1 = "Mark One";
    String suit2 = "Mark Two";

    Son(){
        System.out.println("Son's constructor invoked");
    }
}

public class Test {

    public static void main(String[] args) {
        Son Tony_Stack = new Son();
    }
}

Output:

Father's constructor invoked
Son's constructor invoked

2.class Object is the father class of any class in JAVA.

Hence, every instance (object) in Java is the polymorphism of instance of class Object.

3.The constructor of a subclass runs super () first, regardless of whether it has arguments or how many;

super(); equals to default constructor of father class. So you can either explicitly or implicitly call super() in the any constructor of sub class.

class Father{
    String car = "Toyota";
    String books = "Harry Potter";

    // where the super() is.
    Father(){
        System.out.println("Father's constructor invoked");
    }

    Father(String car){
        this.car = car;
    }
}

class Son extends Father{ // son extends from his father
    Son(){
        //super(); default
        System.out.println("Son's constructor invoked");
    }

    Son(String book){
        //super(); default
        this.books = book;
    }
}

4.Properties that are private to the parent class are not directly accessible to the subclass in test.java, even if the subclass inherits them.

You can specify the subclass's parameter-constructor only by calling the parent's parameter-constructor. For properties that are not private to the parent class, the child class object can invoke directly.

class Father{
    String car = "Toyota";
    String books = "Harry Potter";
    private String bank_account = "123456"; 
    Father(){
        System.out.println("Father's constructor invoked");
    }

    Father(String car){
        this.car = car;
    }
}

class Son extends Father{ // son extends from his father

    Son(){
        //super(); default
        System.out.println("Son's constructor invoked");
    }

}

public class Test {

    public static void main(String[] args) {
        Son Tony_Stack = new Son();
        Tony_Stack.bank_account = "111111";// error reported: 'bank_account' has private access in 'test.Father'!!!
    }
}

Due to the limitation of the paragraph, here are all my knowledge of Inheritance and, there will be more features' details in Polymorphism Section.

Your advice and comments are the power of my moving forward. Thank you for your reading.

Never know how good you will be if you don't push yourself.
Ricky Ruan:

E-mail: yruan@umass.edu

Computer System Cp2.2 Truncating and expanding in C

Yuehui Ruan — Fri, 28 Jan 2022 02:15:23 +0000

If there is a question asking you, what these binary number means in C? (Basing on 32-bit machine, and we defaultly regrad that we are using 32-bit machine, except for spcially mention we are using others)

1011?
0100 0001?

Actually, it's hard to be determined, due to the fact that I haven't told you what data type you are using to contain them in this 32-bit machine.

That is, what binary number 1011 actually is, is basing on the data type that you want to assign.
In different data type, for example:

unsigned integer: 11
signed integer: -5 (the difference of the range of signed and unsigned are described in chapter 2.1)

And, we have 0100 0001:

unsigned integer: 65
char: 'A'

That is, the data type you declare in C program, will be determined to how this 32-bit machine "read".

If you declare unsigned int a = 65; a is printed as integer 65
If you declare int *p = 65; p is actually an address number 65, pointing a memory place containing an int variable.
If you declare unsigned int c = 'A'; c is actually 65, because when a char type variable is assigned to an int type, the machine will "read" this memory as an integer, where the ascii code of A is 65.

But, how it works?

I mean, we already know from chapter 2.1 that, char using 1 byte (that is 8 bits) to store the value, and unsigned int use 4 bytes (that is 32 bits) to store the value.

So now, we are going to thinking questions about value casting and bits truncating (extanding) between different data type in C.

There are two kinds of casting, obviously having upcasting and downcasting. However, when having casting problem, there are also be with Extanding and Truncating.

Upcasting: Low byte(s) cast to high bytes.
Downcasting: High bytes cast to low byte(s).
There is also casting value between same byte:
signed int => unsigned int
or
unsigned int => signed int
Extanding:

Happens in low bytes to high bytes. When a low-byte variable is cast to high-byte variable, the new high bits of high-byte variable will be extanded by
0: if the original value is positive
1: if the original value is nagetive

Example 1:

// In memory, c is 0100 0001, which is 1 byte (8 bits).
unsigned char c = 65;

unsigned int a = c; // Upcasting and extanding

//Now in memory, due to c is originally positive 
//number, variable a will be extanding by 0 on new high bit, 
//that is, adding 0s on the left(significant 
//position) till filling all 4 bytes (32 bits)
//a in memory:
//0000 0000 0000 0000 0000 0000 0100 0001

printf("%d", a);
//65

Example 2:

signed char c = -1;
signed int a = c;
printf("%d", a);
//-1
//Explaination:
//c in memory stored as:
//1111 1111
//(The way to figure out how to get the nagetive value from decimal, 
//please read the last chapter, section about 2's complement)
//Then, upcasting the 1111 1111, adding 1 (because original value 
//is nagetive value) on high bit position, so we have this in 4 bytes:
//1111 1111 1111 1111 1111 1111 1111 1111

Answer by calculator:

Truncating:

How about when a high-bit variable casted to a low-bit variable? Obviously, the low-bit variable can not contain that many bits. So it must do the truncating on high bit position.

Example 3:

unsigned int a = 129;
//which is 0000 0000 0000 0000 0000 0000 1000 0001
//stored in memory, in 32-bit machine
//now I want to downcast it to signed char
signed char c = a;
printf("%d", c);
//what is the answer?
//It's -127

Explaination:
Always remember one sentence:
The data type decide the way that the computer reads!
No matter how this value being stored in memory, the real value that computer will use just depends on how it reads this value.

Even though 129 is stored as an unsigned integer like:
0000 0000 0000 0000 0000 0000 1000 0001
But eventually the computer reads this value as a data of signed char, that is, making this value being read only 8 bits from the lowest bit position, which is only
~~0000 0000 0000 0000 0000 0000~~ 1000 0001
And, 1000 0001 in signed char is -127.

Casting between signed and unsigned :

If you follow these rules, you can hardly get lost:

It's only about how computer reads!
Remember, the most significant position of signed value is describing if it is positive(0) or nagetive(1).

Besides, bit operaters like |, &, <<, >>, <<< should be familiar with, even they are seldom used in our program. But, it did be used so many in like registers, memory allocation and ALU, which are located in the deeper level of system.

If you have any questions, feel free to comment here!

Computer System - Cp.2 - 1 Bit and Byte in C

Yuehui Ruan — Thu, 27 Jan 2022 00:25:21 +0000

We will go over data repersentation of computer systems this chapter. That is, when we need to think in a computer way, you should know how computer think at first (in binary).

Chapter. 2 Repersentation in C

1. Base

What is the base of a number?
Generally, the number that we use in daily life like 50 dollars, 100 pounds, 1,000,000 people are all base 10, which means that these number are all decimal.

And usually, there are different bases we use in studying system, like binary number (base 2), octal number (base 8), and hexadecimal number (base 16).

We can see them being used in computer world:
When the numebr is followed by a character "b", that means it is a binary number:
0101b (BIN) = 0 * 2^3 + 1 * 2^2 + 0 * 2^1 + 1 * 2^0 = 5 (DEX)

Number like '0X1E', is HEX number:
0X is the prefix of the hexadecimal number. We have:
0X1E (HEX) = 1 * 16^1 + 14 * 16^0 = 30 (DEX)

2. Bit and Byte

1 Byte = 8 Bits
And the important repersentations of every data type in C:

Specially, one another data type in C is called POINTER, which is also significant:

Pointer:

4 bytes in 32-bit-system
8 bytes in 64-bit-system

The knowledge that we are reviewing, is usually based on 32-bit systems

3. Conversion between different bases

- DEC to BIN:

There is the same way to do with other bases number except for BIN.

BIN to DEC: mentioned above
X base number to Y base number:
1. X base to DEC
2. And then DEC to Y base

4. Addition and multiplication of binary

5. One's Complement

When comes to 1100 1001 (which is equal to 201 in decimal):
THe 1's complement of 1100 1001 is 0011 0110, which turning 1 to 0, and turning 0 to 1.

6. Two's Complement

Two's complement is used to do the substraction or repersenting negative number in binary (Of course, adding a negative is substracting a positive number).
How to repersent -5 in binary, when we know 5 is 0101 in binary in a 8-bit machine?

Get the 0101's 1's complement in 8-bit machine, having 1111 1010.
Add one, having 1111 1011. Then, 1111 1011 is the number repersenting -5 in 8-bit machine.

That is:
2's complement = 1's complement + 1

7. Intro of Overflow and Underflow

They happen when sum of 2 positive (or negative) number but get the negative (positive) number in machine, due to the fact that when machine has no more bit to extend to repersent this number.
Overflow: Sum of 2 positive but get the negative
Underflow: Sum of 2 negative but get the positive

8. Extension and Truncation between high-bit and low-bit

This part would be the most important part of bit and byte chapter. I would like to go over this part in next post, because I think it would cost me few hours to design how to explain it in a comfortable way.

Hope you like my post! You red heart or subsrcibtion are the energy of me! Thank you!

Computer Systems Principles - Cp.1 Intro

Yuehui Ruan — Tue, 25 Jan 2022 22:57:16 +0000

This is the blog helping myself to review the knowledge that I have went over. Hope you all enjoy my summary.

The knowledge is based on C language.

Chapter 1: Computer Systems Structure

Before we dive into the deeper learning of computer system, the best way getting a comfortable start is to see the bigger picture of computer system structure. I think it is important for the beginner who just start learning Computer System or Operating System.

Just like a hamburger, which has different layers like piece of bread, vagetables, beef, cheese and so on, computer systems also are dive into different layers.

Layers in hamburger:

Layers in Computer Systems:

As we can see, computer systems could be divided into three big layers, which are: (Up to down)
1.Software Layers

All kinds of applications that we use daily

2.Operating System Layers

Operating System -- A special application between software and hardware, which is used to transfer user's or applications' "codes" or "instructions" and then letting the hardware understand how to manipulate the menory.

3.Hardware Layers

Including CPU, disks, registers, RAM and so on.

Specially, and generally we can divede them into five main components (based on every single component could be dived deeper to study at the following chapters)

Input/Output ports. (I/O ports)
Enable the computer to take information or interations from its environment and dispaly them back to the user in some meaningful way.
Central processing unit. (CPU)
Runs or executes instructions and computers data and memory addresses.
Random access memory (RAM)
Stores the data and instructions of running programs. The data and instructions in RAM are typically lost when teh computer system loses power.
Secondary storage device (SSD)
Hard disks or solid state drives (SSD) that can store programs and data even when power is not actively being provided to the computer.
Operating System (OS)
A software layer that lies between the hardware of the computer and the software that a user runs on the computer.

Next chapter, I will go over the , which is the basic knowledge in system, making you think like a computer. Hope you like it and subscribe it :)

Three characteristics of OOP: Encapsulation

Yuehui Ruan — Sat, 21 Aug 2021 06:22:00 +0000

Three main features of OOP language.

PREFACE:
(you can just skip this section to Introduction XD )

Okay, Java and cpp are the language that I learn from my school, though this summer I receive an email from my professor that we "had better" to have some expreience on C. (And I use fews week to be acquainted with this. OMG)

And, we know those two languages are Object Oriented Programming languages. So they have three features that are different from Procedure-Oriented Language (like C, so far I have learnt).

Due to these three features have a high occurrence rate on interviews from many comps, I decide to summary my knowledge.

This blog is based on the language of JAVA, and you should know there are still difference amoung all OOP languages. And in this blog I will try to use "my word" and my thinking to describe what they are and why they exist, how to use them. Please correct me if there is any wrong in my blog. Thank you!

Introduction

Encapsulation
Inheritance
Polymorphism

Encapsulation: What Why How

1. Defination (What):

Put the objects which have same features or, belongs to the same class together, and pack them well.

So you know in the company, there are lots of departments that led by different managers or supervisors. For example, we have IT_Department class and HR_Department class.

class HR_Department{

    private String Manager;
    private String[] Dep_Members;

    HR_Department(String manager_name){// constructor of HR_Dep
        Manager = manager_name;
    }

    private void employ(){
        System.out.println("Our company need to employ a new employee.");
    }
    private void dismissal(){
        System.out.println("We decide to dismissal someone...");
    }
}

class IT_Department{

    private String Manager;
    private String[] Dep_Members;

    IT_Department(String manager_name){// constructor of IT_Dep
        Manager = manager_name;
    }

    private void Access_Database(){
        System.out.println("Our IT Department can access database of our company.");
    }
    private void Power_outage(){
        System.out.println("IT Department decide to shut down the power for fixing problems.");
    }
}

class Google_Inc{
    private IT_Department it_Dep;
    private HR_Department hr_Dep;

    Google_Inc(String IT_Manager_Name,String HR_Manager_Name){// constructor of Google_Inc
        it_Dep = new IT_Department(IT_Manager_Name);
        hr_Dep = new HR_Department(HR_Manager_Name);

        System.out.println("Google Inc is established successfully!");
    }
}

public class Test {

    public static void main(String[] args) {
        // set up a company call newGoogle_Inc XD
        Google_Inc google_Inc = new Google_Inc("Jack", "Rose");
    }
}

If you are CEO of this company, you have to employ some managers to help you manage these different departments, and of course you require any department work in perfect order and help each other
.

2. Significance (Why):

You can easily imagine that, how messy this scenario would be if we didn't have access to every piece of data in any class.

I believe, you can't stand it when HR employee turns off the power without checking in with THE IT department. (even I never work for any companys XD) It's dangerous and out of line anywhere.

So the existance of Encapsulation shows its importance right now. The example of company is also suitable for any program's, code's, data's management. It's dangerous while after you design a program, some of your users could access your data and edit them.

So for Java, we usually "pack" our CLASS (data) well through using Permission Modifier.
1.public
2.protected (default)
3.private (most used to modify class and variable, as you can see on previous code block)

Obviously, you can realize that, if you correctly use the
permission modifier, you can realize the advantages of your code:

1.Isolate important variables(vars) or functions(funcs)
2.Conveniently access vars or funcs
3.Increase the importance
4.Enhance the security

And of course, these advantages also cause the code being much more harder to access and leading you spending more steps to access them.

3. Implement of Encapsulation(HOW):

Before using them, you need to know the range of different modified vars or funcs that could be accessed.

Modify	Same class	Same package	Sub class	All class
private	Yes
default	Yes	Yes	Yes
protected	Yes	Yes	Yes
public	Yes	Yes	Yes	Yes

In some way, protected equals to default.

Eg: You can not access manager name of HR department directly by assign =:

So, you need to set up some functions called "Getters" and "Setters":

class IT_Department{

    private String Manager;
    private String[] Dep_Members;

    IT_Department(String manager_name){// constructor of IT_Dep
        Manager = manager_name;
    }

    String getManager(){ // a classic getter function
        //return manager's name
        return Manager;
    }
    void setManager(String name){// a classic setter function
        //set name to manager's name
        this.Manager = name;
    }

    private void Access_Database(){
        System.out.println("Our IT Department can access database of our company.");
    }
    private void Power_outage(){
        System.out.println("IT Department decide to shut down the power for fixing problems.");
    }
}

Hence, you can realize, the implement of encapsulation is abstract in code. We prefer to call encapsulation a phenomenon or a feature. If you have a clear and strict frame of code, your codes will look so GOOD and COMFORTABLE.

In main function:

public static void main(String[] args) {
        // set up a company call newGoogle_Inc
        Google_Inc google_Inc = new Google_Inc("Jack", "Rose");

        String name = google_Inc.it_Dep.getManager(); // assign "Jack" to name.
        google_Inc.it_Dep.setManager("Ben");// assign "Ben" to IT Department's manager
    }

Your advice and comments are the power of my moving forward. Thank you for your reading.

Never know how good you will be if you don't push yourself.
Ricky Ruan:

E-mail: yruan@umass.edu

DEV Community: Yuehui Ruan

Three characteristics of OOP: Polymorphism

Polymorphism:

Last but not least

Three characteristics of OOP: Inheritance

Inheritance : W W H

Computer System Cp2.2 Truncating and expanding in C

But, how it works?

Extanding:

Truncating:

Casting between *signed * and *unsigned *:

Computer System - Cp.2 - 1 Bit and Byte in C

Chapter. 2 Repersentation in C

1. Base

2. Bit and Byte

The knowledge that we are reviewing, is usually based on 32-bit systems

3. Conversion between different bases

4. Addition and multiplication of binary

5. One's Complement

6. Two's Complement

7. Intro of Overflow and Underflow

8. Extension and Truncation between high-bit and low-bit

Computer Systems Principles - Cp.1 Intro

Chapter 1: Computer Systems Structure

Three characteristics of OOP: Encapsulation

Three main features of OOP language.

Introduction

Encapsulation: What Why How

Casting between signed and unsigned :