Java面向对象第二章

final修饰符

• final修饰的变量称之为最终常量，在程序运行期间是不会被改变的

• final修饰的类不可以被继承，修饰的方法不可被重写

• final修饰的基本数据类型变量进过方法后，不会改变；修饰的引用类型变量进过方法后，地址不变，对象中的内容可以改变

• final修饰的静态成员常量不会导致类加载，但如果在加载前无法确定静态成员常量的值，就会导致类加载。

  package com.mage.oop.inter;  
    
  public class Test02 {  
      //无法确定静态常量的值
      final static int num=(int(Math.random()*25); 
      static {  
          System.out.println("我是静态代码块");  
      }  
      public static void main(String[] args) {  
          System.out.println(Test02.num);  
      }  
  } 
  
  public class Test03 {  
      public static void main(String[] args) {  
          System.out.println(Test02.num);  
      }  
  }
  

类的加载顺序（有继承关系）

1. 父类静态代码块
2. 子类静态代码块
3. 父类初始化块
4. 父类构造器
5. 子类初始化块
6. 子类构造器

public class Test04 {  
    public static void main(String[] args) {  
        new S2().m();  
    }  
}  
class F{  
    static {  
        System.out.println("父类静态代码块");  
    }  
    {  
        System.out.println("父类初始化块");  
    }  
    public F() {  
        System.out.println("父类构造器");  
    }  
}  
class S1 extends F{  
    static {  
        System.out.println("子类s1的静态代码块");  
    }  
    {  
        System.out.println("子类s1的初始化块");  
    }  
    public S1() {  
        System.out.println("子类s1的构造器");  
    }  
}  
class S2 extends F{  
    static {  
        System.out.println("子类s2的静态代码块");  
    }  
    {  
        System.out.println("子类s2的初始化块");  
    }  
    public S2() {  
        System.out.println("子类s2的构造器");  
    }  
    public void m() {  
        new S1();  
    }  
}  

abstract抽象类

定义：一个类中没有足够的信息来描绘一个具体的对象，包含了抽象方法的类就是抽象类、被abstract修饰的类就是抽象类。

结构：abstract class 类名{}

要求：1.父类不需要定义方法的具体实现步骤

​ 2.子类必须重写

优点：避免子类的随意设计，提高了代码的可读性，提高了子类的健壮性 。

tips: 1. 抽象类中既可以定义抽象方法也可以定义普通方法

2. 抽象类中可以存在构造器，但是不能实例化，抽象类中的构造器是给子类准备的

3. 抽象类就是用来被继承的，抽象方法就是用来被重写的

4. 子类继承了抽象类之后一定要重写所有的抽象方法

   public class Test02 {  
       public static void main(String[] args) {  
           Father father=new Son();  
           father.sleep();  
       }  
   }  
   abstract class Father{  
       public Father() {  
           System.out.println("我是父类构造器");  
       }  
       public abstract void sleep() ;  
   }  
   class Son extends Father{  
       public Son() {  
       }  
       public void sleep() {  
           System.out.println("在地板上睡觉");  
       }  
   }  
   

接口

定义：1.接口是一种规范，一套标准，比抽象类还抽象

结构：修饰符 interface 接口名{}

• 接口中的变量是公开的，静态的最终常量值，默认情况下都是public static final 修饰的

• 接口中可以定义静态方法，但是不建议使用

• 接口中定义的对象方法都是抽象方法，接口中的默认方法都是abstract修饰的

• 接口中的默认方法在1.8之后才开始被使用，允许在接口中定义default方法，而且还存在方法体。

  tips: 1.类和接口直接通过implements 发生关系，类实现接口

  2. 类必须实现接口中的所有抽象方法

  3. 一个类可以实现多个接口 类名 implements 接口1 接口2…

  4. 一个类实现了接口后要将当前接口和接口的父类接口中的所有抽象方法 重写

  5. 接口可以继承，但是无法实例化，也没有构造器

  6. 接口中可以使用多态

     package com.mage.oop.inter1;  
       
     public class Test01 {  
         public static void main(String[] args) {  
             Fly f1=new Superman();  
             f1.fly();  
         }  
     }  
     interface Fly {  
         public abstract void fly() ;  
     }  
     class Superman implements Fly{  
         public void fly() {  
             System.out.println("咻咻咻");  
         }  
     }  
     

equals方法

• equals方法就是用来比较两个对象是否相等

• 默认的的equals的方法是比较两个对象的地址

• null可以强转为任意类型 ，null也可以是任意类型

//模拟登录注册  
public class Test01 {  
    public static void main(String[] args) {  
        User u1=new User("张三","123");  
        User u2=new User("张三","123");  
        System.out.println(u1.equals(u2));  
}  
}  
class User{  
    String name;  
    String pwd;  
    public User() {  
          
    }  
    public User(String name,String pwd) {  
        super();  
        this.name=name;  
        this.pwd=pwd;  
    }  
      
    public String getName() {  
        return name;  
    }  
    public void setName(String name) {  
        this.name = name;  
    }  
    public String getPwd() {  
        return pwd;  
    }  
    public void setPwd(String pwd) {  
        this.pwd = pwd;  
    }  
    public boolean equals(Object obj) {  
        if(!(obj instanceof User)) {  
            return false;  
        }  
        User u=(User)obj;  
        if(this.name!=null&&this.pwd!=null) {  
            if(this.name.equals(u.name)&&this.pwd.equals(u.pwd)) {  
                return true;  
            }  
        }  
        return false;  
    }  
}