JAVA萌新学习day10

JAVA萌新学习day10

一.private

package com.qf.java1904.day10;

public class Person {
    //成员变量需要声明成私有的,需要使用关键字 private 修饰.
    //成员变量私有化后,只能通过方法来访问,所以我们提供一对方法.
    //我们叫设置和获取方法,即 setter getter ,只能通过方法来操作成员变量.
    //因为方法内部可以对参数值或变量值进行安全性检查,达到了私有化的目的.
    //一般情况下方法是公开的.
    //姓名
    private String name ;

    //年龄
    private int age;

    //一般情况下,保证一定有一个无参的构造方法
    public Person() {
        //name = "";
        //可以通过 this 关键字调用构造方法
        this("" , 10);
    }

    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) {
        if (age > 0 && age < 150) {
            this.age = age;
        } else {
            System.out.println("输入的年龄不合法");
        }
    }

    public int getAge() {
        return age;

    }
}

二. 继承 extends

MainMethod

public class MainMethod {
    public static void main(String[] args) {

        System.out.println("MainMethod.main");

        //分别创建三个形状对象,设置边长,计算他们的面积和周长.
        Circle circle = new Circle();
        //circle.setType("圆");
        circle.setNewType("椭圆");
        circle.setLength(5);
        double perimeter = circle.perimeter();
        double area = circle.area();

        System.out.println("类型:" + circle.getType());

        System.out.println("边长为" + 5 + "的圆形的周长是:" + perimeter + " " + "面积是:" + area);

        Rectangle rectangle = new Rectangle();
        rectangle.setLength(5);
        perimeter = rectangle.perimeter();
        area = rectangle.area();

        System.out.println("边长为" + 5 + "的正方形的周长是:" + perimeter + " " + "面积是:" + area);

        RegularTrangle regularTrangle = new RegularTrangle();
        regularTrangle.setLength(5);
        perimeter = regularTrangle.perimeter();
        area = regularTrangle.area();

        System.out.println("边长为" + 5 + "的等边三角形的周长是:" + perimeter + " " + "面积是:" + area);


        Circle[] circleArray;
        Rectangle[] rectArray;
        RegularTrangle[] regularArray;

        Shape shape;

        shape = new Shape();

        Shape shape1 = circle;

        shape1 = rectangle;

        Shape[] shapeArray = new Shape[3];

        shapeArray[0] = circle;
        shapeArray[1] = rectangle;
        shapeArray[2] = regularTrangle;

        //Person person = (person)cirle;

        for(int i = 0; i < shapeArray.length; i++){
            Shape tempShape = shapeArray[i];

            //instanceof 用来检查tempShape这个变量(对象)实际指向的内存中的对象类型.
            //tempShape指向的对象是否是Circle类的实例.
            if(tempShape instanceof Circle){
                Circle c1 = (Circle)tempShape;
                c1.setNewType("");
            }

            tempShape.area();
        }

    }

    //public static void add(Circle shape){
    //public static void add(Rectangle shape){
    public static void add(Shape shape){

        shape.area();
    }

}

Shape

//创建一个形状类

/*
1.通过继承(extends),子类会拥有父类的非私有成员变量和方法.
2.父类中定义所有子类共有的成员变量和方法,如果某个方法父类无法实现,就需要子类重写这个方法.
3.方法的重写:子类声明一个从父类继承的同名方法,重新实现方法体.
4.构造方法不能继承.
5.子类重写父类的方法后,如果使用对象,调用方法的时候,实际是调用子类的重写方法.
*/

public class Shape {
    //我们形状类支持 三种形状,圆形,正方形,正三角形
    //如果对象是圆形,它代表半径,如果对象是正方形正三角形,它代表边长
    protected int boderLength;

    String type;

    public Shape(){
        type = "形状";
        System.out.println("Shape.Shape" + type);
    }

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    //计算周长
    public double perimeter(){
        //因为不知道什么形状,所以无法根据公式算出周长.
        return 0.0;
    }

    //计算面积
    public double area(){
        //因为不知道什么形状,所以无法根据公式算出面积.
        return 0.0;
    }

    //设置边长
    public void setLength(int length){
        this.boderLength = length;
    }

}

Circle

//圆形 继承于 形状类 关键字 代表继承 extends, java中一个类只能有一个直接父类,叫单继承.
public class Circle extends Shape{

    String type;

    //使用super关键字调用父类的构造方法
    public Circle(){
        super();
    }

    //计算周长
    public double perimeter(){
        //3.14乘以直径
        return 2*boderLength*3.14;
    }

    //计算面积
    public double area(){
        //使用super关键字调用父类的方法
        super.area();

        return boderLength*boderLength*3.14;
    }

    //测试方法
    public void setNewType(String newType){
        System.out.println("before" + super.type);
        this.type = newType;
        System.out.println("after" + super.type);
    }

}

Rectangle

//正方形
public class Rectangle extends Shape{

    public double perimeter(){
        return boderLength*4.0;
    }

    public double area(){
        return boderLength*boderLength*1.0;
    }
}

RegularTrangle

//正三角形
public class RegularTrangle extends Shape{

    public double perimeter(){
        return 3.0*boderLength;
    }

    public double area(){
        //海伦公式
        double s = 3*boderLength/2;

        double area = Math.sqrt(s * (s - boderLength) * (s - boderLength) *(s - boderLength) );

        return area;
    }
}

一.