Java基础(二)之面向对象编程

一、类和对象

  Java 是一门面向对象的编程语言,其重要的一个思想就是“万物皆对象”。而类是 Java 的核心内容,它是一种逻辑结构,定义了对象的结构,可以由一个类得到众多相似的对象。从某种意义上说,类是 Java 面向对象性的基础。Java 与 C++不同,它是一门完全的面向对象的编程语言,它的任何工作都要在类中进行。
  类(class)实际上是一个模板,而对象是由这个模板产生的多个实例(instance [ˈɪnstəns])。
在这里插入图片描述
  实际上前面的程序中也是在类中实现的,不过全在类中的 main 方法中演示程序的使用,没有体现面向对象编程的思想。这一节里主要讲解 Java 类的相关知识,包括类的形式、类包含的内容,即属性和方法。

二、如何定义类

  Java 的重要思想是万物皆对象,也就是说在 Java 中可以把所有现实中的一切人和物都看做对象,而类就是它们的一般形式。编写程序就是抽象出这些事物的共同点,用程序语言的形式表达出来。

  语法如下:

class 类名{
类型 实例变量名;
类型 实例变量名;
}

  案例:可以把某某人看做一个对象,那么就可以把人作为一个类抽象出来,这个人就可以作为人这个类的一个对象。

public class Person {
    int age;
    String name;
}

  注意:在类名面前可以不加上修饰符 public,在 Java 中是允许把许多类放在一个 Java 文件中,但是这些类只能有一个类被声明为 public,而且这个类的名字必须和 Java 文件名相同。
  案例:通过 Person 类创建两个对象小明和小张

Person person1 = new Person();
person1.age = 12;
person1.name = "小明";
Person person2 = new Person();
person2.age = 13;
person2.name = "小张";
System.out.println(person1);
System.out.println(person2);

  说明:输出到控制台为 Person@1540e19d,原因是 toString 方法没有重写,idea 生成 toString 方法的快捷键是 alt + insert,toString 方法主要用来控制对象的输出格式。

三、成员方法(函数)

  成员方法也叫成员函数、实例方法。如人类:除了有一些属性(Field [fiːld])如:年龄、姓名…外,我们人类还有一些行为比如:可以说话、跑步、学习、还可以做算术题。这时就要用成员方法(Method [ˈmeθəd])才能完成。
在这里插入图片描述
案例:

  • 添加 speak 成员方法,输入出:我是谁,我是一个好人。
  • 添加 calculate 成员方法,可以计算从 1+…+1000 的结果。
  • 添加 calculate 成员方法,该方法可以接收一个数 n,计算返回从 1+…+n 的结果。
  • 添加 add 成员方法,可以计算返回两个数的和。
public class Person {
    int age;
    String name;

    public void speak() {
        System.out.println("我是" + name + ",我是好人!");
    }

    public int calculate() {
        int sum = 0;
        for (int i = 1; i <= 1000; i++) {
            sum += i;
        }
        return sum;
    }

    public int calculate(int n) {
        int sum = 0;
        for (int i = 1; i <= n; i++) {
            sum += i;
        }
        return sum;
    }

    public int add(int x, int y) {
        return x + y;
    }

    @Override
    public String toString() {
        return "Person{" +
                "age=" + age +
                ", name='" + name + '\'' +
                '}';
    }
}

class MainTest {
    public static void main(String[] args) {
        Person person1 = new Person();
        person1.age = 12;
        person1.name = "张三";
        Person person2 = new Person();
        person2.age = 18;
        person2.name = "李四";
        System.out.println(person1);
        System.out.println(person2);
        person2.speak();
        int calculate = person2.calculate(5);
        System.out.println(calculate);
        int add = person1.add(2, 8);
        System.out.println(add);
    }
}

  按照要求完成后两个方法,然后看看和课件上区别在哪里。

  语法如下:

