Java基础day11---------面向对象中 --- 继承

1.练习

构造器练习

快捷使用获得 构造器与空构造及getset方法

package com.atguigu.exer;

/*
创建装载图书数据的JavaBean类Book。
	属性包括书名（name），作者(author)，价格(price)，介绍（summary）。
	private修饰属性 给每个属性提供public的get/set方法
	要求：书名，作者，简介不能为null。单价必须在20~50之间

快捷键 ： alt + insert (生成属性的get和set方法)
 */
class Book{
    private String name; //默认值是null
    private String author;//默认值是null
    private double price;//默认值是0.0
    private String summary;//默认值是null

    public Book() {
    }

    public Book(String name, String author) {
        this.name = name;
        this.author = author;
    }

    public Book(String name, String author, double price, String summary) {
        this.name = name;
        this.author = author;
        this.price = price;
        this.summary = summary;
    }

    //实例方法--只能通过对象调用
    public void setName(String name){//给name属性赋值---可以在方法中加以限制（检查数据的安全）
        if (name == null){
            System.out.println("兄die 你害我 没门");
            //给一个初始值--也可以让程序挂掉
            this.name = "《如何让富婆爱上我》";
        }else {
            this.name = name;//谁（对象）调用该方法那么this就是谁（对象）
        }

    }

    public String getName(){//获取name属性的值
        //return name;
        return this.name; //和return name一样。因为该方法中没有局部变量叫name
    }

    public void setAuthor(String author){//给author属性赋值
        if (author == null){
            System.out.println("兄die 你害我 没门");
            //给一个初始值--也可以让程序挂掉
            this.author = "小龙哥";//给属性赋初始值
        }else {
            //this.author - 属性
            // author : 局部变量
            this.author = author;
        }
    }

    public String getAuthor(){//获取author属性的值
        return this.author;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        if (price < 20 || price > 50){
            System.out.println("书价不合理");
            this.price = 20;
        }
        this.price = price;
    }

    public String getSummary() {
        return summary;
    }

    /*
        兄die 不能用null
     */
    public void setSummary(String summary) {
        if (summary == null){
            System.out.println("兄die 你害我 没门");
            //给一个初始值--也可以让程序挂掉
            this.summary = "";
        }else {
            this.summary = summary;
        }
    }
}
public class BookeTest {
    public static void main(String[] args) {
        Book b1 = new Book();
        Book b2 = new Book();

        b1.setName("aaa");
        System.out.println(b1.getName());


    }
}

package com.atguigu.exer2;

/*
（1）定义三角形类Triangle，

- 声明实例变量a,b,c，代表三角形三条边，全部私有化private，
- 提供每条边的get方法，
- 提供public void setBases(double a, double b, double c)：
要求参数a,b,c的值必须大于等于0，且满足三角形三边关系要求（即任意两边之后大于第三边），否则提示错误信息
- 声明public double area()，返回三角形面积
- 声明public double perimeter()：返回三角形周长
- 声明public String getInfo()：返回三角形的三条边，面积和周长

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

    //构造器
    public Triangle(int a, int b, int c){//没有空参构造器 该构造器必须调用
        if (a > 0 && b > 0 && c > 0 && a + b > c && b + c > a && a + c > b){
            this.a = a;
            this.b = b;
            this.c = c;
        }else{
            System.out.println("三条边的长度不合法......");
        }
    }
    /*
    要求参数a,b,c的值必须大于等于0，且满足三角形三边关系要求（即任意两边之后大于第三边），否则提示错误信息
     */
    public void setBases(int a, int b, int c){
        if (a > 0 && b > 0 && c > 0 && a + b > c && b + c > a && a + c > b){
            this.a = a;
            this.b = b;
            this.c = c;
        }else{
            System.out.println("三条边的长度不合法......");
        }
    }

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

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

    public String getInfo(){
        return a + " " + b + " " + c + " " + area() + " " + perimeter();
    }

    public int getA() {
        return a;
    }

    public void setA(int a) {
        this.a = a;
    }

    public int getB() {
        return b;
    }

    public void setB(int b) {
        this.b = b;
    }

    public int getC() {
        return c;
    }

    public void setC(int c) {
        this.c = c;
    }
}
public class Demo1 {
}

