JAVA基础知识(二)

一、final、常量

1.final关键字是最终的意思，可以修饰类、修饰方法、修饰变量。

• final修饰类：该类称为最终类，特点是不能被继承

• final修饰方法：该方法称之为最终方法，特点是不能被重写。

• final修饰变量：该变量只能被赋值一次。

 2.在实际运用当中经常使用final来定义常量

那么，什么是常量呢？

被 static final 修饰的成员变量，称之为常量

通常用于记录系统的配置信息

代码演示：

public class Constant {
    //常量: 定义一个常量表示学校名称
    //为了方便在其他类中被访问所以一般还会加上public修饰符
    //常量命名规范：建议都采用大写字母命名，多个单词之前有_隔开
    public static final String SCHOOL_NAME = "北京大学";

public class FinalDemo2 {
    public static void main(String[] args) {
        //由于常量被static修饰，在使用时直接用类名就可以调用
        System.out.println(Constant.SCHOOL_NAME);
        System.out.println(Constant.SCHOOL_NAME);
        System.out.println(Constant.SCHOOL_NAME);
        System.out.println(Constant.SCHOOL_NAME);
        System.out.println(Constant.SCHOOL_NAME);
        System.out.println(Constant.SCHOOL_NAME);
        System.out.println(Constant.SCHOOL_NAME);
    }
}

二、多态

1.什么是多态

• 多态：指的是同一个对象，在不同时刻表现出来的多种形态

举例：猫

• 我们可以说猫是猫：猫 cat = new 猫();

• 我们也可以说猫是动物：动物 animal = new 猫();

• 这里猫在不同的时刻表现出来了多种形态，这就是多态

了解了什么是多态后，我们再来说一下多态的前提和体现：

• 有继承/实现关系

• 有方法重写

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

public class Animal {

    public void eat() {
        System.out.println("动物吃东西");
    }

}

public class Cat extends Animal {

    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }

}

/*
    多态的前提和体现
        有继承/实现关系
        有方法重写
        有父类引用指向子类对象
 */
public class AnimalDemo {
    public static void main(String[] args) {
        //有父类引用指向子类对象
        Animal a = new Cat();
    }
}

 2.多态的好处与弊端

   多态的好处：提高了程序的扩展性

   具体体现：定义方法的时候，使用父类型作为参数，将来在使用的时候，使用具体的子类型参与操作

  多态的弊端：不能使用子类的特有功能

3.多态的应用场景

   定义方法时，形参可以设置为抽象类或接口

   创建对象时，使用父类引用指向子类对象

 4.多态的注意事项：多态不是万能的，如果必须依赖子类相关的方法或变量，则可以不用多态的写法

三、抽象类

1.什么是抽象类？

在Java中，一个没有方法体的方法应该定义为抽象方法，而类中如果有抽象方法，该类必须定义为抽象类

public abstract class Animal {

    /*
    public void eat() {
        System.out.println("吃东西");
    }
    */
    public abstract void eat();
}

/*
    测试类
 */
public class AnimalDemo {

    public static void main(String[] args) {
        /*
        Animal a = new Animal();
        a.eat();
        */
    }
}

2.抽象类的特点

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

  • public abstract class 类名 {}

  • public abstract void eat();

• 抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类

• 抽象类不能实例化

  • 抽象类如何实例化呢？参照多态的方式，通过子类对象实例化，这叫抽象类多态

• 抽象类的子类

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

  • 要么是抽象类

    抽象类和普通类的区别: 普通类所拥有的的,抽象类都有,而且还多了一个抽象方法

/*
    抽象类
 */
public abstract class Animal {
    //抽象方法
    public abstract void eat();

    public void sleep() {
        System.out.println("睡觉");
    }
}

 

public class Cat extends Animal {

    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}

public abstract class Dog extends Animal {

}

/*
    测试类
 */
public class AnimalDemo {
    public static void main(String[] args) {
//        Animal a = new Animal();
        Animal a = new Cat();
        a.eat();
        a.sleep();
    }
}

四、接口

• 接口就是一种公共的规范标准，只要符合规范标准，大家都可以通用

• Java中的接口更多的体现在对行为的抽象

1.接口的特点

• 接口用关键字interface修饰

  • public interface 接口名 {}

• 类实现接口用implements表示

  • public class 类名 implements 接口名 {}

• 接口不能实例化

  • 接口如何实例化呢？参照多态的方式，通过实现类对象实例化，这叫接口多态

  • 多态的形式：具体类多态，抽象类多态，接口多态

  • 多态的前提：有继承或者实现关系；有方法重写；有父(类/接口)引用指向(子/实现)类对象

• 接口的实现类

  • 要么重写接口中的所有抽象方法

  • 要么是抽象类

代码演示：

/*
    定义了一个接口
 */
public interface Inter {
    public abstract void show();
}



/*
   类实现了一个接口
*/
public class InterImpl implements Inter {
    @Override
    public void show() {
        System.out.println("show...");
    }
}

 

2.接口的成员特点：

• 成员变量

  • 只能是常量

  • 默认修饰符：public static final

• 构造方法

  • 没有，因为接口主要是扩展功能的，而没有具体存在

  • 一个类如果没有父类，默认继承自Object类

• 成员方法

  • 只能是抽象方法

  • 默认修饰符：public abstract

3. 类和接口的关系

• 类和类的关系

  • 继承关系，只能单继承，但是可以多层继承

• 类和接口的关系

  • 实现关系，可以单实现，也可以多实现，还可以在继承一个类的同时实现多个接口

• 接口和接口的关系

  • 继承关系，可以单继承，也可以多继承

 

4.接口中默认方法的定义格式：

• 格式：public default 返回值类型 方法名(参数列表) { }

• 范例：public default void show1() { }

5.接口中默认方法的注意事项：

• public可以省略，default不能省略

 五、枚举

关键字：enum

public enum 枚举类名{
    枚举项1,枚举项2,枚举项3;
}


public enum A{
    X,Y,Z;
}



/*
   直接使用类名调用
*/
public class Test{
    public static void main(String[] args){
        //获取枚举A类的，枚举项
        A a1 = A.X;
        A a2 = A.Y;
        A a3 = A.Z;
    }
}

使用场景：指定某几个值的时候

好处：避免用户或其他程序员指定了意料之外的值

 六、泛型

1.所谓泛型指的是，在定义类、接口、方法时，同时声明了一个或者多个类型变量（如：<E>），称为泛型类、泛型接口、泛型方法、它们统称为泛型。

2.泛型类使用：

ArrayList<String> a = new ArrayList<>();

ArrayList集合的设计者在定义ArrayList集合时，就已经明确ArrayList集合时给别人装数据用的，但是别人用ArrayList集合时候，装什么类型的数据他不知道，所以就用一个<E>表示元素的数据类型。

当别人使用ArrayList集合创建对象时，new ArrayList<String>就表示元素为String类型，new ArrayList<Integer>表示元素为Integer类型。

3.泛型的好处、本质

• 泛型的好处：在编译阶段可以避免出现一些非法的数据。

• 泛型的本质：把具体的数据类型传递给类型变量。