public 返回数据类型 方法名(参数列表){
    语句;//方法(函数)主体
}
1、参数列表:表示成员函数输入
2、返回数据类型:表示成员函数输出
3、函数主体:表示为了实现某一功能代码块

  注意方法有如下特性:

  • 方法名在有不同参数的情况下可以使用同一个方法名,即有参数和没参数的方法可以同名。
  • 返回类型和返回结果的类型要一致。
  • 在调用某个成员方法的时候,给出的具体数值的个数和类型要相匹配。

练习:

  请定义一个交通工具 Car 的类其中有:属性速度 speed 体积 size 等等;方法移动 move();设置速度 setSpeed(int speed);加速 speedUp();减速 speedDown()等等。最后在测试类 CarTest 中的 main() 方法中实例化一个车对象并通过方法给它初始化 speed,size 的值并且通过打印出来。另外调用加速减速的方法对速度进行改变。

参考代码:

public class Car {
    int speed;
    String size;

    public void move() {
        System.out.println("正在以" + speed + "的速度运行");
    }

    public void setSpeed(int sp) {
        speed = sp;
    }

    public void speedUp() {
        speed += 100;
    }

    public void speedDown(int sp) {
        speed -= 100;
    }

    @Override
    public String toString() {
        return "Car{" +
                "speed=" + speed +
                ", size='" + size + '\'' +
                '}';
    }
}

class CarTest {
    public static void main(String[] args) {
        Car car = new Car();
        car.speed = 100;
        car.size = "5m^3";
        car.move();
        car.setSpeed(200);
        car.move();
        car.speedUp();
        System.out.println(car);
    }
}

四、访问控制修饰符

  java 提供四种访问控制修饰符号控制类、方法和属性的访问权限:
在这里插入图片描述
1、公开级别:用 public [ˈpʌblɪk]修饰,对外公开。

2、受保护级别:用 protected [prəˈtektɪd]修饰,对子类和同一个包中的类公开。

3、默认级别:没有修饰符号,向同一个包的类公开。

4、私有级别:用 private [ˈpraɪvət]修饰,只有类本身可以访问,不对外公开。

具体如下:

访问级别	修饰符    	同类	同包	子类	不同包
公  开    	public    	√	√	√	√
受保护    	protected	√	√	√	╳
默  认    	没有修饰符	√	√	╳	╳
私  有    	private    	√	╳	╳	╳

package:包,用来区分相同类名的类,在类前面声明用于标识当前类所在的包。

import:用于表明当前类中所用到的类。如果是导入同一个包内的其他类,可省略。

五、构造方法

  构造方法(Constructor [kənˈstrʌktə®])是类的一种特殊的方法(Method),它的主要作用是完成对新对象的初始化(initialize [ɪˈnɪʃəlaɪz])。

public class User {
    public int id;
    public String name;

    public User() {//无参构造
    }

    public User(int id, String name) {//有参构造
        this.id = id;
        this.name = name;
    }

}

class MainTest {
    public static void main(String[] args) {
        User user = new User(1, "张三");//调用有参构造初始化对象
        User user1 = new User();//调用无参构造初始化对象(需要再设置对象属性)
        user1.id = 2;
        user1.name = "李四";
    }
}

  构造方法有几个特点:

  • 方法名和类名相同,且没有返回值。
  • 在创建一个类的新对象时,系统会自动的调用该类的构造方法完成对新对象的初始化。
  • 一个类可以定义多个不同的构造方法。
  • 如果程序员没有定义构造方法,系统会自动生成一个默认的无参构造方法。
  • 如果创建了有参数的构造方法,则系统不自动生成无参数的构造方法,程序员一般需要手动创建。

  注意:在类中的 this 是自身的一个对象,代表对象本身,可以理解为:指向对象本身的一个指针。

练习:

  1.在程序中经常要对时间进行操作但是并没有时间类型的数据。那么我们可以自己实现一个时间类来满足程序中的需要。定义名为 MyTime 的类其中应有三个整型成员时 hour 分 minute 秒 second。为了保证数据的安全性这三个成员变量声明为私有。为 MyTime 类定义构造方法以方便创建对象时初始化成员变量。再定义 display() 方法用于将时间信息打印出来。为 MyTime 类添加以下方法 addSecond(int sec)、addMinute(int min)、addHour(int hou)、subSecond(int sec)、subMinute(int min)、subHour(int hou) 分别对时、分、秒进行加减运算。

