JAVA入门小小白学习中ing(abstract关键字、final关键字、static关键字)

小猪学习

小小白慢慢学习中ing 第十五天

努力努力

---

本日内容（abstract关键字、final关键字、static关键字）

1、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关键字，普通类不需要。

        构造方法：都有，但是抽象类不能被实例化，普通类可以。

成员方法：

        抽象类中 ，可以是抽象的，也可以是普通的。

        普通类中，不能有抽象方法，只能是普通方法。

成员变量：都有

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

2、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 最终类{

        }

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

final修饰的方法，不让子类重写。

abstract修饰的方法，要求子类必须重写。

所以final和abstract不能同时修饰一个方法，会疯掉的。

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

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

3、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关键字。那么这个方法就不不能是静态的了。只能是非静态的。

所以，static修饰的方法：

        1、静态方法推荐使用类名直接调用。【强烈推荐】

        不推荐使用对象来调用，但是对象也可以调用

        2、静态方法中，不能访问对象的内容，对象的成员变量，对象的成员方法。

        3、静态方法中，不能出现this和super关键字。语法级别的要求。

        4、静态方法中，可以访问静态的属性，以及其他的静态的方法。

        5、静态方法中，可以通过new关键字来创建对象。

        6、子类可以继承父类的静态方法，但是不能重写。

---

希望我能坚持住每天坚持记录着 ...