02-Java基础-三大特性

代码块、封装、Override与Overload、继承、多态、抽象类、接口、包(package)

代码块

概述：使用{}括起来的代码被称为代码块。
根据其位置和声明的不同，可以分为局部代码块），构造代码块，静态代码块，同步代码块(多线程讲解)。

常见代码块的应用：
局部代码块（基本不用
在方法中出现；限定变量生命周期，及早释放，提高内存利用率

构造代码块 (初始化块 基本不用)
在类中方法外出现；多个构造方法方法中相同的代码存放到一起，每次调用构造都执行，并且在构造方法前执行

静态代码块
在类中方法外出现，并加上static修饰；随着类的加载而加载，只执行一次，优先于主方法执行。
一般用于加载驱动

封装

是指一种将抽象性函式接口的实现细节部份包装、隐藏起来的方法。

• 封装的优点
  1）隐藏实现细节，提供公共的访问方式；
  2）提高了代码的复用性；
  3）提高安全性；

• 注意事项
  1）子类只能集成父类非私有成员（成员方法和成员变量）；
  2）子类不能继承父类的构造方法，但可以通过super去访问父类的构造方法；
  3）this和super区别：this可以访问自己的成员变量，也可以访问父类的成员变量（本类没有该成员变量）；super只能访问父类的成员变量。
  4）构造函数中有super没this，有this没super；this或super必须放在构造函数的第一行，（可以在一个构造函数中通过this调用其它构造方法），无论如何子类必须访问父类的构造函数。

重写(Override)与重载(Overload)

• Override
  重写是子类对父类的允许访问的方法的实现过程进行重新编写, 返回值和形参都不能改变。

class Animal{
   public void move(){
      System.out.println("动物可以移动");
   }
}
 
class Dog extends Animal{
   public void move(){
      super.move();   // 如果需要保留父类方法，用super调用
      System.out.println("狗可以跑和走");
   }
}
 
public class TestDog{
   public static void main(String args[]){
      Animal a = new Animal(); // Animal 对象
      Animal b = new Dog(); // Dog 对象
 
      a.move();// 执行 Animal 类的方法
      b.move();//执行 Dog 类的方法
   }
}
运行结果如下：
动物可以移动
动物可以移动
狗可以跑和走

方法的重写规则:
1）参数列表必须完全与被重写方法的相同；
2）返回类型必须完全与被重写方法的返回类型相同；
3）访问权限不能比父类中被重写的方法的访问权限更低。
4）如果父类的一个方法被声明为public，那么在子类中重写该方法就不能声明为protected。
5）父类的成员方法只能被它的子类重写。
6）声明为final的方法不能被重写。
7）声明为static的方法不能被重写，但是能够被再次声明。
8）子类和父类在同一个包中，那么子类可以重写父类所有方法，除了声明为private和final的方法。
9）子类和父类不在同一个包中，那么子类只能够重写父类的声明为public和protected的非final方法。

• Overload
  重载(overloading) 是在一个类里面，方法名字相同，而参数不同。返回类型可以相同也可以不同。
  每个重载的方法（或者构造函数）都必须有一个独一无二的参数类型列表。（只看参数列表）
  重载规则:
  1）被重载的方法必须改变参数列表(参数个数或类型或顺序不一样)；
  2）被重载的方法可以改变返回类型；
  3）被重载的方法可以改变访问修饰符；
  4）被重载的方法可以声明新的或更广的检查异常；
  5）方法能够在同一个类中或者在一个子类中被重载。

public class Overloading {
    public int test(){
        System.out.println("test1");
        return 1;
    }
 
    public void test(int a){
        System.out.println("test2");
    }   
 
    //以下两个参数类型顺序不同
    public String test(int a,String s){
        System.out.println("test3");
        return "returntest3";
    }   
 
    public String test(String s,int a){
        System.out.println("test4");
        return "returntest4";
    }   
}

重写与重载之间的区别

1）方法重载是一个类中定义了多个方法名相同,而他们的参数的数量不同或数量相同而类型和次序不同,则称为方法的重载(Overloading)。
2）方法重写是在子类存在方法与父类的方法的名字相同,而且参数的个数与类型一样,返回值也一样的方法,就称为重写(Overriding)。
3）方法重载是一个类的多态性表现,而方法重写是子类与父类的一种多态性表现。

