JAVA笔记(三)---封装、继承和多态

面向对象的三大特征：
封装、继承、多态

封装

封装的好处：
封装之后，将复杂的事情封装到内部，外部只需要做简单的操作，类似照相机。
封装之后的对象，可以更好的重复使用
封装提高了安全性

封装的步骤：
所有属性私有化，使用private关键字进行修饰，被private修饰的数据只能在本类中访问。
对外提供简单的操作入口，也就是想要访问age属性，必须通过这个入口进行访问：
对外提供两个公开方法，get和set方法
读取属性值，使用get方法
修改属性值，使用set方法

set命名规范：
public void setAge(int a)
{
age = a;
}

set方法没有返回值

get命名规范
public int getAge()
{
return age;
}

setter 和 getter方法没有static关键字
有static关键字修饰的方法怎样调用：类名.方法名(实参)
没有static关键字修饰的方法怎样调用：引用.方法名(实参)

构造方法

构造方法又被称为构造函数/构造器/constructor

普通方法语法结构：
[修饰符列表] 返回值类型 方法名(形式参数列表){
方法体;
}

构造方法语法结构：
[修饰符列表] 构造方法名(形式参数列表){
构造方法体;
}

构造方法没有返回值类型
如果将构造方法里面，添加上返回值类型，则成为普通方法。

构造方法虽然没有明显写返回值，但是，里面其实是为我们自动添加了一个返回值，且该返回值的类型是该类的类型。

对于构造方法来说，构造方法名必须和类名相同。

普通方法的调用：
方法修饰符中有static：类名.方法名(实参列表)
方法修饰符中没有static：引用.方法名(实参列表)

构造方法的调用：
new 构造方法名(实参列表)

当一个类中没有定义任何构造方法，系统会默认给该类提供一个无参数的构造方法。这个构造方法被称为缺省构造器。

当一个类中，自定义了构造方法，系统不会默认再给该类提供构造方法。建议在开发中，手动创建一个无参数的构造方法。

构造方法的作用：
1 创建对象
2 给实例变量赋值

---

this关键字

this是一个关键字
this是一个引用，this是一个变量，this变量中保存的地址是自身的地址。
this存储在JVM堆内存java对象内部。
每个对象都有一个this
this可以出现在"实例方法"当中，代表当前正在执行这个动作的对象
this不能使用在带有static的方法当中

没有static关键字修饰的方法被称为：实例方法
没有static关键字修饰的变量被称为：实例变量

按照OC的逻辑：
static是类对象
没有static是对象

static静态变量

static静态变量，在类加载的时候初始化，不需要创建对象，内存就开辟了。
静态变量存储在方法区内存

static修饰的所有元素都是类级别的特征，和具体的对象无关。

什么时候声明为实例变量？（没有static）
所有对象都有这个属性，但这个属性的值会随着对象的变化而变化。

什么时候声明为静态变量？（有static）
所有对象都有这个属性，且这个属性的值都是一样的，则建议定义为静态变量，减少内存开销。

所有静态数据，都可以使用类名.方式访问，也可以使用引用.方式访问。建议采用类名.方式访问

使用引用.方式访问的，最终还是类名.方式访问。
即使引用是null，也不会报空指针异常，因为，访问静态变量不需要对象的存在。

静态代码块

可以使用static关键字来定义 静态代码块

语法格式：
static {
java语句;
}

静态代码块在类加载的时候执行，并且只执行一次。

静态代码块在一个类中可以编写多个，并且从上往下按序执行。

静态代码块的作用？
静态代码块是在类加载的时候调用，因此，我们可以在类加载的时候，在静态代码块中做一些操作。

静态方法

什么时候将方法定义为静态方法？
当方法不依赖于对象，是模板级的动作，可以定义为静态方法

静态方法中，无法直接访问实例变量和实例方法

继承

继承的基本作用：代码复用
继承有更重要的作用：有了继承才有以后的方法覆盖和多态。

继承的语法格式：
[修饰符列表] class 类名 extends 父类名{
类体;
}

java语言中的继承只支持单继承，一个类不能同时继承很多类，只能继承一个类。

