Java[2] 类与对象-优快云博客

[public] [abstract | final] class ClassName [extends SuperClass]

[implements InterfaceNameList] {

// 1. 声明类字段

// 2. 定义构造器

// 3. 定义类方法

}

3.2 实例字段

与声明变量类似

[public | protected | private] [static] [final] type variable [ = value];

关键字 private 确保只有类本身的方法能够访问这些实例字段

可以包含类类型的实例字段

3.3 构造器（方法）

构造器与类同名

[public | protected | private] ClassName ([paramList]) {

// 方法体

}

每个类可以有一个以上的构造器
构造器可以有0个 1个或多个参数
构造器没有返回值
构造器总是结合 new 操作符一起调用

3.4 隐式参数和显示参数

隐式参数：出现在方法名前的类对象（方法调用的目标或接收者）
显示参数：位于方法名后括号中的数值

关键字 this 指示隐式参数（类似于 Python 中的关键字 self）

3.5 访问器与更改器（方法）

[public | protected | private] [static] [final | abstract] returnType methodName ([paramList]) {

// 方法体

}

访问器

返回实例字段的值

如果需要返回一个可变对象的引用首先应该对它进行克隆

[public | protected | private] [static] [final] paramType getParam() {

return param;

}

更改器

修改实例字段的值

[public | protected | private] [final] void setParam(paramType param) {

this.param = param;

}

获得或修改实例字段的值需要：

一个私有的实例字段
一个公共的字段访问器方法
一个公共的字段更改器方法
一个类的方法可以访问这个类的所有对象的私有数据

将关键字 public 改为 private 即可实现私有方法
可以将实例字段定义为 final （不可变）

四、静态字段与静态方法

4.1 静态字段（关键字 static）

使用关键字 static 定义

不会出现在每个类的对象中

只有一个副本属于类不属于对象

4.2 静态常量

使用关键字 static 和 final 定义

可以直接通过类调用例如 Math.PI

4.3 静态方法

是不操作对象的方法（可以认为是没有 this 参数的方法）例如 Math.pow(x, a)

可以访问静态字段

建议使用类名而不是对象来调用（使用对象调用是合法的）

可以使用的情况：

方法不需要访问对象状态所需参数通过显示参数提供
方法只需要访问静态字段

4.5 工厂方法*

4.6 main方法

不对任何对象进行操作

可用于为类增加演示代码

五、方法参数

参数传递方式：

按值调用：方法接收的是调用者提供的值
按引用调用：方法接收的是调用者提供的变量位置
按名调用*

方法可以修改按引用传递的变量的值不能修改按值传递的变量的值

Java是按值调用但可以改变对象参数的状态

Java的方法参数使用总结：

不能修改基本数据类型（数值型或布尔型）的参数
可以改变对象参数的状态
不能让一个对象参数引用一个新对象

六、对象重构

6.1 重载

如果多个方法有相同的方法名但有不同的参数便出现了重载

编译器会用各个方法首部中的参数类型与特定方法调用中所使用的值类型进行匹配选出正确的方法

Java允许重载任何方法

不能有两个名字相同参数类型也相同却又不同返回类型的方法

[public | protected | private] [static] [final | abstract] returnType methodName ([paramList1]) {

// 方法体

}

[public | protected | private] [static] [final | abstract] returnType methodName ([paramList2]) {

// 方法体

}

......

6.2 默认字段初始化

如果在构造器中没有显示地为一个字段设置初始值就会将它自动设置为默认值：

数值 --> 0
布尔值 --> flase
对象引用 --> null

6.3 无参数构造器

类没有构造器时会自动提供一个无参数构造器所有实例字段默认初始化

无参数构造器可以为对象的状态设置适当的默认值

类中至少有一个构造器没有无参数构造器使用构造器时必须提供参数

6.4 显示字段初始化

可以在类定义中直接为任何字段赋值

初始值不一定是常量值