继承

继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。

• 继承的好处
  1.提高了代码的复用性
  2.提高了代码的维护性
  3.让类与类之间产生了关系，是多态的前提

• 继承的注意事项
  1.子类只能继承父类所有非私有的成员(成员方法和成员变量)
  2.子类不能继承父类的构造方法，但是可以通过super关键字去访问父类构造方法

• 继承中构造方法的关系
  子类中所有的构造方法默认都会访问父类中空参数的构造方法
  因为子类会继承父类中的数据，可能还会使用父类的数据。
  所以，子类初始化之前，一定要先完成父类数据的初始化。

多态

多态是同一个行为具有多个不同表现形式或形态的能力。

• 多态的前提
  1.继承
  2.重写
  3.父类引用指向子类对象
• 多态中成员的访问特点
  1.成员变量
  编译看左边，运行看左边
  2.成员方法
  编译看左边，运行看右边
  3.静态方法
  编译看左边，运行看左边

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

• 多态中向上转型和向下转型

Animal a = new Cat();  // 向上转型
Cat c = (Cat)a;        // 向下转型

• 多态的好处和弊端
  1）多态的优点
  提高代码的维护性
  提高代码的扩展性
  2）多态的弊端
  不能使用子类的特有属性和行为

抽象类

抽象类不能用来实例化对象，声明抽象类的唯一目的是为了将来对该类进行扩充。

• 抽象类的特点
  1）抽象类和抽象方法，必须用 abstract 修饰。
  abstract class 类名{}；
  public abstract void function（）;
  2）抽象类不一定有抽象方法，有抽象方法的类一定是抽象类或接口。
  3）抽象类不能实例化，由子类实例化。

// 抽象类
abstract class Animal{
    int num1 = 10;
    final int num2 = 20;

    public Animal(){}
    // 抽象类中可以有非抽象方法
    public void eat(){
        System.out.println("吃饭");
    }

    public abstract void run();
}

class Dog extends Animal{
    @Override
    public void run() {
        System.out.println("奔跑");
    }
}

接口

一个抽象类型，是抽象方法的集合，接口通常以interface来声明。

• 接口与类的区别

• 接口不能用于实例化对象。
• 接口没有构造方法。
• 接口中所有的方法必须是抽象方法。
• 接口不能包含成员变量，除了 static 和 final 变量。
• 接口不是被类继承了，而是要被类实现。
• 接口支持多继承。

• 抽象类和接口的区别

• 抽象类中的方法可以有方法体，就是能实现方法的具体功能，但是接口中的方法不行。
• 抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是 public static final 类型的。
• 接口中不能含有静态代码块以及静态方法(用 static 修饰的方法)，而抽象类是可以有静态代码块和静态方法。
• 一个类只能继承一个抽象类，而一个类却可以实现多个接口。

包(package)

为了更好地组织类，Java 提供了包机制，用于区别类名的命名空间。
包语句的语法格式为：
package pkg;
package pkg1.pkg2.pkg3; 多级包

内部类

• 内部类访问特点
  1.内部类可以直接访问外部类的成员，包括私有。
  2.外部类要访问内部类的成员，必须创建对象。
  3.外部类名.内部类名 对象名 = 外部类对象.内部类对象;

// 匿名内部类
public interface AnonymousInnerClassInterface {

    public void print();

}

class Outter{
    class Inner implements AnonymousInnerClassInterface{

        @Override
        public void print() {
            System.out.println("匿名内部类1");
        }
    }

    public void method(){
//        方法一
        Inner inner = new Inner();
        inner.print();

//        方法二
        new AnonymousInnerClassInterface(){
            @Override
            public void print() {
                System.out.println("匿名内部类2");
            }
        }.print();

//        方法三
        AnonymousInnerClassInterface inter = new AnonymousInnerClassInterface(){
            @Override
            public void print() {
                System.out.println("匿名内部类2");
            }
        };
        inter.print();
    }
}