package com.atguigu.exer2;

/*
(1)定义Student类,有4个属性：
    String name;
    int age;
    String school;
    String major;
(2)定义Student类的3个构造器:
第一个构造器Student(String n, int a)设置类的name和age属性；
第二个构造器Student(String n, int a, String s)设置类的name, age 和school属性；
第三个构造器Student(String n, int a, String s, String m)设置类的name, age ,school和major属性；
(3)在main方法中分别调用不同的构造器创建的对象，并输出其属性值。

 */
class Student{
    String name;
    int age;
    String school;
    String major;

    public Student(String n,int a){
        name = n;
        age = a;
    }

    public Student(String n,int a,String s){
        this(n,a);//调用本类中的其它构造器
        school = s;
    }

    public Student(String n,int a,String s,String m){
        this(n,a,s);//调用本类中的其它构造器
        major = m;
    }
}
public class Demo2 {
}

package com.atguigu.exer2;

class Account{
    private int id;
    private double balance;
    private double annualInterestRate;

    public Account (int id, double balance, double annualInterestRate ){
        this.id = id;
        this.balance = balance;
        this.annualInterestRate = annualInterestRate;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public double getBalance() {
        return balance;
    }

    public void setBalance(double balance) {
        this.balance = balance;
    }

    public double getAnnualInterestRate() {
        return annualInterestRate;
    }

    public void setAnnualInterestRate(double annualInterestRate) {
        this.annualInterestRate = annualInterestRate;
    }

    //取钱-在提款方法withdraw中，需要判断用户余额是否能够满足提款数额的要求，如果不能，应给出提示。
    public void withdraw (double amount){
        if (balance >= amount){//可以取
            balance -= amount;// balance = balance - amount;
            System.out.println("取款成功:" + amount);
        }else{//不可以取
            System.out.println("余额不足，取款失败");
        }
    }
    //存钱
    public void deposit (double amount){
        if (amount > 0){//校验
            balance += amount;
            System.out.println("存款成功:" + amount);
        }else{
            System.out.println("存款金额不合理......");
        }
    }

}

class Customer{
    private String firstName;
    private String lastName;
    private Account account;

    public Customer(String firstName, String lastName) {
        this.firstName = firstName;
        this.lastName = lastName;
    }

    public String getFirstName() {
        return firstName;
    }

    public String getLastName() {
        return lastName;
    }

    public Account getAccount() {
        return account;
    }

