Java系列教程day11——abstract&final&static

最新推荐文章于 2023-10-30 17:04:06 发布

Davie老师

最新推荐文章于 2023-10-30 17:04:06 发布

阅读量295

点赞数

原文链接：https://me.csdn.net/qianfeng_dashuju

版权

day11——abstract&final&static三个关键字

提纲：

1、abstract修饰方法
2、abstract修饰类
3、final关键字
4、static属性
5、static方法
6、static代码块
7、作业

一、abstract关键字

1.1、abstract关键字

abstract，词义："抽象的"。

A：修饰方法，表示抽象的方法。什么意思呢？就是这个方法，只有方法的声明，没有具体的实现(就是方法体，连{}也不能有)，直接分号结束声明。

//方法的声明：访问权限 返回值类型 方法名 形参列表
public void run();

B：还可以修饰类，如果一个类中包含了至少一个抽象方法，那么该类就必须是抽象的。

意味着：表示有这个功能，但是没有具体的要执行的代码。意味着：抽象类，不能被实例化(创建对象)。因为里面可能包含了抽象方法。

abstract class Animal{
    public abstract void run();//只有声明， 没有实现，那么就是抽象方法。
}

public static void main(String[] args){
    //对于抽象类，不能创建对象
    //Animal a = new Animal();
    //a.run();
}

最大的目的：就是强制子类重写。

所以，如果一个类，包含了抽象方法，那么该类就是抽象类。不能被实例化，只能等待子类来继承并实现这个抽象法。子类应该积极的实现这些抽象方法，就可以创建子类对象了。但是如果子类没有实现全部的抽象方法，那么子类也是抽象的，要再等子类继承，并实现抽象方法。

“父债子还”

常见的错误：ctrl+1，万能键

1、Abstract methods do not specify a body
一个抽象方法，不能包含方法体。
2、The type Animal must be an abstract class to define abstract methods
如果一个类中，包含了抽象方法，那么这个类必须抽象的。
3、The type Cat must implement the inherited abstract method Animal.move()
如果子类继承了抽象父类，要么实现父类的抽象方法，要么子类也是抽象的，再等继承。

abstract关键字的使用总结：

1、为什么要使用抽象类？

有些类创建对象没有意思，需要把这个定义为抽象类。
抽象类，不能实例化，只能被继承。

2、abstract关键字

修饰方法：抽象方法，没有方法体，没有{}，需要使用；来结束方法的声明
修饰类：抽象类，抽象方法所在的类必须是抽象的。

3、抽象方法：

没有方法体，就是没有{}。
一个类中如果有抽象方法，那么这个类必须是抽象的
如果一个类是抽象的，不一定非要包含抽象方法。
抽象方法必须被子类重写，除非子类也是抽象的。

4、抽象类：和普通的父类只有一点区别，就是可能包含抽象方法

抽象类中，可能包含有抽象方法，所以抽象类不允许实例化。
抽象类也可以没有抽象方法（语法上是可以的），但是往往没有实际的意义。
抽象类中可以有构造方法吗？可以的。虽然抽象类不能实例化，不能创建对象，但是构造方法会在子类的构造中被调用。
抽象类中的抽象方法，一定要被子类重写，如果子类没有重写，子类也抽象。

5、抽象类和普通类的区别：

抽象类需要使用abstract关键字，普通类不需要。
构造方法：都有，但是抽象类不能被实例化，普通类可以。
成员方法：
- 抽象类中，可以是抽象的，也可以是普通的。
- 普通类中，不能有抽象方法，只能是普通方法。

成员变量：都有

最后：抽象类和普通类很相似，只不过可能多了抽象的方法。“抽象类是天生就来当爹的。”

示例代码：

package com.qf.demo04;

public abstract class Animal {//表示该类是抽象的。
  private int age;
  private char sex;
  public void eat(){
    System.out.println("吃东西。。");
  }
  
  //动物应该有动的功能。。跑，飞，游。。
  public abstract void move();

  
  public Animal(int age, char sex) {
    this.age = age;
    this.sex = sex;
  }
  public Animal() {
    
  }
  public int getAge() {
    return age;
  }
  public void setAge(int age) {
    this.age = age;
  }
  public char getSex() {
    return sex;
  }
  public void setSex(char sex) {
    this.sex = sex;
  }
}
package com.qf.demo04;