B类继承A类，则：
A类称为：父类、基类、超类、superclass
B类称为：子类、派生类、subclass

java语言中，子类继承父类都继承哪些数据？
私有的不支持继承
构造方法不支持继承
其他数据都支持继承

java中所有的类，都继承JavaSE库中的java.lang.object类

方法覆盖又被称为方法重写：override
当父类的方法不能够满足子类的需求的时候，会选择使用方法覆盖，子类方法覆盖掉父类的方法。

方法重写的时候：返回值类型相同、方法名相同、形参列表相同
方法重写的时候：访问权限不能更低，可以更高

私有方法不能继承，所以不能覆盖。
构造方法不能继承，所以不能覆盖。

多态

小例子：
Animal类
Cat继承Animal
Bird继承Animal

几个概念：
向上转型(upcasting)：子转父类型
向下转型(downcasting)：父转子类型

转型的前提是：两者有继承关系

Animal a = new Cat();
等号右边是Cat对象
等号左边是Animal

将子类赋值给父类，子类转换为父类型。

a.move();
最后运行的方法是猫里面的方法。

这就跟OC一样了，编译时没事，运行时还是看真正的类型。

Animal a1 = new Bird();
Cat c1 = (Cat)a1;//编译阶段可以通过，但是运行的时候不能通过
因为，a1运行后是Bird，Bird与Cat没有继承关系，因此，无法强转。

向上转换，只要编译通过，运行就没有问题。
向下转换，编译通过，运行也有可能出问题。

可以使用instanceof运算符避免以上异常

instanceof

instanceof语法格式：

引用 instanceof 数据类型名

以上运算符的执行结果类型是布尔类型。

a instanceof Animal
true：a这个引用，指向的对象是一个Animal类型
false：a这个引用，指向的对象不是一个Animal类型

Animal a1 = new Bird();
Cat c1 = (Cat)a1;

使用instanceof优化：
Animal a1 = new Bird();
if(a1 instanceof Cat)
{
	Cat c1 = (Cat)a1;
}

final关键字

final：最终的，不可变的
final修饰的类无法被继承
final修饰的方法无法被覆盖
final修饰的变量一旦赋值之后，不可重新赋值
final修饰的实例变量，必须手动赋值，不能采用系统默认值
final修饰的引用，一旦指向某个对象之后，不能再指向其他对象。被指向的对象不能被垃圾回收器回收
final修饰的实例变量，一般和static联合使用，被称为常量。

final User u = new User();
u = new User();//错误，不可以重新赋值

public static final 类型 常量名 = 值;

感觉跟const差不多

package和import

package包，java中引入package主要是为了方便程序管理。
不同功能的类，放在不同的包里面，查找比较方便，易维护。

java程序的第一行上编写package语句。
且，只能编写一个package语句

语法结构：
package 包名;

包名的命名规范：
公司域名倒序+项目名+模块名+功能名
该方式重名几率比较低

包名必须全部小写，包名也是标识符，因此，需要遵循标识符的命名规则。

一个包对应一个目录

现有

package com.baidu.javase.day01;

public class Test01
{
	public static void main(String[] args)
	{
		System.out.println("你好");
	}
}

则，此时的类名不再是Test01
而是：com.baidu.javase.day01.Test01

两个类在同一个包下，则，类名前的包名可以省略

也就是，不在同一个包的两个类，类名需要加上包名，这么一长串，太麻烦了

然后，引入了import

import用来导入其他包里面的类

import语法格式：
import 类名;
import 包名.* ；
import com.baidu.javase.day01.Test01;
import com.baidu.javase.day01.*

import语句需要编写在package语句之下，class语句之上

访问控制权限

访问控制权限修饰符来控制元素的访问范围

访问控制权限修饰符可以修饰：类、变量、方法

访问控制权限修饰符包括：
public 表示公开的，在任何位置都可以访问
protected 表示受保护的，可以在同包、子类访问
缺省 表示缺省的，可以在同包中访问
private 表示私有的，只能在本类中访问

public > protected > 缺省 > private

---

只学了基础课，进阶班有300多个视频，就不看了，转战数据结构！加油💪