    public void setAccount(Account account) {
        this.account = account;
    }
}


public class Demo3 {
    public static void main(String[] args) {
        /*
        3.写一个测试程序。
        （1）	创建一个Customer ，名字叫 Jane Smith,
            他有一个账号为1000，余额为2000元，年利率为 1.23％ 的账户。
        （2）	对Jane Smith操作。
            存入 100 元，再取出960元。再取出2000元。
            打印出Jane Smith 的基本信息

         */
        Customer c = new Customer("Jane", "Smith"); //快捷键 : ctrl + x (删除一行)
        Account a = new Account(1000,2000,1.23);
        //对象的关联
        c.setAccount(a);

        //操作Jane Smith账户
        //存入 100 元
        c.getAccount().deposit(100);
        //取出960元
        c.getAccount().withdraw(960);
        //取出2000元
        c.getAccount().withdraw(2000);

        //输出用户的信息
        System.out.println("Customer [" + c.getFirstName() + ", " + c.getLastName() +"] has a account: " +
                "id is " + c.getAccount().getId() +", annualInterestRate is " + c.getAccount().getAnnualInterestRate() + "％," +
                " balance is " + c.getAccount().getBalance());
    }
}

2.导包（使用其他的包中的类）

包的作用

package com.atguigu.java2;

/*
    package的作用：
        1.为了避免类的重名。不同包中的类名可以重复。
        2.可以控制类及类的成员的可见范围。
        3.可以对类进行分类管理-方便维护

    说明：
        1.package必须放在源文件的首行。
        2.一个源文件中只能有一个package。
        3.package的命名规范：全部小写，每个单词之间用"."隔开
        4.package的名字一般是公司域名倒序 + 项目名称
            com.atguigu.java
        5.起包名时不要以java.开头。
 */
public class PackageTest {
}

导包

package com.atguigu.java2;

import com.atguigu.java.Dog;
import com.atguigu.java.Person;
import java.util.Scanner;
import static java.lang.System.out;
/*
    通过import导包（因为我们要告诉编译器我们用的类在哪里）
    1.位置：在package和类的中间声明
    2.当我们使用其它包中的类时（不是本包的）那么就需要使用import导包
    3.可以有多个import(需要哪个类就导那个类所在的包即可)
    4.如果我们要使用同一个包中的多个类那么只需要在导包时用*替代类名即可（import com.atguigu.java.*）
    5.如果使用的是本包中的类和java.lang包中的类那么不需要import。
    6.使用不同包中相同类名的多个类那么需要使用类的全类名进行区分（必须会）
    7.静态导入：可以导入类变量(知道就可)
 */
public class ImportTest {
    public static void main(String[] args) {

        //使用com.atguigu.java包中的Dog类
        new Dog();
        //使用com.atguigu.java包中的Person类
        new Person();

        new Scanner(System.in);

        new JavaBean();

        Math.random();
        //=====================================================

        //全类名 ：包含包名在内的类的全名称（包名.类名）。
        //使用不同包中相同类名的多个类那么需要使用类的全类名进行区分
        Dog dog = new Dog();
        com.atguigu.java3.Dog d = new com.atguigu.java3.Dog(1,"a");//全类名

        //============================================================
        out.println("aaa");
        out.print("cccc");
    }
}

3.javaBean 的概念及意义

package com.atguigu.java2;

/*
    JavaBean的作用 ：用来存储数据。一条数据就是一个JavaBean对象。
    1.JavaBean就是一个类
    2.JavaBean的类必须是public所修饰
    3.JavaBean的类中必须有空参构造器-构造器也用public修饰
    4.JavaBean中的属性是private修饰
    5.JavaBean中要给属性提供set/get方法。
 */
public class JavaBean {
    private int id;
    private String info;

    public JavaBean(){

    }
    public JavaBean(int id){ //可选

    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getInfo() {
        return info;
    }

    public void setInfo(String info) {
        this.info = info;
    }

    //其它方法 -（可选）
}

4.继承

继承的介绍及说明

package com.atguigu.java4;

/*
    面向对象三大特性之：继承性

    继承的好处：
        1.减少代码的冗余
        2.提高代码的复用性
        3.继承是多态的前提

    什么时候可以使用继承？
        当类与类之间存在大量相同的内容时。需要满足子类是父类中的一种（is a的关系）。
        就可以将子类中重复的内容抽取到父类-这时子类就可以继承父类。

    继承的格式 ：[修饰符]  class 类名A extends 类名B
        A类叫作子类-subClass
        B类叫作父类-SuperClass

     说明：
        1.当子类继承父类后就拥有了父类中的实例变量和实例方法。
        2.子类继承父类后也可以增加自己（子类）的属性和方法--子类比父类更强大
        3.子类继承父类后父类中的属性和方法被private修饰，
            子类就不能直接调用但我们还是认为子类继承了父类中私有的属性和方法（可以间接调用）。
        4.java是单继承。一个子类只可以有一个父类。但是一个父类可以有多个子类。
        5.子类除了可以继承直接父类中的实例变量和实例方法外还可以继承间接父类中的。
        6.如果一个类没有显示继承其它类那么默认继承Object类。Object类是所有类的父类。
        7.子类和父类一定要存在“is a”的关系（不要为了继承而继承）。

     快捷键 ：
        查看继承关系 ：ctrl +alt + u (图)
                    ctrl + H （继承树-家谱）
 */

class Animal{
    int aid;
    public void animalShow(){
        System.out.println("animal show");
    }
}
//父类
class Person extends Animal{
    //属性-实例变量
    int id;
    String name;

