2019-05-19 Java学习日记 day9

修饰类

feinal关键字特点：

　　修饰类，类不能被继承

　　修饰变量，变量就变成了常量，只能被赋值一次

　　修饰方法，方法不能被重写

final修饰变量叫做常量们一般会与public static共用

class demo1_final
{
    public static void main (String args  []){
    son s=new son();
    s.print();
    }
}
class son
{
    final int num=10;
    public void print(){
        num=20;
    System.out.println(num);
    }
}

基本类型：值不能被改变

引用类型：地址值不能被改变，对象中的属性可以改变

class demo2_final
{
    public static void main (String args []){
        final person p =new person("一",20);
        p.setname("二");
        System.out.println(p.getname()+","+p.getage());
        method(10);
    }
    public static void method(final int x){
    System.out.println(x);
    }
}
class person
{
    private String name;
    private int age;
    public person(){}
    public  person(String name,int age){
    this.name=name;
    this.age=age;
    }
    public void setname(String name){
    this.name=name;
    }
    public String getname(){
    return name;
    }
    public void setage(int age){
    this.age=age;
    }
    public int getage(){
    return age;
    }
}

多态（polymorphic）

　　事物存在的多种形态

多态前提：

　　要有继承关系

　　要有方法重写

　　要有父类引用指向子类对象

class demo1_polymorphic
{
    public static void main (String args []){
        cat c=new cat();
        c.eat();
        animal a=new cat();  //父类引用指向子类对象
        a.eat();
    }
}
class animal
{
    public void eat(){
    System.out.println("吃饭");
    }
}
class cat extends animal{
 public void eat(){
    System.out.println("吃鱼");
 }
}

多态的成员变量特点：编译看左边（父类），运行看左边（父类）

成员方法：编译看左边（父类），运行看右边（子类），动态绑定

class demo2_polymorphic
{
    public static void main (String args []){
    father f=new son();
    System.out.println(f.num);//成员变量
    f.print();   //成员方法
    }
}
class father
{
    int num=10;
    public void print(){
    System.out.println("father");
    }
}
class son extends father
{
    int num=20;//成员变量
    public void print(){  //成员方法
    System.out.println("son");
    }
}

静态方法：

　　编译看左边（父类），运行看左边（父类）

　　只有非静态的成员方法，编译看左边，运行看右边

向上转型

向下转型

class demo3_polymorphic
{
    public static void main (String args []){
        person p =new superman();   //向上转型
        System.out.println(p.name);
        p.print();
        System.out.println("--------------");
        superman sm=(superman)p;  //向下转型
       System.out.println(sm.name);
        sm.fly();
    }
}
class person
{
    String name="Jung";
    public void print(){
    System.out.println("读书");
    }
}
class superman extends person
{
String name="superman";
public void fly(){
System.out.println("会飞");
}
     public void print(){
     System.out.println("上班");
     }
}

多态的好处：

　　提高了代码的维护性（继承保证）

　　提高了代码的展性（多态保证）

多态的弊端：

　　不能使用子类的持有属性和行为

关键字（instanseof）

判断前边的引用是否是后边数据类型

class demo4_animal
{
    public static void main (String args []){
    method(new cat());
    method(new dog());
    } 
    public static void method(animal a){
    if(a instanceof cat){
    cat c=(cat)a;
    c.eat();
    
    }else if(a instanceof dog){
    dog d=(dog)a;
    d.eat();
    d.lookhome();
    }else{
    a.eat();
    }

    }
}
class animal
{
    public void eat(){
    System.out.println("动物吃饭");
    }
}
class cat extends animal
{
    public void eat(){
    System.out.println("猫吃鱼");
    }
}
class dog extends animal
{
    public void eat(){
    System.out.println("狗吃屎");
    }
    public void lookhome(){
    System.out.println("狗看家");
    }
}

抽象类

　　抽象类和抽象方法必须用abstract关键字修饰：：

　　　　abstract class类名（）

　　　　public abstract void eat（）；

　　抽象类不一定有抽象方法，有抽象方法的类一定是抽象类或者是接口

　　抽象类不能实例化：

　　　　按照多态方式，有具体的子类实例化，其实这也是多态的一种，抽象类多态

　　抽象类的子类：

　　　　要么是抽象类

　　　　要么重写抽象类中的所有抽象方法

class demo1_abstract
{
    public static void main (String args []){
    animal a=new cat();   //父类引用指向子类对象
    a.eat();
    }
}
abstract class animal
{
    public abstract void eat();
}
class cat extends animal
{
    public void eat(){
    System.out.println("猫吃鱼");
    }
}

抽象类的成员特点：

　　成员变量：既可以是变量，也可以是常量

　　构造方法：用于子类访问父类数据的初始化

特性：

　　抽象方法，强制要求子做的事情

　　非抽象方法 子类继承的事情，提高代码复用性

class demo2_abstract
{
    public static void main (String args []){
     吴江德 p=new 吴江德();
     p.断手();
    }
}
abstract class 一指神功
{
    public abstract void 断手();
}
class 吴江德 extends 一指神功
{
    public void 断手(){
    System.out.println("断一只手指");
    }
}
class 吴基德 extends 一指神功
{
    public void 断手(){
    System.out.println("断三只手指");
    }
}

接口

　　从狭义的角度讲就是指Java中的interface。

　　 从广义的角度讲对外提供规则的都是接口。

接口特点：

　　接口用关键字Interface表示

                     interface 接口名 { }

　　类实现接口用implements表示

                      class 类名 implements 接口名 { }

　　接口不能实例化

                 （按照多态的方式来实现）

　　接口的子类：

              可以是抽象类，但是意义不大

               可以是具体类。要重写接口中的所有抽象方法（推荐方案）