【JAVA基础】 面向对象

1. 面向过程就是分析解决问题所需要的步骤，然后用函数把这些步骤一一实现，使用的时候一个一个依次调用就可以了。
   面向对象则是把解决的问题按照一定规则划分为多个独立的对象，然后通过调用对象的方法来解决问题。（封装、继承、多态）

2. 当对象被实例化后，在程序中可以通过对象的引用变量来访问该对象的成员。需要注意的是，当没有任何变量引用这个对象时，它将成为垃圾对象，不能再被使用。

   除了等待java虚拟机进行自动的垃圾回收，也可以通过调用System.gc()方法来通知java虚拟机立即进行垃圾回收。当一个对象在内存中被释放时，它的finalize()方法会被自动调用，因此可以在类中通过定义finailize()方法来观察对象何时被释放。

---

3. 构造方法满足
   （1）方法名与类名相同。
   （2）在方法名的前面没有返回值类型的声明。
   （3）在方法中不能使用return语句返回一个值。

4. 在Java中的每个类至少有一个构造方法，如果在一个类中没有定义构造方法，系统会自动为这个类创建一个默认的构造方法，这个默认的构造方法没有参数，在其方法体中没有任何代码，即什么也不做。一旦为该类定义了构造方法，系统就不再提供默认的构造方法了。

5. 一个类中如果定义了有参的构造方法，最好再定义一个无参的构造方法。

6. 构造方法是在实例化对象时被Java虚拟机自动调用的，在程序中不能像调用其他方法一样去调用构造方法，但可以在一个构造方法中使用“this(参数1，参数2，……)”的形式来调用其他的构造方法。

7. 在使用this调用类的构造方法时，应注意以下几点：
   （1）只能在构造方法中使用this调用其他的构造方法，不能再成员方法中使用。
   （2）在构造方法中，使用this调用构造方法的语句必须位于第一行，且只能出现一次。
   （3）不能在一个类的两个构造方法中使用this互相调用。

8. 构造代码块：给对象进行初始化。
   （1）对象一建立就运行，且优先于构造函数执行。
   （2）构造代码块是给所有对象进行统一初始化，而构造函数是给对应的对象初始化。
   （3）不同构造函数中共同的部分完全可以放在构造代码块中。
   （4）构造代码块中定义的是不同对象共性的初始化内容。

---

9. 静态static：是一个修饰符，用于修饰成员（成员变量，成员方法），被修饰的成员是被共用的。当成员被静态修饰后，就多了一个调用方式，除了可以被对象调用外，还可以直接被类名调用，写法：类名.静态成员。
   静态被放在方法区(或者说共享区，静态区)

10. 静态的特点：
    静态随着类的加载而加载（随着类的消失而消失），说明生命周期最长，对内存消耗比较大（静态的成员变量，即类变量，区别于成员变量，即实例变量）。
    （1）优先于对象而存在：静态先存在，对象后存在
    （2）被所有对象所共享
    （3）可以直接被类名所调用

11. 实例变量和类变量的区别：
    （1）存放位置：
    类变量随着类的加载而存在于方法区中，
    实例变量随着对象的建立而存在于堆内存中。
    （2）生命周期：
    类变量生命周期最长，随着类的消失而消失
    实例变量生命周期随着对象的消失而消失。

12. 静态使用注意事项
    （1）静态方法只能访问静态成员
    （2）非静态方法既可以访问静态也可以访问非静态
    （3）静态方法中不可以定义this，super关键字
    （4）因为静态优先于对象存在，所以静态方法中不可以出现this

13. 静态有利有弊
    利：（1）对对象的共享数据进行单独空间的存储，节省空间。没有必要每一个对象中都存储一份。（2）可以直接被类名调用
    弊端：（1）生命周期过长（2）访问出现局限性（静态虽好，但只能访问静态）

14. static关键字只能用于修饰成员变量，不能用于修饰局部变量。

15. 在一个静态方法中只能访问用static修饰的成员，原因在于没有被static修饰的成员需要先创建对象才能访问，而静态方法在被调用时可以不创建任何对象。

16. 当类被加载时，静态代码块会执行，由于类只加载一次，因此静态代码块只执行一次。

17. 创建内部类对象的具体语法格式：

外部类名.内部类名 变量名 = new 外部类名().new 内部类名();

若内部类被声明为私有，外界将无法访问。

18. 创建静态内部类对象的具体语法格式：

外部类名.内部类名 变量名 = new 外部类名.内部类名();

静态内部类只能访问外部类的静态成员变量。
在静态内部类中可以定义静态的成员，而在非静态的内部类中不允许定义静态的成员。

19. 静态代码块 格式：

static｛ 静态代码块中的执行语句 ｝

特点：随着类的加载而执行，只执行一次，并且优先于主函数（无论new几次都是只执行一次，并且即使静态代码块放在main函数后面，也是静态代码块先执行）。用于给类进行初始化。

staticcode s = null；

诸如此类的情况类是没有被加载的
但凡用到了类中的内容，或者new，类才被加载

---

21. 方法内部类只能在方法中创建该类的实例对象。

22. java中，类只支持单继承，不允许多重继承，也就是说一个类只能有一个直接父类。

23. 在子类中重写的方法需要和父类被重写的方法具有相同的方法名、参数列表以及返回值类型。

