Java（九）

知识点1：JavaBean的概念

package com.atguigu.java;

/**
 *
 * 所谓javaBean，是指符合如下标准的Java类：
 * 类是公共的
 * 有一个无参的公共的构造器
 * 有属性，且有对应的get、set方法
 */
public class User {

    private int id;
    private String name;

    public User(){

    }

    public User(int i,String n){
        id = i;
        name = n;
    }

    public void setId(int i){
        id = i;
    }
    public void setName(String n){
        name = n;
    }
    public int getId(){
        return id;
    }
    public String getName(){
        return name;
    }

}

知识点2：UML的类图

知识点3：this关键字的使用

1. this调用属性、方法

/*this调用属性、方法
 *    2.1 我们在类的方法或类的构造器中，可以调用当前类中声明的属性或方法。其实，此属性或方法前可以添加
 *    "this."，表示当前属性或方法的调用者，即当前对象或当前正在创建的对象。但是我们通常情况下都省略了此"this."
 *    2.2 在特殊情况下，此"this."不能省略：
 *     当方法中或构造器中定义的局部变量（包含：形参）与当前类的属性同名时，为了区分二者。在表示属性时，必须显式
 *     的加上"this.",表明调用的是当前类的属性，而非局部变量。
 */

2. this调用构造器

/*
this调用构造器
 *   ① 我们可以在类的构造器中显式的声明"this(形参列表)"的方式，表示调用本类中的其他构造器。
 *   ② "this(形参列表)" 必须声明在类的构造器的首行！
 *   ③ 在一个类的构造器中，最多只能声明一个"this(形参列表)"的结构。
 *   ④ 如果一个类中声明了n个构造器，则最多有 n - 1 个构造器中可以使用"this(形参列表)"的结构。
 */

• 代码演示

public class PersonTest {
    public static void main(String[] args) {
        Person p1 = new Person();
        p1.setAge(1);
        p1.setName("Tom");

        p1.info();
        p1.eat();

        Person p2 = new Person();
        p2.eat();

        Person p3 = new Person("Tom",12);
    }
}

class Person{
    private String name;
    private int age;

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

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

    public Person(){
        //声明创建对象过程中，必须要执行的操作
        //...
        //...
        this.age = 18;
    }

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

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

    public void eat(){
        System.out.println("人吃饭");

        this.sleep();
    }
    public void sleep(){
        System.out.println("人睡觉");
    }

    public void info(){
        System.out.println("name = " + name + ", age = " + age);
    }
}

• 课后练习

package com.atguigu.exer;

/**
 */
public class BoyGirlTest {
    public static void main(String[] args) {
        Boy boy = new Boy("罗密欧",23);

        Girl girl = new Girl("朱丽叶",22);

        girl.marry(boy);

        boy.shout();

        Girl girl1 = new Girl("祝英台",18);
        int compare = girl.compare(girl1);
        System.out.println(compare);//1
    }

}

class Boy{
    private String name;
    private int age;

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

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

    public Boy(String name) {
        this.name = name;
    }

    public Boy() {
    }

    public void marry(Girl girl){
        System.out.println("我想娶" + girl.getName());
    }

    public void shout(){
        if(this.age >= 22){
            System.out.println("到了法定结婚的年龄");
        }else{
            System.out.println("只能先谈谈女朋友");
        }
    }
}

class Girl{
    private String name;
    private int age;

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

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

    public Girl() {
    }

    public void marry(Boy boy){
        System.out.println("我想嫁给" + boy.getName());

        boy.marry(this);
    }

    /**
     * 比较两个对象的年龄的大小。
     * @param girl
     * @return  如果当前对象的年龄大，则返回正数；如果当前对象的年龄小，则返回负数。如果二者年龄相同，则返回0
     */
    public int compare(Girl girl){
        if(this.age > girl.age){
            return 1;
        }else if(this.age < girl.age){
            return -1;
        }else{
            return 0;
        }
    }
}

知识点4：package 和 import关键字的使用

