刷题DAY7

三角形面积

题目：已知三角形的边长a，b和从、，求其面积

输入：输入三个实数a，b，c，表示三边长

输出：输出面积，保留三位小数

输入：1

2

2.5

输出：0.950

import java.util.Scanner;
public class 求三角形面积 {
    public static void main(String[] args) {
        System.out.println("请输入你的第一数");
        double z =new Scanner(System.in).nextDouble();
        double sideA = z;
        System.out.println("请输入你的第二数");
        double y=new Scanner(System.in).nextDouble();
        double sideB = y;
        System.out.println("请输入你的第三数");
        double h =new Scanner(System.in).nextDouble();
        double sideC = h;
​
        double area = getTriangleArea(sideA, sideB, sideC);
        System.out.println("三角形面积：" + String.format("%.3f", area));
    }
​
    public static double getTriangleArea(double a, double b, double c) {
        double s = (a + b + c) / 2;
        return Math.sqrt(s * (s - a) * (s - b) * (s - c));
    }
}
​

知识点

1.String.format

用于创建格式化的字符串以及连接多个字符串对象

// 使用当前本地区域对象（Locale.getDefault()），制定字符串格式和参数生成格式化的字符串 String String.format(String fmt, Object... args);

// 自定义本地区域对象，制定字符串格式和参数生成格式化的字符串 String String.format(Locale locale, String fmt, Object... args);

2.getTriangleArea

这是计算三角形面积的公式

3.重载(overload)

有相同的方法名称，但形参不同的方法

目的就是为了会更加方便程序的可用性

满足条件：

1. 参数列表必须改变

2. 返回类型可以改变

3. 实现过程可以改变

4. 异常声明可以改变

5. 访问限制可以改变

总的来说外壳必须改变，内核可以改变

public class Overload {
    public static void print(Integer a) {
        // 当传入参数的类型为Integer时，JVM会调用这个方法
        System.out.println("传入参数为Integer类型");
    }
 
    public static void print(String s) {
        // 当传入参数的类型为String时，JVM会调用这个方法
        System.out.println("传入参数为String类型");
    }
 
    public static void main(String[] args) {
        Overload.print(1); // Output：传入参数为Integer类型
        Overload.print("1"); // Output：传入参数为String类型
    }
}

4.重写(override)

是指子类重新实现父类中已有的方法，此方法可使用 @Override 注解来标记（非强制）。

子类的方法必须与父类被重写的方法具有相同的名称、返回类型和参数列表。

重写不代表子类再也无法调用父类中被重写的方法，子类仍可以通过super关键字进行调用

满足条件：

1. 参数列表不能改变

2. 返回类型可以被为重写方法的派生类

3. 实现过程可以改变

4. 异常声明不能比父类更加广泛

5. 访问限制不能比符类更加严格

6. final修饰的方法不可重写

7. static修饰的方法不可重写，但能重新声明

8. 构造方法不可重写

9. 父类无法被子类访问1的方法不可重写

总的来说外壳(几乎)不能改变，内核可以改变

class Animal {
    public static void move() { // static 修饰，不可被重写
        System.out.println("动物移动");
    }
 
    public void bark() { // 被重写方法
        System.out.println("动物叫");
    }
}
 
class Dog extends Animal {
    // @Override // 错误的重写，添加注解则编译器报错
    public static void move() { // 重新声明，并非重写
        System.out.println("狗跑");
    }
 
    @Override // 重写注解
    public void bark() { // 重写方法
        System.out.println("狗吠");
    }
}
 
public class Test {
    public static void main(String[] args) {
        Animal animal = new Animal();
        Dog dog = new Dog();
        Animal.move(); // Output：动物移动
        Dog.move(); // Output：狗跑
        animal.bark(); // Output: 动物叫
        dog.bark(); // Output: 狗吠
    }
}

5.继承

是指再原有类的基础上，进行功能的拓展，创建新的类型

本质是对某一批类的抽象，从而实现对现实世界的更好建模

在Java中继承只有单继承没有多继承

继承是类和类之间的一种关系(除此之外，类和类之间的关系有依赖，组合，聚合等)

继承关系的两个类，一个为子类(派生类)，一个为父类(基类)。子类继承父类，使用关键字extends(拓展)来调用

格式：

public class 子类名(Zi) extends 父类名(Fu){}

public class Zi extends Fu{}

子类可以有父类的内容，也可以有自己特有的内容

// 父类
public class Person {
    //public 公共的
    public int money = 1_0000_0000;
    public void say(){
        System.out.println("说话");
    }
 
}

//student is person
//Teacher student也叫派生类或者子类
//子类可以继承父类的所有方法
public class Student extends Person{
 
}

访问特点：先访问子类在子类中寻找，没有再再父类中寻找，没有就报错，不在考虑父类的父类。

super

代表父类存储空间的标识(可以理解为父类对象引用)与this(本类对象的引用(指向该方法的对象 一般我们是在当前类中使用this关键字所以我们常说this代表本类对象的引用))相似

关键字	访问成员变量	访问构造方法	访问成员方法
this	this.成员变量访问本类成员变量	this(...)访问本类构造方法	this.成员方法(...)访问本类成员方法
super	super.成员变量访问父类成员变量	super(...)访问父类构造方法	super,成员方法(...)访问父类成员方法

public class Fu {
    public int age = 10;
 
}

 public class Zi extends Fu {
    public int age = 20;
 
    public void show() {
        int age = 30;
        System.out.println(age); // 30
        // 访问本类中的成员变量age
        System.out.println(this.age);
        // 访问Fu类中的成员变量age
        System.out.println(super.age);
    }
}