JAVA学习笔记4

2./*final关键字用法
掌握final关键字的使用要求
掌握全局常量的声明
使用final声明的类不能有子类；
使用final声明的方法不能被子类所覆盖；
使用final声明的变量即成为常量，常量不可以修改
如果一个程序中使用public static final关键字联合声明的变量称为全局常量：
public static final String INFO = "LXH" ;
在使用final声明变量时，要求全部的字母大写，如INFO，这点在开发中是非常重要的。 */
class Person{
final int age=100;
public static final String INFO="LXH" ;
}
public class test1{
public static void main(String args[]){

Person p1=new Person();
System.out.println(p1.age);
System.out.println(p1.INFO);
}
}

3.instanceof关键字

/*instanceof 关键字
对象 instanceof 类   ?  返回boolean类型
如果x属于类A的子类B，x instanceof A值也为true。
*/
class A {
    int a=100;
    public void fun1(){
        System.out.println(a);
    }
}
class B extends A{
    public void fun2(){
        System.out.println("abc");
    }
}
class test1{
    public static void main(String args[]){
        B b=new B();
        A a=b;
        boolean x=a instanceof B;
        boolean y=a instanceof A;
        System.out.println(x+","+y);
    }
}

/*对象的多态性
对象的向上转型（重点）
Student s=new Student();
          Person p=s;
或Person p=new Student();*/
/*父类*/
class A{
    public void fun1(){
        System.out.println("A-->");
    }
    public void fun2(){
        this.fun1();
    }
};
/*子类*/
class B extends A{
    public void fun1(){
        System.out.println("B-->public void fun1---");
    }
    public void fun3(){
        System.out.println("B---phblic void fun3");
    }
};
public class test1{
    public static void main(String [] args){
        B b=new B();
        A a=b;
        a.fun1();
    }
}

/* 子类对象实例化过程
使用super可以从子类中调用父类中的构造方法、普通方法、属性。
 */
class Person {            // 定义父类Person
    private String name;        // 定义name属性
    private int age;        // 定义age属性
    public Person(String name,int age){// 通过构造方法设置name和age
        this.setName(name);    // 设置name属性内容
        this.setAge(age);        // 设置age属性内容
    }
    public void setName(String name){
        this.name=name;
    }
    public String getName(){
        return this.name;
    }
    public void setAge(int age){
        this.age=age;
    }
    public int getAge(){
        return this.age;
    }
    public String getInfo(){        // 信息输出
        return "姓名：" + this.getName() + "；年龄：" + this.getAge() ;
    }
}
class Student extends Person{
    private String school;
    public Student(String name,int age,String school){
        super(name,age);
        this.setSchool(school);
    }
    public void setSchool(String school){
        this.school=school;
    }
    public String getSchool(){
        return this.school;
    }
    public String getInfo(){
        return super.getInfo()+"学校"+this.getSchool();
    }

}
public class Thisi{
    public static void main(String args[]){
        Student st1=new Student("张三",28,"北大");
        System.out.println(st1.getInfo());
    }
}

1.方法的覆盖

/* 掌握子类对象的实例化过程
掌握方法覆写的概念及实现
在子类中可以根据需要对从父类中继承来的方法进行改造—方法覆盖(方法的重置、重写)覆盖方法必须和被覆盖方法具有相同的方法名称、参数列表和返回值类型。覆盖方法不能使用比被覆盖方法更严格的访问权限
掌握super关键字的作用 */
class Person{
    void print(){
        System.out.println("Person-->void print()");
    }
}
class Student extends Person{
    public void print(){
        /*super调用父类中的方法*/
        super.print();
        System.out.println("Student-->void print()");
    }
}
public class Thisi{
    public static void main(String args[]){
        new Student().print();
    }
}

属性的覆盖

/* 属性的覆盖
super调用父类中的方法或属性
 */
class Person{
    public String info="MLDN";
}
class Student extends Person{
    public String info="LXH";
    public void print(){
        System.out.println("父类中的属性"+super.info);
        System.out.println("子类中的属性"+info);
    }
}
public class Thisi{
    public static void main (String args[]){
        new Student().print();
    }
}

继承

/*继承的基本语法特点*/
/*继承就是一个类的得到了另外一个类的成员变量和成员方法。
类继承语法规则:

 < 修饰符> class < 子类名称> [extends < 父类>]
    {
        <属性和方法的声明>
      }
类通过getter访问父类中的属性
*/
class ManKind{
    int sex;
    int salary;
    public void manOrWoman(){
        if(sex==1)
            System.out.println("Man");
        else System.out.println("Women");
    }
    public void employed(){
        if(salary==0)
            System.out.println("No job");
        else System.out.println("job");
    }
}
public class Thisi extends ManKind{
    int yearsOld;
    void printAge(){
        System.out.println("age="+yearsOld);
    }
    public static void main(String args[]){
        Thisi THI=new Thisi();
        THI.sex=1;
        THI.salary=0;
        THI.manOrWoman();
        THI.employed();
        THI.yearsOld=28;
        THI.printAge();
    }