参数名会遮蔽同名的实例字段

6.5 调用另一个构造器

如果构造器的第一个语句形如 this(...) 这个构造器将调用同一个类的另一个构造器

6.6 初始化块

在一个类的声明中可以使用任意的代码块构造对象时会自动执行

首先运行初始化块然后才运行构造器的主体部分

通常直接将初始化代码放在构造器中

七、记录

7.1 概念

一种特殊形式的类状态不可变公共可读

record ClassName(paramType1 param1, paramType2 param2, ...) {

// 类体

}

组件：一个记录的实例字段
自动定义构造器和访问器

ClassName(paramType1 param1, paramType2 param2, ...) // 默认构造器

public paramType1 param1() // 默认访问器

public paramType2 param2()

......

3个自动定义的方法：

toString
equals
hasCode

可以增加自己的方法

可以有静态字段和方法

record ClassName(paramType1 param1, paramType2 param2, ...) {

public static type variable [ = value]; // 自定义静态字段

public static returnType methodName([ParamList]) { // 自定义静态方法

// 方法体

}

public returnType methodName([ParamList]) { // 自定义方法

// 方法体

}

}

不能为记录增加实例字段（记录的字段自动为 final （不可变）字段）

7.2 自定义构造器

必须调用另一个构造器

record ClassName(paramType1 param1, paramType2 param2, ...) {

public ClassName() {

this(paramType1 param1, paramType2 param2, ...);

}

}

八、包

8.1 包名

使用包的主要作用是确保类名的唯一性

为了保证包名的绝对唯一性可以使用 Internet 域名以逆序的形式作为包名

8.2 类的导入

一个类可以使用所属包中的所有类以及其他包中的公共类

访问类的方式

完全限定名（包后面跟着类名）
使用 import 语句导入一个特定的类或整个包

import 语句应该位于源文件的顶部

只能使用 “ * ” 导入一个包

静态导入（import static）：允许导入静态方法和静态字段

import java.util.Scanner // 导入特定类

import java.util.* // 导入 java.util 中的所有类导入 java.util 包

import static java.lang.Math.sqrt // 静态导入

8.3 增加类

想将类放入包中必须将包名放在源文件的开头使用 package 语句

如果没有在源文件中放置 package 语句这个源文件中的类就属于无名包（没有包名）

8.4 访问

如果没有指定 public 或 private 这个部分可以由同一个包中的所有方法访问

8.5 类路径

参考视频：http://www.bilibili.com/video/BV1Pu4y1Z7qq

九、JAR文件

9.1 包含

类文件

资源文件

清单文件

9.2 创建JAR文件

9.3 清单文件（MANIFEST.MF）

位于 JAR 文件的 META-INF 子目录中

十、文档注释

10.1 注释的插入

信息来源：

模块
包
公共类与接口
公共的和受保护的字段
公共的和受保护的构造器及方法

文档注释（/** . . . */）

包含标记（@）以及之后紧跟着的自由格式文本
自由格式文本第一句是概要陈述
自由格式文本可以使用 HTML 修饰符
键入等宽代码需要使用 {@code . . .}

10.2 类注释

必须放在 import 语句之后 class 定义之前

10.3 方法注释

必须放在所描述的方法之前

@ param variable description（参数条目）
@ return description（返回描述）
@ throws class description（异常条目）

10.4 字段注释

只需要对公共字段（通常是静态常量）增加文档注释

10.5 通用注释

@ since text（始于条目）
@ author name（作者条目）
@ version text（版本条目）

@ see 或 @ link reference（超链接条目）

可以用于类中也可以用于方法中

package.class#feature label
<a href=" . . . ">label</a>
"text"

10.6 包注释

在包目录中添加一个单独的文件

提供一个名为 package-info.java 的文件

提供一个名为 package.html 的文件抽取标记<body> . . . </body>之间的所有文本

10.7 注释的提取