参考代码:

public class MyTime {
    private int hour;
    private int minute;
    private int second;

    public MyTime(int x, int y, int z) {
        this.hour = x;
        this.minute = y;
        this.second = z;
    }

    public void display() {
        System.out.println("现在时间:" + this.hour + ":" + this.minute + ":" + this.second);
    }

    public void addHour(int hou) {
        this.hour = this.hour + hou;
    }

    public void addSecond(int sec) {
        this.second = this.second + sec;
    }

    public void addMinute(int min) {
        this.minute = this.minute + min;
    }

    public void subHour(int hou) {
        this.hour = this.hour - hou;
    }

    public void subMinute(int min) {
        this.minute = this.minute - min;
    }

    public void subSecond(int sec) {
        this.second = this.second - sec;
    }
}

六、类变量

1.类变量

  类变量(static field)是该类的所有对象共享的变量。任何一个该类的对象去访问它时,取到的都是相同的值,同样任何一个该类的对象去修改它时,修改的也是同一个变量。
在这里插入图片描述
语法如下:

  访问修饰符 static 数据类型 变量名;

  案例:完成对象创建个数统计

public class Person {
    public static int count;
    public int age;
    public String name;

    public Person() {
        count++;
    }

    public static void main(String[] args) {
        Person person = new Person();
        Person person1 = new Person();
        System.out.println(person1.count);//2
        person.age = 12;
        person.name = "张三";
        new Person();
        System.out.println(Person.count);//3
    }
}

  思考一下,类变量还可以用在哪些地方。

七、类方法(静态方法)

  类方法(static method)是属于所有对象实例共享的方法。

  语法如下:

  访问修饰符 static 数据返回类型 方法名(参数列表){}

  注意:

  • 类方法中不能访问普通属性(实例属性),而普通方法既可以访问普通属性也可以访问静态属性。
  • 一般使用 类名.类方法名() 或者 对象名.类方法名() 调用类方法(int i = Integer.parseInt(“12”);)

案例:

public class Person {
    public static int count;
    public int age;
    public String name;

    public Person() {
        count++;
    }

    public void say() {//普通方法既可以访问类属性,也可以普通属性
        System.out.println("我是" + name + ",我是好人,共" + count + "个对象");
    }

    public static void staticSay() {//类方法不能访问对象属性(实例属性,普通属性)
        System.out.println("创建了" + count);
    }

    public static void main(String[] args) {
        Person person = new Person();
        person.staticSay();//对象.方法名() 方式调用静态方法
        Person.staticSay();//类名.方法名() 方式调用静态方法
        new Person();
        System.out.println(Person.count);
    }
}

  思考一下类方法在实际开发中的主要作用。

练习:

  1.用自己的话描述 static 的用法,它修饰的属性与方法都有哪些特征。

八、方法重载

  方法重载(overload [əʊvəˈləʊd])就是在类的同一种功能的多种实现方法,方法的参数列表不同,到底采用哪个方法调用(Invoke [ɪnˈvəʊk]),取决于调用者给出的参数(Parameter [pəˈræmɪtə®])。
在这里插入图片描述
注意事项:

  • 方法名必须相同。
  • 方法的参数类型、个数、顺序至少有一项不同,简称参数列表不同(Parameter list)。
  • 方法的返回类型,访问级别和 throws 子句对使其成为重载方法没有任何影响。

案例:

public void aa(){
}
public void aa(int i1){
}

如上就是方法的重载,重载在我们后面开发中是非常常见的。

练习:

  1.创建一个类 MathUtil 并使该类无法创建对象,里面编写三个重载的静态方法方法 max 。第一个方法求两个 int 值中的最大值,第二个方法求两个 double 中的最大值,第三个方法求三个 double 中的最大值,并且分别调用三个方法。

