Java基础知识（三）

类

访问控制符

/** * 人类 * @author Ken *   * 访问控制符: * public:公共访问权限，设置为该控制符的属性、类和方法等，可以随意被任何其他类所调用 * protected:受保护的访问权限，设置为该访问控制符的属性、类和方法等，可以被同包下类随意访问，可以被子类访问 * default（什么都不写）:包访问权限，设置为该访问控制符的属性、类和方法等，可以被同包下的类随意访问 * private:私有访问权限，只能在当前类中使用 *  * 通常用的最多的：public和private *  * 1、访问控制符权限，只能修饰，外部类（public和default），属性，方法，构造方法，内部类 * 2、局部变量不能用访问修饰符修饰 */public class Person {    /**     * 封装原则 -- 建议     * 1、将所有属性私有化     * 2、再为每一个属性提供一对set/get方法     */    private String name;    private int age;    /**     * 如果一个方法只会在当前类中使用，则通常定义为private     */    public void displayInfo(){        int i = 10;        System.out.println("姓名：" + name);        System.out.println("年龄：" + age);    }    /**     * set/get方法     * 生成set/get方法     * shift + alt + s     */    public void setName(String name){        this.name = name;    }    public String getName(){        return name;    }    public void setAge(int age){        if(age > 0 && age <= 150){            this.age = age;        } else {            System.out.println("你设置的年龄不符合规则");        }    }    public int getAge(){        return age;    }

方法的重写
/**
* 方法的重写 – 睡觉
* 把父类的sleep方法覆盖
* 1、重写方法的访问控制权限要比父类的方法的控制权限大或者相同
* 2、重写方法的返回值类型必须是父类方法的返回值类型的子类或者相同
* 3、重写方法的形参列表必须和父类方法的形参列表一样
* 4、重写方法的抛出的异常范围必须小于或者等于父类方法抛出的异常范围
*
* 大小同小
*/

package com.qf.object;public class ObjectDemo {    public static void main(String[] args) {        Person a = new Person("小明", 10, "女", "北京市西城区皮条胡同", "2005-9-9");        Person a2 = new Person("小明", 10, "女", "北京市西城区皮条胡同", "2005-9-9");        /**         * 从Object中继承过来的方法         *          * getClass();         * equals();         * hashCode();         * toString();         */        a.getClass();        a.equals(null);        a.hashCode();        /**         * toString方法         * 打印一个对象：包名.类名@十六进制的hashCode值         * 打印一个对象，默认会调用这个对象的toString方法         * String类重写toString方法         */        String str = new String("字符串");        String str2 = "字符串";//      System.out.println(str.hashCode() + "  " + str2.hashCode());//      System.out.println(str.equals(str2));        /**         * equals方法         *          * String重写了equals方法         *          * ==和equals区别：==比较的是地址，equals比较的是值 XXXXXX         * ==：1、比较基本类型，int a = 10; int b = 10; a == b，比较的是值         *    2、比较引用类型，比较的是地址（比较两个引用是否指向同一个对象）         * equals: 1、比较引用类型，默认比较的是地址，具体比较什么，根据类的重写来决定         */        System.out.println(a2.equals(a));        System.out.println(a2.hashCode() + "  " + a.hashCode());        /**         * jni           * hashcode - 根据对象所处的内存位置，通过一系列的算法返回一个哈希码（散列码）         * 如果两个引用不是指向同一个对象 - hashcode值一定不相同         */    }}class Person{    String name;    int age;    String sex;    String address;    String birthday;    public Person(String name, int age, String sex, String address, String birthday) {        super();        this.name = name;        this.age = age;        this.sex = sex;        this.address = address;        this.birthday = birthday;    }    /**     * 重写equals方法     */    @Override    public boolean equals(Object obj) {        //第一个比较的对象：this        //第二个比较的对象：obj        //非空性        if(obj == null){            return false;        }        //自反性        if(this == obj){            return true;        }        //验证obj是否为Person类型        if(!(obj instanceof Person)){            return false;        }        Person p1 = this;        Person p2 = (Person)obj;        if(p1.name.equals(p2.name)                 && p1.age == p2.age                 && p1.sex.equals(p2.sex)                && p1.address.equals(p2.address)                && p1.birthday.equals(p2.birthday)){            return true;        }        return false;    }    /**     * 重写hashCode方法     * 1、把用于判断equals方法比较的属性拿过来组合成为一个新的hashCode     */    @Override    public int hashCode() {        return name.hashCode() + age + sex.hashCode() + address.hashCode() + birthday.hashCode();    }    /*     * 重写toString方法     *///  @Override//  public String toString() {//      return "name:" + name + //              " age:" + age + //              " sex:" + sex + //              " address:" + address + //              " birthday:" + birthday;//  }}

==和equals区别：==比较的是地址，equals比较的是值 XXXXXX
==：
1、比较基本类型，int a = 10; int b = 10; a == b，比较的是值
2、比较引用类型，比较的是地址（比较两个引用是否指向同一个对象）
equals:
1、比较引用类型，默认比较的是地址，具体比较什么，根据类的重写来决定

多态

public class Test {    public static void main(String[] args) {        //B b; 表示变量b的编译时类型为B类型        //new B(); 表示变量b所指向的对象类型为B类型，也就是所说的运行时类型        //当一个变量编译时类型和运行时类型不相同时，就发生了所谓的多态        //父类类型 变量名 = new 子类类型(); java的自动向上转型         A a = new B();        a.sleep();//调用的sleep方法是子类中重写的sleep方法，称之为方法的多态        System.out.println(a.getI());//属性没有多态的特性,打印出来的值是20    }}/** * 父类 * @author Ken * */class A{    int i = 10;    public void sleep(){        System.out.println("A类中的sleep方法" + i);    }    public int getI() {        return i;    }    public void setI(int i) {        this.i = i;    }}/** * 继承于A的子类B * @author Ken * */class B extends A{    int i = 20;    @Override    public void sleep(){        System.out.println("B类中的sleep方法" + i);    }    public int getI() {        return i;    }    public void setI(int i) {        this.i = i;    }}

package arrs;public class Client {    public static void main(String[] args) {        /*         * 多态-父类类型的变量不能够调用子类中的拓展的属性和方法         */        A p = new C();//      a.m();//      System.out.println(a.i);        //p可以是B的类型也可以是B的子类类型 （a instanceof B） 都是返回true的        if(p instanceof B){//          B b = (B)p;//          b.m();//          System.out.println(b.i);            System.out.println("p是B类型");        } else {            System.out.println("p不是B类型");        }        //如何判断a变量必须是B类型，哪怕是B的父类类型都不行        if(p.getClass() == C.class){            System.out.println("p是C类型");        } else {            System.out.println("p不是C类型");        }    }}class A{}class B extends A{    public int i = 100;    public void m(){        System.out.println("B类中的m方法");    }}class C extends B{}

static关键字
* static关键字
* 1、用static关键字修饰的成员都是类成员（类成员不需要通过对象/实例去访问）
* 2、类成员可以通过类名直接访问
* 3、类成员也可以通过对象去访问
* 4、一个为空的类型对象也可以调用类中的类成员，不会报空指针异常
* 5、类成员只有一份资源，通过类名访问，对象访问，空对象访问的都是同一份资源，
* 只要修改一次，那么其他访问结果也会全部被修改
* 6、static关键字可以修饰属性、方法、代码块和内部类
* 7、类成员（静态成员）不能直接访问实例成员（非静态成员）
* 8、实例成员可以随意访问类成员
* 9、在类成员中不能使用this和super关键字
* 10、类成员会随着类加载的时候被加载,仅仅只会被加载一次