public class Cat extends Animal{

  @Override
  public void move() {
    System.out.println("猫咪走猫步。。");
  }

}
package com.qf.demo04;

public abstract class Dog extends Animal {

}
package com.qf.demo04;

public class BigDog extends Dog {

  @Override
  public void move() {
    System.out.println("大狗，慢慢的走。。。");
  }

}
package com.qf.demo04;

public class SmallDog  extends Dog{

  @Override
  public void move() {
    System.out.println("撅着屁股跑。。。");
  }

}
package com.qf.demo04;

public class Test9Abstract {

  public static void main(String[] args) {
    //抽象类，不能创建对象
//    Animal a1= new Animal();
//    a1.move();
    
    Cat c1 = new Cat();
    c1.eat();//父类的方法
    c1.move();//子类重写来的方法
    
    SmallDog d1 = new SmallDog();
    d1.eat();
    d1.move();
  }

}

二、final关键字

词义：“最终的，最后的”。可不可以把final理解成最后的，谁都不能更改。

在Java中，可以修饰类，变量，方法。

1、final修饰局部变量？
    赋值之后，数值不能再修改了。
2、final修饰成员变量？
    final在类中修饰成员变量的话，要求必须初始化。并且赋值后，不能再修改数值了。
3、final修饰成员方法？
    final所修饰的方法，不允许子类重写的。
4、final修饰的类？
    final修饰的类，不允许子类继承。“太监类”，比如String。

所以：

1、final修饰变量（成员变量和局部变量），则为常量，只能赋值这一次。

修饰成员变量的时候，定义时，要同时给出初始化的值。
修饰局部变量，只能赋值一次。

2、final修饰方法，则该方法不能被子类重写

public final 返回值类型 方法名(){

}

3、final修饰类，则类不能被继承

final class 最终类{

}

示例代码：

package com.qf.demo02_final;

final class A{//不能有子类来继承的，代表最后一个类了。
  //The blank final field country may not have been initialized
  //当前final修饰的成员变量，没有被初始化。
  final String country = "中华人民共和国";//成员变量
  
  
  public final void testA(){//最后的方法：这是最终模式，要求子类不能重写
    System.out.println("A类的成员方法。。。");
  }
  
  
}
//The type B cannot subclass the final class A
//B类不能继承final修饰的A类。
//class B extends A{
  //Cannot override the final method from A
  //不允许子类重写父类的final方法
//  @Override
//  public void testA() {//子类重写父类的方法
//    System.out.println("B类重写A类的方法。。");
//  }
//}


public class Test3_Final {

  public static void main(String[] args) {
    final int a = 10;//普通的局部变量
    System.out.println(a);
    /*
     * The final local variable a cannot be assigned. It must be blank and not using a compound assignment
     * final修饰的局部变量，不能被重新赋值
     * 
     * final修饰的变量：局部，还是成员的，一旦被赋值，之后不能修改数据的。
     */
//    a = 20;//重新赋值，更改变量的值。，报错，不允许修改final修饰的局部变量
    System.out.println(a);
    
    A a2 = new A();
    System.out.println(a2.country);
//    a2.country = "其他国家";//报错，不允许修改final修饰的成员变量
    a2.testA();
    
//    B b = new B();
//    b.testA();
  }

}

对比final和abstract关键字修饰方法：

final修饰的方法，不让子类重写。
abstract修饰的方法，要求子类必须重写。
所以final和abstract不能同时修饰一个方法，会疯掉的。

变量：本质就是一小块内存，用于存储数据。在程序执行过程中，数值可以改变。

常量：同变量类似，也是存储数据。数值不能改变。

三、static关键字

3.1 生活中的例子

共享单车：
    1、存储于公共区域。
    2、每个人都可以使用
    3、共享单车，和你，我，他都无关。
    4、如果车坏了，所有骑车的人都收到应用。
总结：
    1、公共区域存储。
    2、共享性使用。
    3、和对象无关。
    4、一处修改，其他的对象访问都收到影响。

3.2 修饰成员属性

