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

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);
  }
}
​

 

四、作业

1、创建抽象类，表示形状。提供2个抽象方法，求周长，求面积。 子类：圆形，重写2个方法。考虑是否要新增属性。 子类：三角形：重写2个方法。考虑是否要新增属性。 子类：矩形：重写2个方法。考虑是否要新增属性。

以上形状的求面积公式，自行百度。