Java Day9

1.final 关键字

final不可更改

  1. final修饰的成员、局部变量，无法改变，又称为常量
  2. 被final修饰的方法不可以被重写
  3. 被final修饰的类无法更改
1
2
3
4
5
6
7
8
9
10
11
12
13
public class Final {
    final String name = "小张";

    public static void main(String[] args) {
        Final f = new Final();
        final int a = 10;
        
        a = 1;
        f.name = "2333";
    }

}
//编译器报错
  • 局部变量和成员变量name 都无法更改
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
public class Final {
    final String name = "小张";

    public final void hellowold(){
        System.out.println("helloworld");
    }

    public static void main(String[] args) {
        Final f = new Final();
        final int a = 10;

//        a = 1;
//        f.name = "2333";
    }

}

class b extends Final{
    void hellowold(){
        System.out.println("hello");
    }
}
//编译器报错
  • b 继承 Final 父类 但无法重写其final 方法
1
2
3
4
5
6
7
public final class Final{ 
}

class b extends Final{
    //无法被继承
}
//编译器报错
  • final 类不可以被继承

2.abstract 关键字

  • Java中抽象只声明，无法被实现（不能实例化对象）
  • 抽象中的子类 必须实现其抽象方法
  • 接口的方法都是公开抽象
  • 接口中的所有成员变量都是public static final修饰的公开静态常量

1.抽象类的定义

用abstract修饰，不可有方法体{}，直接分好结束。

1
2
3
public  abstract class  A {
    public abstract void work();    //每个人工作都不同 我们可以把工作抽象出来 
}

有抽象方法的 类 必定是一个抽象类 因此其类必须也要用abstract修饰

2.继承抽向类必须重写其抽象方法，否则子类也是抽象类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
public  abstract class  A {
    public abstract void work();    //每个人工作都不同 我们可以把工作抽象出来

    public static void main(String[] args) {
        c w = new c();
        w.work();
        w.work2();
    }
}

//没有实现父类抽象方法 所以子类b也是抽象类
abstract class b extends A{
    public abstract void work2();        //第二份工作

}


//最终c类继承抽象b类 所以c类可以实例化
class c extends b{

    @Override
    public void work() {
        System.out.printf("我的第1份工作");
    }
    @Override
    public void work2(){
        System.out.printf("我的第2份工作");
    }
}

通过抽象类可以强制子类，要求其实现其方法

抽象类也具有多态性

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public abstract class Abstract {
//    抽象的多态性
  public abstract void function();
}

class A extends Abstract{
//    A 实现了抽象父类
    @Override
    public void function() {
        System.out.println("抽象类也能多态");
    }

    public static void main(String[] args) {
//        多态
        Abstract Class = new A();
        Class.function();
    }
}

抽象类中也允许有普通方法

1
2
3
4
5
6
7
public abstract class Abstract {
//    这是一个抽象类
    public void helloworld(){
        System.out.println("抽象类也允许有普通方法");
    }
}

3.interface 关键字

接口（实际上是一种特殊的抽象类，但接口 相对于 抽象类 不同的是所有的方法必须是抽象方法不能有其他普通方法但可以拥有成员变量）

  1. 接口使用interface声明

    1
    2
    3
    4
    5
    6
    7
    public interface InterFace {

        public static final String name = "这个是一个特殊抽象类，接口";
        public abstract void function();

    }

  2. 接口中所有方法，默认抽象且公开

    1
    2
    3
    4
    5
    6
    7
    8
    9
    public interface InterFace {
        //变量是公开静态常量  即  public static final String name;
    	String name = "2333";
    	// public abastract  	编译器会自动添加
        public abstract void function();
        //->public abstract void function2()   完整的修饰
        void function2();
    }

  3. **使用extends 的继承 **

    InterFace2 继承 接口父类 但未实现因此不能用class 声明 InterFace2只能是接口

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    public interface InterFace {

        public static final String name = "这个是一个特殊抽象类，接口";
        public abstract void function();

    }

    interface InterFace2 extends InterFace{
      
    }

  4. **使用implements的继承 实现了其方法 **

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    public interface InterFace {

        public static final String name = "这个是一个特殊抽象类，接口";
        public abstract void function();

    }

    interface InterFace2 extends InterFace{
      void fucntion2();
    }

    // 实现接口方法 _Class 类可以被实例化
    final class _Class implements InterFace2{
        @Override
        public void function() {
            System.out.println("实现了InterFace的方法");
        }

        @Override
        public void fucntion2() {
            System.out.println("实现了InterFace2   的方法");
        }
    }

  5. 接口多态

    接口1 继承 接口类 _Class继承了接口1类 

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    public interface InterFace {

        public static final String name = "这个是一个特殊抽象类，接口";
        public abstract void function();

    }

    interface InterFace2 extends InterFace{
      void fucntion2();
    }

    final class _Class implements InterFace2{
        @Override
        public void function() {
            System.out.println("实现了InterFace的方法");
        }

        @Override
        public void fucntion2() {
            System.out.println("实现了InterFace2   的方法");
        }

        public static void main(String[] args) {
    //        接口多态
            InterFace Class = new _Class();
            
            Class.function();
            //这里要强制转换 因为function2  是 2接口的 抽象类 抽象父类接口是隐藏的
            ((InterFace2)Class).fucntion2();
    //        Class.function2();
        }
    }
  • 接口可以把很多不相同的内容进行整合

4.Java实现”多继承”

Java只能单继承(只能继承一个类类)，但是可以通过interface 接口实现类似于多继承的关系

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
public class God extends Money implements Decorations, Metal{
    @Override
    public void decorations() {
        System.out.println("黄金可以制作黄金饰品");
    }

    @Override
    public void metal() {
        System.out.println("黄金是金属，可做导体");
    }

    public static void main(String[] args) {
        
        //多态
       Money g = new God();
        g.Value();
        ((Decorations)g).decorations();
        ((Metal)g).metal();
    }
}

class Money{
    public void Value(){
        System.out.println("具有货币性质");
    }
}

interface Decorations{
    public abstract void decorations();
}

interface Metal{
    public abstract void metal();
}