参考代码:

public class MathUtil {
    private MathUtil() {
    }

    public static int max(int i, int j) {
        return (i > j) ? i : j;
    }

    public static double max(double i, double j) {
        return (i > j) ? i : j;
    }

    public static double max(double i, double j, double k) {
        return max(i, j) > k ? max(i, j) : k;
    }
}

class MainTest {
    public static void main(String[] args) {
        int i1 = MathUtil.max(3, 4);
        System.out.println("两个int中的最大值是:" + i1);
        double i2 = MathUtil.max(3.1, 3.2);
        System.out.println("两个double中的最大值是:" + i2);
        double i3 = MathUtil.max(3.1, 3.2, 3.3);
        System.out.println("三个double中的最大值是:" + i3);
    }
}

九、方法覆盖

  方法覆盖也叫方法重写(override)就是子类有一个方法,和父类的某个方法的名称、返回类型、参数一样,那么我们就说子类的这个方法覆盖了父类的那个方法。

  java 里面的所有类都是 Object 的子类。

  注意事项:

  • 子类的方法的返回类型,参数,方法名称,要和父类的返回类型,参数,方法名称完全一样,否则不能构成方法覆盖。
  • 一般在覆盖的方法上添加注解(@Override),用于检查和方法的返回类型,参数,方法名称是否完全一样。
  • 子类方法不能缩小父类方法的访问权限。

案例:

Object 的 toString
public String toString() {
    return getClass().getName() + "@" + Integer.toHexString(hashCode());
}

自己的 toString
@Override
public String toString() {
    return "Person{" +
        "age=" + age +
        ", name='" + name + '\'' +
        '}';
}

方法覆盖主要是子类覆盖父类的方法。

十、抽象

  我们在前面去定义一个类时候,实际上就是把一类事物的共有的属性(Field)和行为(Method)抽取出来,形成一个物理模型,叫做模版类(class)。这种研究问题的方法称为抽象(abstract)。
在这里插入图片描述

十一、封装

  封装就是把抽象出来的属性(Field)数据和对属性数据的操作封装在一起,属性数据被保护在内部,程序的其它部分只有通过被授权的成员方法(Method)操作数据,没有对应的授权方法则该属性数据不可操作。
在这里插入图片描述
  常见的属性数据操作有:设置(setter)和获取(getter)。

public class Person {
    private String wxh;
    private int age;
    private String name;

    public Person(String wxh) {
        this.wxh = wxh;
    }

    public int getAge() {
        return age;
    }

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

    public String getName() {
        return name;
    }

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

class MainTest {
    public static void main(String[] args) {
        Person person = new Person("wpf_123");
        person.setName("张三");
        person.setAge(18);
        System.out.println(person.getAge());
    }
}

  在开发过程中,经常把一些常用的代码块放入一个方法,其他类或对象在使用时直接调用该方法,而不用再重新写一遍,从而增加代码的复用率,这种操作也叫做封装。

十二、继承

  继承(extend)可以解决代码复用问题,让我们的编程更加靠近人类思维。当多个类存在相同的属性(变量)和方法时,可以从这些类中抽象出父类,在父类中定义这些相同的属性(Field)和方法(Method),所有的子类不需要重新定义这些属性和方法,只需要通过 extends 语句来声明继承父类。这样,子类就会自动拥有父类定义的某些属性和方法。

语法:

  class 子类 extends 父类

  父类的 public、protected 和默认修饰符修饰的属性和方法被子类继承了,而父类的 private 修饰符修饰的属性和方法不能被子类继承。

public class Student extends Person {
    private String classRoom;
}

  注意:super 可以理解为是指向自己超(父)类对象的一个指针,而这个超类指的是离自己最近的一个父类。

  案例:当我们在 Person 里面添加一个全参构造时,在子类 Student 里面通过 super 调用父类构造方法。

public Student(int age, String name, String classRoom) {
    super(age, name);
    //super.setAge(age);
    setName(name);
    this.classRoom = classRoom;
}