十一、类设计技巧

保证数据私有
要初始化数据
不要在类中使用过多的基本类型（其他的类）
不是所有字段都需要单独的字段访问器和更改器
分解有过多职责的类
类名和方法名要能够体现它们的职责
优先使用不可变的类

编程练习

public class Person {
    String name;
    int age;

    public Person () {
        this.name = "unknown";
        this.age = 0;
    }

    public Person (String name) {
        this.name = name;
        this.age = 0;
    }

    public Person (int age) {
        this.name = "unknown";
        this.age = age;
    }

    public Person (String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void setName (String name) {
        this.name = name;
    }

    public void setAge (int age) {
        this.age = age;
    }

    public String getName () {
        return this.name;
    }

    public int getAge () {
        return this.age;
    }

    public void speak () {
        System.out.printf("My name is %s. I'm %d years old.\n", this.name, this.age);
    }

    public static void main (String[] args) {
        String name = "Oliver";
        int age = 20;
        Person person = new Person();

        person.setName(name);
        person.setAge(age);
        System.out.println(person.getName());
        System.out.println(person.getAge());
        person.speak();

        person.setName("John");
        person.setAge(18);
        person.speak();
    }
}

public class Circle {
    private double centerX;
    private double centerY;
    private double radius;

    public Circle() {
        this(1.0);
    }

    public Circle(double radius) {
        this.radius = radius;
    }

    public double getRadius() {
        return this.radius;
    }

    public void setRadius(double radius) {
        this.radius = radius;
    }

    public double getArea() {
        return this.radius * this.radius * Math.PI;
    }

    public double getPerimeter() {
        return 2 * this.radius * Math.PI;
    }

    public static void main(String[] args) {
        Circle circle = new Circle();

        System.out.printf("The radius of the circle is %f.\n", circle.getRadius()); // The radius of the circle is 1.000000.
        System.out.printf("The perimeter of the circle is %f.\n", circle.getPerimeter());   // The perimeter of the circle is 6.283185.
        System.out.printf("The area of the circle is %f.\n", circle.getArea()); // The area of the circle is 3.141593.

        Circle mycircle = new Circle(Math.E);
        System.out.printf("The radius of the circle is %f.\n", mycircle.getRadius());   // The radius of the circle is 2.718282.
        mycircle.setRadius(Math.PI);
        System.out.printf("The radius of the circle is %f.\n", mycircle.getRadius());   // The radius of the circle is 3.141593.
    }
}

public class Rectangle {
    private double length;
    private double width;

    public Rectangle() {
        this(1.0, 1.0);
    }

    public Rectangle(double length, double width) {
        this.length = length;
        this.width = width;
    }

    public double getLength() {
        return this.length;
    }

    public double getWidth() {
        return this.width;
    }

    public void setLength(double length) {
        this.length = length;
    }

    public void setWidth(double width) {
        this.width = width;
    }

    public double getPerimeter() {
        return 2 * (this.length + this.width);
    }

    public double getArea() {
        return Math.pow(this.length + this.width, 2);
    }

    public static void main(String[] args) {
        Rectangle rectangle = new Rectangle();
        System.out.printf("The length of the rectangle is %f.\n", rectangle.getLength());   // The length of the rectangle is 1.000000.
        System.out.printf("The width of the rectangle is %f.\n", rectangle.getWidth()); // The width of the rectangle is 1.000000.
        System.out.printf("The perimeter of the rectangle is %f.\n", rectangle.getPerimeter()); // The perimeter of the rectangle is 4.000000.
        System.out.printf("The area of the rectangle is %f.\n", rectangle.getArea());   // The area of the rectangle is 4.000000.

        Rectangle myRectangle = new Rectangle(0, 0);
        myRectangle.setLength(3.82);
        myRectangle.setWidth(6.19);
        System.out.printf("The length of my rectangle is %f.\n", myRectangle.getLength());  // The length of my rectangle is 3.820000.
        System.out.printf("The width of my rectangle is %f.\n", myRectangle.getWidth());    // The width of my rectangle is 6.190000.
        System.out.printf("The perimeter of my rectangle is %f.\n", myRectangle.getPerimeter());    // The perimeter of my rectangle is 20.020000.
        System.out.printf("The area of my rectangle is %f.\n", myRectangle.getArea());  // The area of my rectangle is 100.200100.
    }
}

public class Triangle {
    private double a;
    private double b;
    private double c;