1. package关键字的使用

 /* 一、package : 包
 *  1. 我们编写的java类，通常都放在不同的包下。即：指名类所在的包。目的：便于管理。
 *  2. 使用package声明一个包，放在java源文件的开头。
 *  3. 包名，属于标识符的一种。在定义时需要满足标识符的命名规则、规范、“见名知意”
 *  4. 每"."一次，就代表一层文件目录。
 *  5. 同一个包内，不允许声明相同名的结构：类、接口。
 *     不同的包下，可以声明相同名的结构：类、接口
 */

2. import关键字的使用

/*二、import:导入
 *  1. 我们可以在package包声明和java类的定义之间，声明导入的结构
 *  2. 我们可以在当前类中，使用其他包下的结构（类、接口），此时需要使用import结构。
 *  3. 如果使用的是当前包下的结构（类、接口），则可以省略import的声明
 *  4. 如果使用的是其他包下的结构（类、接口），则必须显式的声明import结构。
 *     特例：如果导入的是java.lang下的结构，则此时可以省略import java.lang.下的结构。
 *  5. 如果需要导入多个结构，则并列声明即可。
 *  6. 我们可以使用java.util.*的方式，表示可以导入java.util包下的所有结构（类、接口）。
 *  7. 如果已经导入了a.*结构了，此时如果要使用a包的子包下的结构，则仍然需要导入a的子包。
 *  8. 如果类中使用了不同包下同名的类，则至少有一个需要使用全类名的方式表示。
 */

import java.lang.reflect.Field;
import java.lang.reflect.Proxy;
import java.util.ArrayList;

import java.util.HashMap;
import java.util.LinkedList;

import java.util.Date;
public class PackageImportTest {
    public static void main(String[] args) {

        Person p1 = new Person();

        String s = "hello";
        System.out.println(s);

        HashMap map = null;

        ArrayList list = null;

        LinkedList list2 = null;

        Field f = null;
        Proxy p = null;

        Date date = null; //java.util
        java.sql.Date date1 = null;//java.sql

    }
}

知识点5：面向对象的特征之二：继承性

• 为什么要有类的继承性？

/**
 *
 *  3W ： why ? what ?  how ?
 *
 *  class Account{
 *      double balance;//余额
 *
 *      //存钱
 *      public void deposit(double amt){}
 *      //取钱
 *      public void withdraw(double amt){
 *          if(amt > 0 && amt <= balance)
 *              balance -= amt;
 *      }
 *  }
 *
 *  class SavingAccount extends Account{//储蓄卡
 *
 *
 *  }
 *  class CheckAccount extends Account{//信用卡
 *      double protectedBalance;//可透支额度
 *
 *      //重写：取钱
 *      public void withdraw(double amt){
 *         if(amt <= getBalance()){
 *             balance -= amt;
 *         }else if(protectedBalance >= amt - balance){
 *             protectedBalance -= (amt - balance);
 *             balance = 0;
 *         }else{
 *             sout("取款失败");
 *         }
 *      }
 *  }
 *
 *
 *
 *
 * 一、继承性的好处
 * >继承的出现减少了代码冗余，提高了代码的复用性。
 * >继承的出现，更有利于功能的扩展。
 * >继承的出现让类与类之间产生了关系，提供了多态的前提。
 *
 * 注意：不要仅为了获取其他类中某个功能而去继承
 */

• 具体使用

/*二、继承性的格式：
 *   class A extends B {}
 *   其中:
 *   A：子类、SubClass
 *   B: 父类、SuperClass、超类、基类
 *
 *  说明：子类在继承父类之后，就获取到了父类中声明的属性和方法。
 *       ==>但是，可能由于封装性的影响，导致子类中不能直接使用父类中声明的属性、方法。
 *       此外，子类还可以根据自己的需要，额外定义自己特有的属性和方法。
 *       ==>子类的功能比父类的功能要强大！
 *
 *  三、说明：
 *   1. 一个父类可以声明多个子类。
 *   2. 反之，一个子类只能有一个父类。--->Java类的单继承性
 *   3. Java 支持多层继承。相关概念：子类、直接父类、间接父类
 *   4. 子类、父类的概念是相对的。
 *   5. 当一个类没有显式的声明父类时，则其默认的父类为：java.lang.Object类
 *   6. 任何一个java类（除了Object类），都直接或间接的继承于java.lang.Object类
 */