  java 的继承是单继承,也就是一个类最多只能有一个父类,这种单继承的机制可保证类的纯洁性,比 C++ 中的多继承机制简洁。

练习:

  建立一个汽车 Auto 类:汽车颜色、车身重量、速度等成员变量。并通过不同的构造方法创建实例。至少要求汽车能够加速减速停车。再定义一个小汽车类 Car 继承 Auto 并添加空调成员变量并覆盖加速方法。

public class Auto {
    private String color;
    private double weight;
    private int speed;

    public void speedUp() {
        System.out.println("我在加速");
    }

    public void speedDown() {
        System.out.println("我在减速");
    }

    public void stop() {
        System.out.println("熄火了");
    }

    public static void main(String[] args) {
        Car car = new Car();
        car.speedUp();
    }
}

class Car extends Auto {
    private String airCondition;

    @Override
    public void speedUp() {
        System.out.println("我在加速!!!");
    }
}

十三、多态

  多态就是指一个引用类型在不同情况下的多种状态。也可以理解成:

  多态是指父类的类型可以存放子类的实例;

  通过调用父类的方法自动调用子类实现了的或重写了的方法;

Person person = new Student();

  这种转换时自动完成的,在调用 Person 对象的方法时自动调用 student 重写或实现的方法。

  缺点:使用多态会使创建出来的对象丢失子类的方法。

  优点:大多在设计模式中使用,使程序更加通用。

class MainTest {
    public static void main(String[] args) {
        Person person1 = new Student(1, "张三", "java2004");
        Student person2 = new Student(1, "张三", "java2004");
        Worker person3 = new Worker(1, "张三", "天狼科技");
        changeName(person2, "历史");
    }

    private static void changeName(Person person, String name) {
        person.setName(name);
    }
}

十四、抽象类

  当父类的一些方法不能确定时,可以用 abstract [ˈæbstrækt] 关键字来修饰该方法,这种方法叫做抽象方法(abstract method)。拥有抽象方法的类必须添加 abstract 关键字修饰,用 abstract 来修饰的类叫抽象类(abstract class)。

public abstract class Animal {
    private String name;

    abstract public void cry();

    public void sx() {
        System.out.println("实现方法");
    }

    public static void main(String[] args) {
        Animal dog = new Dog();
        dog.cry();
    }
}

class Dog extends Animal {
    @Override
    public void cry() {
        System.out.println("汪汪汪汪!!!!");
    }
}
  • 用 abstract 关键字来修饰一个类时,这个类就是抽象类,抽象类不能被实例化(new Animal())
  • 用 abstract 关键字来修饰一个方法时,这个方法就是抽象方法。
  • 抽象方法是不允许在该抽象类中实现的(void cry() { })也就是方法不能有方法体,一旦实现(有方法体)就编译报错。
  • 抽象方法只能在子类中实现。
  • 抽象类中可以拥有实现过的方法。

注意:

  抽象类不一定要包含抽象方法。也就是说,抽象类可以没有抽象方法。一旦类包含了抽象方法,则这个类必须声明为抽象类。

练习:

  创建一个 Vehicle 类并将它声明为抽象类。在 Vehicle 类中声明一个 getWheels 抽象方法使它输出轮子个数。创建两个类 Car 和 Motorbike 从 Vehicle 类继承并在这两个类中实现 getWheels 方法。在 Car 类中应当显示“四轮车”信息而在 Motorbike 类中应当显示“双轮车”信息。创建另一个带 main 方法的类在该类中创建 Car 和 Motorbike 的实例并在控制台中显示消息。

public class Demo{
    public static void main(String[] dsa) {
        Car c = new Car();
        c.getWheels();
        Motorbike m = new Motorbike();
        m.getWheels();
    }
}

abstract class Vehicle {
    abstract public void getWheels();
}

class Car extends Vehicle {
    public void getWheels() {
        System.out.println("四轮车");
    }
}

class Motorbike extends Vehicle {
    public void getWheels() {
        System.out.println("双轮车");
    }
}

十五、接口

