Kotlinlearncs.online LogoJava

    ← Prev

    Index

    Next →

    Kotlin
    Java

    • Encapsulation : 27

    • Constructors : 26

    • Objects, Continued : 25

    • Introduction to Objects : 24

    • Compilation and Type Inference : 23

    • Practice with Collections : 22

    • Maps and Sets : 21

    • Lists and Type Parameters : 20

    • Imports and Libraries : 19

    • Multidimensional Arrays : 18

    • Practice with Strings : 17

    • null : 16

    • Algorithms and Strings : 15

    • Strings : 14

    • Functions and Algorithms : 13

    • Practice with Functions : 12

    • More About Functions : 11

    • Errors and Debugging : 10

    • Functions : 9

    • Practice with Loops and Algorithms : 8

    • Algorithms I : 7

    • Loops : 6

    • Arrays : 5

    • Compound Conditionals : 4

    • Conditional Expressions and Statements : 3

    • Operations on Variables : 2

    • Variables and Types : 1

    • Hello, world! : 0

    Constructors

    public class Dimensions {
    double width;
    double height;
    Dimensions(double setWidth, double setHeight) {
    width = setWidth;
    height = setHeight;
    }
    double area() {
    return width * height;
    }
    }
    Dimensions room = new Dimensions(8.8, 10.0);
    System.out.println(room.area());

    Let’s continue our discussion of Java objects. Remember that bit of syntax that looked like a method call when we create a new Java object? Well, it was! Next we’ll talk about what it does.

    Constructors
    Constructors

    Previously when we created instances of our new object classes, we used new followed by something that looked like a method call to a function accepting no parameters:

    class Person {
    String name;
    double age;
    }
    Person geoff = new Person();
    geoff.name = "Geoff";
    geoff.age = 41.05;

    It turns out that this is exactly what follows new. Usually when we create a new object we want to set the fields on it right away. Rather than doing this in the fairly clumsy way shown above, Java provides a better alternative. Let’s look at it together!

    class Person {
    String name;
    double age;
    }
    Person geoff = new Person();
    geoff.name = "Geoff";
    geoff.age = 41.05;

    Constructor Semantics
    Constructor Semantics

    There are a few things to keep in mind about constructors.

    First, they must have the same name as the class and cannot declare a return value:

    class Person {
    String name;
    double age;
    // Only three parts to this method declaration
    Person(String setName, double setAge) {
    name = setName;
    age = setAge;
    }
    }
    Person you = new Person("Great Student", 18);
    System.out.println(you.name + " is " + you.age);

    You can, however, use return in a constructor if you want to skip some parts of the initialization in certain cases:

    class Person {
    String name;
    double age;
    // Only three parts to this method declaration
    Person(String setName, double setAge) {
    if (setAge < 0.0) {
    // Don't set name on people with negative age...
    return;
    }
    name = setName;
    age = setAge;
    }
    }
    Person unborn = new Person("New Baby", -0.2);
    System.out.println(unborn.name);

    Finally, we don’t need to declare a constructor. If we don’t, Java will include a default constructor that takes no arguments. Let’s see how that works:

    class Person {
    String name;
    double age;
    }
    Person geoff = new Person();
    geoff.name = "Geoff";
    geoff.age = 41.05;

    Practice: Simple Object Field

    Created By: Geoffrey Challen
    / Version: 2020.9.0

    Create a class called Simple that stores a single int value using a field named value. Simple should implement a function called setValue that accepts a single int and changes the saved value. (It should not return a value.) Simple should also implement a function called getValue that returns the saved value.

    Note that you should include public before your class definition for this problem. We've provided starter code that does that. If that doesn't fully make sense yet, don't worry. It will soon.

    Overloaded Constructors
    Overloaded Constructors

    Just like with other methods, classes can provide multiple constructors as long as they accept different parameters:

    class Person {
    String name;
    double age;
    Person(String setName, double setAge) {
    name = setName;
    age = setAge;
    }
    // Useful for really new people, like babies
    Person(String setName) {
    name = setName;
    age = 0.0;
    }
    }
    Person geoff = new Person("Geoff", 41.05);
    // Lily is my niece. Super cute. Probably not into Java yet.
    Person lily = new Person("Lily");
    System.out.println(geoff.age);
    System.out.println(lily.age);

    Homework: Simple Object Field 2

    Created By: Geoffrey Challen
    / Version: 2021.9.0

    Create a class called Simple that stores a single String value using a field named data. Simple should implement a function called setData that accepts a single String and changes the saved value. (It should not return a value.) Simple should also implement a function called getData that returns the saved value.

    Note that you should include public before your class definition for this problem. We've provided starter code that does that. If that doesn't fully make sense yet, don't worry. It will soon.

    More Practice

    Need more practice? Head over to the practice page.