词义：“静态的”。属于类，不再属于对象。

public class Person {
    //成员变量：随着对象的创建而产生的。每个对象都有自己的一份属性值，和其他的对象的数值是无关的。
    String name;
    int age;
    static String city;//该类的对象，属性值，恰巧都相同。
    
}

修饰属性：

类中的属性：2种
1、非static，叫成员变量(name,age)，属于对象的。随着对象的创建而产生，创建几个对象，就有几分该属性值。对象的属性值是彼此独立的。
  对象.成员变量，表示该对象访问自己的属性，赋值，取值
2、static的属性，叫静态属性，属于类的。和对象无关。随着类的加载而产生。内存中，就一份。应该由类直接访问，但是对象也可以访问，多个对象，共享这一份数据。
  类.静态属性。可以赋值，取值

如果一个类中的某一个属性，该类所有的对象，对于该属性的取值都相同，就可以写成静态的属性。节省内存，操作简便。

应用：什么样的属性，适合是静态的属性，什么样的适合是成员变量。
所以，static修饰的属性：

1、静态成员变量，使用static修饰的成员变量，定义再内存中【数据区】
2、静态成员变量，不推荐使用对象调用，赋值，取值。。如果使用，也允许，但是会警告：
  The static field Person.city should be accessed in a static way
3、静态的成员属性，属于类的，应该由类直接调用。【强烈的推荐方式】
  类名.静态属性名 = 赋值/取值。
4、如果代码中，没有创建对象，可以通过类名直接访问静态属性。【和对象无关的】
5、不管通过对象还是类，如果修改了静态属性的值，那么就改了，其他的对象来访问，会收到影响。

3.3 修饰成员方法

//static修饰方法的语法格式：
public static 返回值类型/void 方法名(参数列表){
  方法体;
}

一个方法，一旦使用static修饰，就表示该方法属于类，应该由类来直接调用。

静态方法中：
  可以访问静态的属性(属于类的)，但是不能直接访问非静态的属性(属于对象的)。
  可以访问静态的方法(属于类的)，但是不能直接访问非静态的方法(属于对象的)。
  
结论：静态方法中，不要涉及对象的内容：对象的属性(成员变量)，对象的方法(成员方法)，包括this和super关键字。

非静态方法中：属于对象
  全都行：静态的，非静态的都可以。this，super都可以。

应用：尽可能的将一个方法设计为静态的，但是如果方法中涉及到了对象的内容：对象的属性，对象的方法，以及this和super关键字。那么这个方法就不不能是静态的了。只能是非静态的。

示例代码：

package com.qf.demo03_static;


public class Person {//50人，49个男生，1个女生
  //成员变量：随着对象的创建而产生的。每个对象都有自己的一份属性值，和其他的对象的数值是无关的。
  String name;//属于对象？什么时候产生？
  int age;
  
//  String sex;//咱班巧了，都是男生。。
  static String city;//该类的对象，属性值，恰巧都相同。
  
  
  //打印对象的属性信息
  public void showInfo(){
    System.out.println("姓名："+this.name+",年龄："+age+",城市："+city);
  }
  
  //1.测试静态的成员方法
  public static void test1(){//属于类
    //1.在静态方法中，不能访问非静态的属性：因为non-static的属性，属于对象的，此时可能没有对象。
//    System.out.println("name:"+name);//Cannot make a static reference to the non-static field name
//    System.out.println("age:"+age);
    //2.在静态方法中，可以直接访问静态的属性：因为都属于类，随着类的加载而产生。
    System.out.println("city:"+Person.city);
    
    //3.在静态方法中，访问其他的静态方法：因为都属于类，
    Person.test2();//可以省略类名
    
    //4.在静态方法中，不可以访问非静态的方法：因为non-static的方法，属于对象的，由对象调用。
    //test3();//Cannot make a static reference to the non-static method test3() from the type Person
    
    //5.this和super这两个关键字，语法层面上，不能出现在static方法中。
    
  }
  
  public static void test2(){//静态方法，属于类的，类调用
    System.out.println("静态的方法test2()。。");
    Person p1 = new Person();
    System.out.println(p1.name);//?
    System.out.println(p1.age);//?
//    p1.test3();
  }
  
  
  