  接口(interface [ˈɪntəfeɪs])就是给出一些没有方法体的方法,封装到一起,到某个类要使用的时候,再根据具体情况把这些方法写出来。接口是更加抽象的抽象类,抽象类里的方法可以有方法体,接口里的所有方法都没有方法体。接口体现了程序设计的多态和高内聚低偶合的设计思想。接口和类之间一般使用 implements [ˈɪmplɪments]表示父子关系。

接口的建立语法:
interface 接口名{
    方法;
}
实现类语法:
class 类名 implements 接口{
    方法;
    变量;
}

高内聚,低耦合:

  每个模块之间相互联系的紧密程度,模块之间联系越紧密,则耦合性越高,模块的独立性就越差!反之同理;

  一个模块中各个元素之间的联系的紧密程度,如果各个元素(语句、程序段)之间的联系程度越高,则内聚性越高,即高内聚!

  如:一个项目中有 20 个方法调用良好,但是要修改了其中一个,另外的 19 个都要进行修改,这就是高耦合!独立性太差!

  现在的软件结构设计,都会要求“高内聚,低耦合”,来保证软件的高质量!

public interface Person {
    void say();
}

class PersonMain implements Person {
    @Override
    public void say() {
        System.out.println("1212");
    }

    public static void main(String[] args) {
       Person person = new PersonMain();
       person.say();
    }
}

注意:

  • 接口不能被实例化(new Person()),接口中的方法默认都是 public 修饰的。
  • 接口中所有的方法都不能有方法体(void aaa(){}),故接口可以看作更加抽象的抽象类。
  • 一个类可以实现多个接口(class PersonMain implements Person, Serializable{})。
  • 接口中可以有变量,但变量不能用 private 和 protected 修饰。接口中的变量,本质上都是 static 的而且是 final (最终的)类型的,不管你加不加 static 修饰,通常称为常量。
  • 一个接口不能继承其它的类,但是可以继承别的接口。
public interface Person {
    int aa = 0;
    void say();
}

interface PersonMain extends Person {  
    public void say1();
}

class Main implements PersonMain {

    @Override
    public void say() {
    }

    @Override
    public void say1() {
    }
}

案例:

public class Demo {
    public static void main(String[] args) {
        LittleMonkey li = new LittleMonkey();
        li.setName("孙悟空");
        li.swimming();
        li.fly();
    }
}

interface Fish {
    void swimming();
}

interface Bird {
    void fly();
}

class Monkey {
    private String name;

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

    public void jump() {
        System.out.println("猴子会跳!");
    }
}

class LittleMonkey extends Monkey implements Fish, Bird {
    public void swimming() {
        System.out.println("学到了鱼的游泳!");
    }

    public void fly() {
        System.out.println("学到了鸟飞翔!");
    }
}

注意:

  • 实现接口可以看作是对继承的一种补充。
  • 实现接口可在不打破继承关系的前提下,对某个类功能扩展,非常灵活。

练习:

  1.创建一个名称为 Vehicle 的接口在接口中添加两个方法 start() 和 stop()。在两个名称分别为 Bike 和 Bus 的类中实现 Vehicle 接口。创建一个名称为 InterfaceDemo 的类在 InterfaceDemo 的 main() 方法中创建 Bike 和 Bus 对象并访问 start() 和 stop() 方法。

参考代码:

public class InterfaceDemo {
    public static void main(String[] dsa) {
        Bike bike = new Bike();
        bike.start();
        bike.stop();
        Bus bus = new Bus();
        bus.start();
        bus.stop();
    }
}

class Bike implements Vehicle {
    public void start() {
        System.out.println("我是自行车,我启动了!!");
    }

    public void stop() {
        System.out.println("我是自行车,我停止了!!");
    }
}

class Bus implements Vehicle {
    public void start() {
        System.out.println("我是公共汽车,我启动了!!");
    }

    public void stop() {
        System.out.println("我是公共汽车,我停止了!!");
    }
}
public interface Vehicle {
    void start();
    void stop();
}

十六、new 运算符背后(自)