    public Triangle() {
        this(0.0, 0.0, 0.0);
    }

    public Triangle(double a, double b, double c) {
        this.a = a;
        this.b = b;
        this.c = c;
    }

    public double area() {
        double s = (a + b + c) / 2;
        return Math.sqrt(s * (s - a) * (s - b) * (s - c));
    }

    public static void main(String[] args) {
        Triangle triangle = new Triangle();
        System.out.printf("The area of the triangle is %f.\n", triangle.area());    // The area of the triangle is 0.000000.

        Triangle myTriangle = new Triangle(3.0, 4.0, 5.0);
        System.out.printf("The area of my triangle is %f.\n", myTriangle.area());   // The area of my triangle is 6.000000.
    }
}

public class Stock {
    private String symbol;
    private String name;
    private double previousPrice;
    private double currentPrice;

    public Stock(String symbol, String name) {
        this.symbol = symbol;
        this.name = name;
    }

    public void setPreviousPrice(double price) {
        previousPrice = price;
    }

    public void setCurrentPrice(double price) {
        currentPrice = price;
    }

    public double getChangePercent() {
        return (currentPrice - previousPrice) / previousPrice;
    }

    public static void main(String[] args) {
        Stock stock = new Stock("60000", "浦发银行");
        stock.setPreviousPrice(25.5);
        stock.setCurrentPrice(28.6);
        System.out.print(stock.getChangePercent()); // 0.12156862745098045
    }
}

public class Fibonacci {
    public static long fib (int n) {
        if (n == 1 || n == 2) return 1;
        else return fib(n - 1) + fib(n - 2);
    }

    public static void main(String[] args) {
        int n = 20;
        for (int i = 0; i < n; i++) {
            System.out.print(fib(i + 1));
            System.out.print(' ');
        }
    }
}

import java.util.Scanner;
public class QuadraticEquation {
    private double a;
    private double b;
    private double c;

    public QuadraticEquation(double a, double b, double c) {
        this.a = a;
        this.b = b;
        this.c = c;
    }

    public double getA() {
        return a;
    }

    public double getB() {
        return b;
    }

    public double getC() {
        return c;
    }

    public double getDiscriminant() {
        return Math.pow(b, 2) - 4 * a * c;
    }

    public double getRoot1() {
        if (this.getDiscriminant() < 0) return 0;
        else return (-b + Math.sqrt(this.getDiscriminant())) / (2 * a);
    }

    public double getRoot2() {
        if (this.getDiscriminant() < 0) return 0;
        else return (-b - Math.sqrt(this.getDiscriminant())) / (2 * a);
    }

    public static void main(String[] args) {
        int[] coefficient = new int[3];
        Scanner in = new Scanner(System.in);

        System.out.println("please input (a, b, c) one by one:");
        for (int i = 0; i < 3; i++) {
            coefficient[i] = in.nextInt();
        }

        QuadraticEquation equation = new QuadraticEquation(coefficient[0], coefficient[1], coefficient[2]);
        if (equation.getDiscriminant() < 0) {
            System.out.println("The equation has no real roots");
        } else if (equation.getDiscriminant() == 0) {
            System.out.printf("The root of the equation is %f.", equation.getRoot1());
        } else {
            System.out.printf("The root of the equation is %f and %f.", equation.getRoot1(), equation.getRoot2());
        }
    }
}