24. 子类重写父类方法时，不能使用比父类中被重写的方法更严格的访问权限，如父类中的方法是public的，子类的方法就不能是private的。

25. 通过super调用父类构造方法的代码必须位于子类构造方法的第一行，并且只能出现一次。在子类的构造方法中一定会调用父类的某个构造方法。这时可以在子类的构造方法中通过super指定调用父类的哪个构造方法，如果没有指定，在实例化子类对象时，会自动调用父类无参的构造方法。

26. 为什么子类一定要访问父类中的构造函数？
    因为父类中的数据子类可以直接获取，所以子类对象在建立时，需要先查看父类是如何对这些数据进行初始化的
    所以子类在对象初始化时，要先访问一下父类中的构造函数
    如果要访问父类中指定的构造函数，可以通过手动定义super语句的方式来指定
    注意：super语句一定要定义在子类构造函数的第一行

27. 子类的实例化过程：
    结论：子类的所有的构造函数，（在没有定义super的情况下）默认都会访问父类中空参数的构造函数
    因为子类每一个构造函数内的第一行都有一句隐式super()
    当父类中没有空参数的构造函数时，子类必须手动通过super语句形式来指定要访问父类中的构造函数
    当然，子类的构造函数第一行也可以手动指定this语句来访问本类中的构造函数
    子类中至少会有一个构造函数会访问父类的构造函数
    this()和super()不能同时出现。

28. 定义一个类时，如果没有特殊需求，尽量在类中定义一个无参的构造方法，避免被继承时出现错误。

29. final
    （1）final修饰的类不能被继承
    （2）final修饰的方法不能被子类重写
    （3）final修饰的变量（成员变量和局部变量）是常量，只能赋值一次。

30. Java允许在定义方法时不写方法体，不包含方法体的方法为抽象方法，抽象方法必须使用abstract关键字来修饰。当一个类中包含了抽象方法，该类必须使用abstract关键字来修饰，使用abstract关键字修饰的类为抽象类。但抽象类可以不包含任何抽象方法，抽象类不可被实例化。

31. 接口：所有方法都是抽象的抽象类。
    接口中定义的方法默认使用"public abstract"来修饰，即抽象方法。
    接口中的变量默认使用"public static final"来修饰，即全局变量。

32. 一个类通过implements关键字实现接口时，可以实现多个接口。
    一个接口可以通过extends关键字继承多个接口。
    一个类在继承另一个类的同时还可以实现接口，此时，extends关键字必须位于implements关键字之前。

class Dog extends Canidae implements Animal{                      //先继承，再实现
	程序代码……
}

---

33. 将子类对象当做父类使用时不需要任何显式地声明，需要注意的是，此时不能通过父类变量去调用子类中的某些方法（子类中独有的方法）。

34. Java提供了一个关键字instanceof，它可以判断一个对象是否为某个类（或接口）的实例或者子类实例，语法格式：

对象（或者对象引用变量） instanceof 类（或接口）

35. 多态的前提：必须是类与类之间有关系。要么继承，要么实现
    通常还有一个前提：存在覆盖。

36. 多态的好处：大大提高程序的扩展性
    多态的弊端：提高了扩展性，但是只能用父类的引用访问父类中的成员

37. 多态的应用

public duoTaiDemo{
    public static void main(String args[]){
        Animal a = new Cat();//类型提升，向上转型
        //如果想要调用猫的特有方法时，如何操作？
        //强制将父类的引用,转成子类类型.向下转型。（必须new的时候是猫，不能Animal a = new Animal();然后向下转型。）
        Cat c = (Cat) a;
        c.catchMouse();
    }
}

千万不要出现这样的操作，就是将父类对象转成子类类型。我们能转换的是父类引用指向了自己的子类对象时，该引用可以被提升，也可以被强制转换

多态自始至终都是子类对象在做着变化

---

38. 内部类的访问规则：内部类可以直接访问外部类中的成员，包括私有
    之所以可以直接访问外部类中的成员，是因为内部类中持有了一个外部类的引用，格式：外部类名.this
    内部类可以私有。
    内部类的this是this，外部类的this在内部类中调用时，用作 Outer.this

39. static: 内部类就具备static的特性
    当内部类被static修饰后，只能直接访问外部类中的static成员，出现了访问局限。
    注意：当内部类中定义了静态成员，该内部类必须是static的
    当外部类中的静态方法访问内部类时，内部类也必须是static

40. 当描述事物时，事物的内部还是事物，该事物用内部类来描述 因为内部事物在使用外部事物的内容
    内部类定义在局部时：
    （1）不可以被成员修饰符修饰
    （2）可以直接访问外部类中的成员，因为还持有外部类中的引用
    但是不可以访问它所在的局部中的变量。只能访问被final修饰的局部变量。

41. 匿名内部类
    （1）定义匿名内部类的前提：内部类必须是继承一个类或者实现接口
    （2）匿名内部类的格式：new 父类或者接口（）｛定义子类的内容｝
    （3）其实匿名内部类就是一个匿名子类对象。而且这个对象有点胖。
    可以理解为带内容的对象。
    （4）匿名内部类中定义的方法最好不要超过三个，最好一个或者两个。

来源：CSDN

作者：_WWWZP

链接：https://blog.csdn.net/Nase_Mitsuki/article/details/94854823