• 代码演示

/**
 */
public class Creature {//生物
    boolean gender;

    public void breath(){
        System.out.println("呼吸");
    }
}

package com.atguigu.java1;

/**
 */
public class Person extends Creature{
    String name;
    private int age;

    int id = 1001;//身份证号

    public Person() {
    }

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

    public void eat(){
        System.out.println("人吃饭");
    }
    public int sleep(){
        System.out.println("人睡觉");
        return 8;
    }

    public int getAge() {
        return age;
    }

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

    private void swim(){
        System.out.println("人游泳");
    }

    public Object play(){

        return null;
    }
}

package com.atguigu.java1;

/**
 */
public class Student extends Person{
    String major;//专业

    int id = 1002;//学号

    public void study(){
        System.out.println("学生学习");
    }


    @Override
    public void eat() {
        System.out.println("学生应该多吃没有防腐剂等食物");
    }


//    public int swim(){
//        System.out.println("人游泳");
//        return 1;
//    }

    public int sleep(){
        System.out.println("学生睡觉");
        return 9;
    }

    public String play(){

        return null;
    }
}

public class ExtendsTest {
    public static void main(String[] args) {
        Person p1 = new Person("Tom",12);
//        p1.age = 13;
        p1.eat();

        Student s1 = new Student();
        s1.name = "Jerry";
//        s1.age = 12;
        s1.setAge(12);
        System.out.println("学生年龄为：" + s1.getAge());

        s1.eat();
        s1.sleep();
        //##########学生调用自己特有的结构#############
        s1.major = "计算机科学与技术";
        s1.study();

        //##########学生调用Creature中的结构#############
        s1.gender = true;
        s1.breath();

        //##########Creature对象的功能调用#############
        Creature c = new Creature();
        c.gender = false;
        c.breath();
        System.out.println(c.toString());
        System.out.println(c.getClass().getSuperclass());

    }
}

知识点6：方法的重写(override)

/**
 *
 * 回顾：方法的重载。“两同一不同”
 *
 * 测试方法的重写（override / overwrite）
 * 1. 方法重写的前提：有类的继承关系
 * 2. 在子类继承父类以后，子类可以对父类中同名同参数的方法进行覆盖操作。此覆盖操作，就称为方法的重写。
 *  -->当创建子类对象以后，通过子类对象调用重写的父类的方法时，执行的就是子类重写父类的方法。
 *
 * 3. 方法重写的细节要求：  子类重写的方法  vs 父类被重写的方法
 *      权限修饰符  返回值类型  方法名（形参列表）{}
 *
 *    >子类重写的方法 与 父类被重写的方法的 方法名、形参列表相同
 *    >子类重写的方法的权限修饰符 不小于 父类被重写的方法的权限修饰符
 *         (注意：子类不能重写父类中声明为private权限的方法）
 *    > 父类被重写的方法返回值类型为void时：子类重写的方法也必须是void的
 *    > 父类被重写的方法返回值类型为基本数据类型时，子类重写的方法的返回值类型必须与父类的类型相同。
 *    > 父类被重写的方法返回值类型为引用数据类型时，子类重写的方法的返回值类型可以与父类此方法的返回值类型的相同，
 *                                              或是父类此方法返回值类型的子类。
 *
 *    > 子类重写的方法声明的异常类型不大于父类被重写的方法声明的异常类型。（异常处理时讲）
 *
 * 4. 属性、构造器不存在重写的概念
 *
 * 【面试题】 方法的重载和重写有什么区别？
 */
public class OverrideTest {
    public static void main(String[] args) {
        Student s1 = new Student();

        s1.eat();
        s1.sleep();
    }
}