    private int age;//被子类继承了没有？- 继承了（因为可以通过调用方法的方式获取父类的私有属性）
    static int pid;//类变量
    public static void staticSay(){//类方法
        System.out.println("static say");
    }

    //非静态方法-实例方法
    public void show(){
        System.out.println("Person show");
        System.out.println("id=" + id + " name=" + name + " age=" + age);
    }
}


//子类 - 在子类中继承了父类
class Student extends Person{
    int sid;//子类继承父类后也可以增加自己（子类）的属性和方法--子类比父类更强大
    public void subShow(){
        System.out.println(sid + " subShow");
    }
}

class Employee extends Person{

}

//如果一个类没有显示继承其它类那么默认继承Object类。Object类是所有类的父类。
class A{}
public class ExtendesTest {

    public static void main(String[] args) {
        Student s = new Student();
        s.id = 1;
        s.name = "龙哥";
        s.show();
        s.sid = 1000;
        s.subShow();

        System.out.println("================================");

        System.out.println(s.pid);
        s.staticSay();

        System.out.println("================================");
        //调用间接父类中的属性和方法
        System.out.println(s.aid);
        s.animalShow();

        System.out.println("===============================");
        A a = new A();
        a.toString();
    }
}

方法的重写

package com.atguigu.java4;

/*
    方法的重写 ：当子类继承父类后如果子类对父类中的方法不满意（无法满足子类需求）可以考虑方法的重写
        当子类重写父类的方法后再通过子类的对象调用此方法调用的是子类重写的方法。

    如何方法重写？ 可以直接将父类中要被重写的方法复制到子类中即可

    ============================================================
    在方法的重写时要注意的细节
        1.父类被重写的方法和子类重写的方法，方法名和形参列表必须一致。
        2.父类被重写的方法的返回值和子类重写方法的返回值
            被重写的方法      重写方法
                void        void
              基本数据类型    对应的基本数据类型
              ---------------------------------
              引用数据类型     要小于等于父类被重写方法的返回值类型（A3 继承 A2 继承 A1）
                  A2                A2和A3
              ---------------------------------
        3.子类重写方法的权限修饰符>=父类被重写方法的权限修饰符
            权限修饰符 : private -> 缺省的 -> protected -> public
    ================================================================
    注意：
        1.私有方法不能被子类重写
        2.final修饰的方法不能被子类重写
        3.类方法不能被重写
        4.如果是跨包的子类 父类中缺省的方法也不能被子类重写因为权限-子类看不到
 */
class A1{

}
class A2 extends A1{

}
class A3 extends A2{

}

class Graphical{//图形

    //被重写的方法
    public double findArea(){//图形的面积无法计算
        System.out.println("图形的findArea方法");
        return 0;
    }

    // A3 继承 A2 继承 A1
    public A2 print(){
        return null;
    }

    //权限修饰符 : private -> 缺省的 -> protected -> public
    protected void run(){

    }

    //私有方法不能被子类重写
    private void demo(){

    }

    //final修饰的方法不能被子类重写
    public final void demo2(){

    }

    //类方法不能被重写
    public static void demo3(){

    }
}
class Circle extends Graphical{
    double radius;

    @Override
    protected void run() {

    }

    //方法的重写
    @Override
    public A3 print(){
        return null;
    }

    //重写的方法
    @Override //该注解用来说明该方法是重写的方法 如果不是直接报错
    public double findArea(){//图形的面积无法计算
        System.out.println("圆的findArea方法");
        return Math.PI * radius * radius;
    }
}

public class OverwrideTest {
    public static void main(String[] args) {
        Circle c = new Circle();
        c.findArea();//求圆的面积
    }
}