  new 运算符,new 创建对象实例(new User(“aa”)),对象引用(s)指向对象实例。

   对象实例在堆内存中, 对象引用存放在栈内存中。

   一个对象引用可以指向 0 个或 1 个对象 (一根绳子可以不系气球,也可以系一个气球);

  一个对象可以有 n 个引用指向它(可以用 n 条绳子系住一个气球)。

String s = new String("aa");
String s1= s;

阶段练习:

  • 1.编写 Java 程序模拟简单的计算器。 定义名为 Number 的类其中有两个整型数据成员 n1 和 n2 应声明为私有。编写构造方法赋予 n1 和 n2 初始值再为该类定义加 addition、减 subtraction、乘 multiplication、除 division 等公有成员方法分别对两个成员变量执行加、减、乘、除的运算。 在 main 方法中创建 Number 类的对象调用各个方法并显示计算结果。

  • 2.定义一个网络用户类 User,要存储私有的信息有用户 id、用户密码 password、email 地址。在建立类的实例时把以上三个信息都作为构造函数的参数输入其中。用户 id 和用户密码是必须的,缺省 email 地址时用户 email 使用用户 id 加上字符串 @gameschool.com。

  • 3.创建一个圆 Circle 类, 为该类提供一个变量 r 表示半径,一个常量 PI 表示圆周率; 同时为该类提供两个方法:方法一用于求圆的面积,方法二用于求圆的周长; 为该类提供一个有参的构造方法,用于初始化 r 的值。 在 main 方法中测试。

  • 4.编写一个类 Triangle 并为该类创建一个三个整数参数的构造方法,在构造方法中判断是否能构成三角形,如果能构成三角形就提供两个方法计算该三角形的周长和面积。

  • 海伦公式: 公式描述:在这里插入图片描述
    公式中 a,b,c 分别为三角形三边长,p 为半周长,S 为三角形的面积。

参考代码:

题1

class Number {
    private int n1;
    private int n2;

    public Number(int n1, int n2) {
        this.n1 = n1;
        this.n2 = n2;
    }

    public int addition() {
        return n1 + n2;
    }

    public int subtraction() {
        return n1 - n2;
    }

    public int multiplication() {
        return n1 * n2;
    }

    public int division() {
        return n1 / n2;
    }

    public static void main(String[] args) {
        Number number = new Number(3, 6);
        System.out.println(number.addition());
        System.out.println(number.subtraction());
        System.out.println(number.multiplication());
        System.out.println(number.division());
    }
}

题2:

class User {
    private int id;
    private String password;
    private String email;

    public User(int id, String password) {
        this.id = id;
        this.password = password;
        this.email = id + "@gameschool.com";
    }

    public User(int id, String password, String email) {
        this.id = id;
        this.password = password;
        this.email = email;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", password='" + password + '\'' +
                ", email='" + email + '\'' +
                '}';
    }

    public static void main(String[] args) {
        User user1 = new User(1, "123");
        User user2 = new User(1, "123", "123@qq.com");
        System.out.println(user1);
        System.out.println(user2);
    }
}

题3:

class Circle {
    private double r;
    private static final double PI = 3.14159;

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

    public double perimeter() {
        return 2 * PI * r;
    }

    public double area() {
        return PI * r * r;
    }

    public static void main(String[] args) {
        Circle circle = new Circle(5);
        System.out.println(circle.area());
        System.out.println(circle.perimeter());
    }
}

题4:

class Triangle {
    private int a;
    private int b;
    private int c;

    public Triangle(int a, int b, int c) {
        if (a + b < c || a + c < b || c + b < a) {
            System.out.println("不能构成三角形");
            return;
        }
        this.a = a;
        this.b = b;
        this.c = c;
    }

    public double perimeter() {
        return a + b + c;
    }

    public double area() {
        double p = perimeter()/2;
        return Math.pow(p * (p - a) * (p - b) * (p - c), 0.5);
    }

}
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

faramita_of_mine

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值