  public void test3(){//非静态方法，属于对象的，对象调用
    System.out.println("非静态的方法。。test3()");
    //1.非静态方法属于对象的，可以直接访问非静态属性，因为也是属于对象。
    System.out.println("name:"+this.name);//可以访问非静态的属性，
    System.out.println("age:"+this.age);//
    
    //2.非静态方法，可以调用静态的属性，属于类的。
    System.out.println("city:"+Person.city);//
    
    //3.非静态方法，可以直接访问其他的非静态方法吗？可以的。都是对象的。
    this.showInfo();
    
    //4.非静态方法，可以直接访问静态的方法吗？可以的。
    test2();//?
    
  }

}
package com.qf.demo03_static;

public class Test4_Person {

  public static void main(String[] args) {
    //创建对象
    Person p1 = new Person();
    p1.name = "王二狗";
    p1.age = 18;
    Person.city = "北京";//The static field Person.city should be accessed in a static way
    p1.showInfo();
    
    Person p2 = new Person();
    p2.name = "李小花";
    p2.age = 17;
    Person.city = "北京";
    p2.showInfo();
    
    //...以上已经创建了50个对象，都来自北京。。。
    Person.city = "上海";
    p1.showInfo();
    p2.showInfo();//?
  }

}

所以，static修饰的方法：

1、静态方法推荐使用类名直接调用。【强烈推荐】
  不推荐使用对象来调用，但是对象也可以调用
2、静态方法中，不能访问对象的内容，对象的成员变量，对象的成员方法。
3、静态方法中，不能出现this和super关键字。语法级别的要求。
4、静态方法中，可以访问静态的属性，以及其他的静态的方法。
5、静态方法中，可以通过new关键字来创建对象。
6、子类可以继承父类的静态方法，但是不能重写。

【扩展】类加载

类加载就是第一次调用这个类的时候，需要通过classpath找到类的.class文件。将class文件中类的信息描述加载到内存中。

比如：包名，类名，父类，属性，方法。。。

加载类时机：

创建对象
创建子类对象
访问静态属性
访问静态方法
主动加载：Class.forName("包名.类名");

3.4 static修饰代码块

代码块：一块代码。以{}为范畴。

1、局部代码块，就是普通的代码块，{}。注意点：作用域

if语句：if(条件){。。。。}

if，for，while，do-while，switch-case。。。{}

2、构造代码块：类里，方法外的代码块。

执行时机：当构造方法被调用的时候，构造代码块就执行。而且是优先于构造方法执行的。如果创建多个对象，就执行多次。

应用：可以为非静态的属性进行统一赋值。

3、静态代码块：在代码块前加static关键字。

执行时机：初始化程序，只要类文件加载，静态代码块就会被执行。仅执行1次。在main函数之前执行。。

应用：可以为静态属性进行赋值。

4、同步代码块：多线程

示例代码：

package com.qf.demo01_statci_;

public  class Test1Static {
  
  String name = "无名";//null
  int age = 18;//0
  
  static String city;
  
  {
    System.out.println("构造代码块。。。可以给成员属性统一赋值");
    name = "无名";
    age = 18;
  }
  
  static{
    System.out.println("静态代码块了，只执行1次。。。。");
    city = "武汉";
  }
  public Test1Static(){
    System.out.println("构造方法。。。");
  }
  
  
  public static void main(String[] args) {
    {
      System.out.println("局部代码块,就是一块代码，注意作用域。。。");
      int i  = 30;
      System.out.println(i);
    }
//    System.out.println(i);
    /*
     * if(){}
     * if(){}else{}
     * for(){}
     * while(){}
     * do{}while()
     * swich(){case}
     */

    int n = 10;
    if(n > 0){//局部代码块。。注意作用域
      System.out.println("n是正数。。。");
      int a = 20;
      System.out.println(a);
    }
//    System.out.println(a);//超出了作用域，无法使用
    
    
    Test1Static t1 = new Test1Static();//调用构造方法，创建对象
    Test1Static t2 = new Test1Static();
    System.out.println(t1.name+","+t1.age);
    System.out.println(t2.name +","+t2.age);
    System.out.println(Test1Static.city);
  }
}