Java小白学点东西（基础）（9）

1.final

翻译过来的意思是：最终的，最后的

用法：（四种）

1.final修饰成员变量

使用final修饰成员变量的时候必须进行赋值（初始化）。如果赋值以后，这个值就能不能更改了。

2.final可以修饰局部变量

局部变量使用final可以不赋值。使用final修饰的局部变量一旦本赋值就不能修改

3.final可以修饰成员方法

final修饰的成员方法，子类不能重写！！！

4.final可以修饰类

final修饰的类不能被继承

​
//final修饰的类不能被继承
  class Person {
   final int age = 23;
​
   public final void eat () {
       System.out.println("烤枸杞");
​
   }
   public void test () {
      final int num;//num是一个局部变量  可以不用直接赋值
//       num = 20;//num被赋值了
//       num = 30;//下面想改变num值，不能改变，因为被final
   }
​
}
//class Student extends Person{
////    public final void eat() {
////
////    }
//}
public class Demo1 {
    public static void main(String[] args) {
       final Person person = new Person();
        //person.age = 56;//age属性的值已经赋值了，不能再更改了
​
​
    }
}
​

2.接口【重点】

2.1生活中的接口

电脑上的usb

插座

接口的作用是扩展功能！！！

2.2java中接口

语法格式：

interface 接口名字{

成员属性；//很少用

成员方法；

}

【注意事项】：

1.接口下面可以声明成员属性，但是要赋值，因为默认被final修饰了

2.接口下面的方法必须都是抽象方法，abstract关键字默认有的，可以有也可以没有

3.接口不能被实例化

4.接口必须使用一个类去实现（implements）它

5.必须重写接口中所有的抽象方法

6.可以实现多个接口，相当于实现了多继承

2.3抽象类和接口的区别【面试题】

1.接口的方法都是抽象的，抽象类可以有抽象方法，也可以有非抽象方法
2.类可以试想多个接口，但是只能继承一个抽象类
3.类如果要实现一个接口的话，必须要实现它所有的抽象方法
    类如果要继承一个抽象类，可以不求重写非抽象方法，但是抽象方法必须重写
4.抽象类去实现接口，接口的方法在抽象类中可以不强制重写
5.java8及以上的版本可以写默认的方法，这个方法带有方法体

2.4接口的案例

见c_interface

3.多态【重要】

封装 继承 多态

父类的引用指向子类的对象

Father Son 其中 Father 是Son类的父类

Father father = new Son()

为什么要使用多态的一种写法：

多态的使用可以让咱们的代码变得更加灵活，简洁。具有普适性

3.1多态的案例

见文件e_duotai f_duotai文件夹

3.2向上转型和向下转型【了解】

父子对象之间的转换分为向上转型和向下转型。他们的区别如下：

向上转型：通过子类的对象(小范围)去实例化父类的对象（大范围）,属于自动转换【父类的引用指向子类的对象】小范围转为大范围 是自动转的

向下转型：通过父类的对象(大范围)去实例化子类的对象（小范围），属于强制转换

3.2.1向上转型

​class A {
    public void test(){
        System.out.println("A:test");
    }
​
}
class B extends A {
    @Override
    public void test() {
        System.out.println("B:test");
    }
}
public class Test {
    public static void main(String[] args) {
        A a = new B();//向上转型，父类引用指向子类的对象。
        //通过子类去实例化父类
        a.test();
​
        //意义：当我们需要对方法进行传参数的时候，
//这个参数可以是父类的对象，但是传真实的参数的时候，直接传子类的对象即可
    }
}

​

3.2.2向下转型【了解】

在java中，向下转型是为了通过父类强制转换成子类，从而可以调用子类独有的方法。

向下转型在真实的项目中很少，几乎不用！！！

class A1 {
    public void test(){
        System.out.println("A:test");
    }
​
}
class B1 extends A1 {
    @Override
    public void test() {
        System.out.println("B:test");
    }
    public void funcB () {
        System.out.println("funcB");
    }
}
class C1 extends A1 {
    @Override
    public void test() {
        System.out.println("C:test");
    }
    public void func() {
        System.out.println("funC");
    }
}
public class Test1 {
    public static void main(String[] args) {
        A1 a1 = new A1();
        func(a1);
​
    }
    public static void func (A1 a1) {
        a1.test();
        if (a1 instanceof B1) {
            //((B1) a1).funcB();
            //子类 子类变量名字 = （子类）父类对象;
           B1 b1 = (B1)a1;//强制转换  获得子类特有的方法，要获取子类对象
            //但是你的参数父类的a1  a1 变成b1  只能强转
           b1.funcB();
        } else if(a1 instanceof C1){
            C1 c1 = (C1) a1;
            c1.func();
        }
    }
}

​

总结：

父转子，需要强制类型转换，目的是为了调用子类独有的方法
子转父，自动转换，啥也不需要，但是不可以调用子类独有的方法