面向对象特殊语法

构造方法

1. 构造方法定义的格式
   1)方法名固定，和类名相同；
   2)构造方法没有返回值，也不用声明方法返回值类型
   public 类名(形参列表) { }
2. 构造方法的使用：在new对象的时候使用
   new 类名(实参列表)
3. 注意事项
   1)构造方法可以重载
   2)jvm会给没有定义构造方法的类，自动添加默认构造方法（无参构造方法），而如果类中已经定义了构造方法，此时jvm就不会给该类，自动添加无参构造方法了
   3)构造方法的执行时机是，在创建对象的最后一步执行

this关键字

1. this：表示当期对象的引用（地址）
   1)this出现在构造方法中，this指代的当前对象，就是构造方法执行时，正在创建的那个对象
   2)this出现在成员方法的方法体中
   对于成员方法，只能通过 对象名.方法 去访问（调用）该方法
   所以，在哪个对象上调用该方法，该方法本次运行时的当前对象，就是哪个对象
2. this关键字的作用：
   1)解决成员变量的隐藏的问题
   2)访问对象的成员（包括成员变量和成员方法）
   3)访问对象的构造方法 this(实参列表)
   只能在构造方法的方法体中，利用this调用其他方法
   必须在构造方法方法体的，第一条语句的位置，利用this调用其他构造方法

static关键字

1. static关键字修饰成员变量和成员方法
2. static关键字的特点：
   1)被类的所有对象所共享（判断是否使用static的关键）
   static修饰成员变量，该成员变量的值，就不在存储于对象中了，而是，单独存储了一份，被类的所有对象所共享
   当static修饰成员方法的时候，该方法被当前类的所有对象共享，当前类对象.方法（和普通成员方法从共享的角度，几乎没太大区别）
   2)可以通过类名访问
   可以通过类名直接访问，static成员变量的值
   直接通过类名直接调用，static成员方法
   语法：
   类名.静态变量;
   类名.静态方法（实参列表）;
   3)随着类的加载而加载
   static成员变量，随着类加载过程，其实就已经在方法区中，分配了内存，并赋予默认初值
   static成员方法，一旦类加载完毕，我们就可以直接访问，static方法（通过类名. ）
   4)优先于对象而存在（不依赖于对象而存在）
   static成员变量，只要类加载完毕，就可以访问（即使此时还未创建对象）
   static成员方法，一旦类加载完毕，我们就可以直接访问，而不必等待创建对象之后再访问
3. static关键字的注意事项
   1)静态上下文中（静态方法的方法体），无法访问非静态的成员变量或成员方法
   只是无法访问当前对象的普通成员变量，和在当前对象上调用普通成员方法
   但是，我们可以在静态方法中，在我们自己创建出的对象上，访问其普通成员变量或普通成员方法
   2)静态上下文中（静态方法的方法体），只能直接访问静态成员变量或者静态成员方法
4. 使用场景
   1)当我们希望，某个成员变量的值，被该类的所有对象所共享，此时可以使用static修饰这个普通成员变量
   2)通常当我们需要定义一个方便被别人使用工具方法的时候，此时可以将该方法定义成静态方法

静态成员变量和普通成员变量

1. 所属不同
   1)静态变量属于类，所以也称为类变量
   2)成员变量属于对象，所以也称为实例变量（对象变量)

2. 内存中的位置不同
   1)静态变量存储于方法区
   2)成员变量存储于堆内存

3.内存出现时间不同

1. 静态变量随着类的加载而加载，随着类的消失而消失
   2)成员变量随着对象的创建而存在，随着对象的消失而消失

4. 访问方式不同
   1)静态变量可以通过类名访问，也可以通过对象访问
   2)成员变量只能通过对象名访问

代码块

1.代码块：在Java中，使用{}括起来的代码被称为代码块
2.根据其位置和声明的不同，代码块分成如下几种：
局部代码块、构造代码块、静态代码块、同步代码块（在多线程部分）
3. 局部代码块
1)声明位置在方法体中，声明方式{}
2)执行时机，随着其所在方法的执行而执行
4. 构造代码块
1)声明位置：定义在类中方法体之外，声明方式{}
2)执行时机：在每次其所在类的对象创建的时候执行
3)注意事项
a.关于执行时机
构造方法 VS 构造代码块：构造代码块 先于 构造方法执行
构造代码块 VS 成员变量的初始化语句 执行的先后顺序：取决于它们定义的先后顺序
b.使用场景
利用构造代码块，在创建对象的时候给对象的该成员变量赋初值
多个构造方法方法中都需要执行一段相同的代码，我就可以把这些代码放在构造代码块中
5. 静态代码块
1)声明位置：类中方法体之外，声明方式:static{}
2)执行时机：随着类加载而执行，在一个jvm中至多执行一次
3)注意事项：
a.一个静态代码块，也是一种static context静态上下文使用场景
b.使用场景：当代码在整个程序运行过程中，只需要执行一次，这样的代码，我们就可以放在静态代码块

包

1. java语言中的包，可以类比于操作系统中的文件夹，文件夹用来组织文件，包用来组织类

2. 而且，包还可以解决命名冲突的问题，不同包中可以定义同名类

3. 在Java源程序文件的第一行使用package声明可以使文件中定义的类成为指定包的成员
   package 包名;

4. 包名通常由多个字符串构成，中间用句点“.”分隔，即多级包名。多级包名中的每一级，也都可以表示一个包，后一级是前一级的子包
   习惯上，以组织机构的域名反转形式来定义包名，比如：com.cskaoyan

5.没有用package关键字定义包名的java文件中的类，属于java语言中的默认包

import

1.在不同包中，可以定义同名类，那如何唯一确定一个类呢？
在类名前面加上类所属的包名，中间用句点“.”分隔，称为类的完全限定名简称为全类名
2.当在类体中使用了与当前类不同包的类名时，编译器编译时因为无法找到该类的定义而失败，有两个解决办法：
使用不同包类的完全限定名
使用import声明，为编译器提供该类的定义信息
3.import声明一般紧跟在package声明之后，必须在类声明之前，其基本语法如下：
import <类的完全限定名>
4.注意事项
a.Java语言核心包java.lang包中的类将被隐式导入，可以直接使用其中的类
b.import声明提供了一种包的智能导入方式 （import <包名>.**）
包中的类将根据需要*导入，避免使用多条import声明
但是注意，智能导包方式，并不会递归导入，子包中的类

面向过程思想

所谓面向过程的编程思想，简单理解，程序是“动词”的集合，即程序功能是由一系列有序的动作来完成（方法调用）

面向对象的编程思想

1.所谓面向对象的编程思想，简单理解，程序是由一系列的对象和对象间的交互组成，即程序是由一系列的对象和对象间的消息组成
*举例：*把大象放入冰箱
2.面向对象中，对象的消息
当我们在某个对象上，调用其成员方法，我们就说我们给该对象发送了一条消息

面向对象和面向过程的比较

1.结构化程序设计：
对应的典型的计算机语言，例如：C
面向操作的
函数（方法）是程序的基本单位
2.面向对象程序设计
对应的典型的计算机语言，例如：Java、C++、C#
面向*对象（object）*的（运行中的程序）
类是代码的基本单位

面向对象02

访问权限

1.在Java语言中，一切事物都具有(或显示定义或隐式定义的)访问权限，而这种语言层面的访问控制权限，是由访问权限修饰符来定义的
2.访问权限的定义分成了2种
定义类中的成员的访问权限，即控制类中成员是否能被其他人访问到（控制类中成员的可见性）
定义类的访问权限，即控制其他人是否能访问到该类（即控制类的可见性）
3.类中成员的访问权限
a. public: 任意类均访问，实际就是没有限制访问权限
b. protected: 同包中的其他类，和不同包的（可见）子类均可见
c. 默认权限，隐式定义: 仅同包中的其他类可见
d. private: 仅对同类中的其他成员可见

	public	protected	默认	private
同一类中	√	√	√	√
同一包子类，其他类	√	√	√
不同包子类	√	√
不同包其他类	√
4.能够修饰类的访问权限修饰符只有2种：

public：对其他任意类可见
default：对同包中的其他类可见

5.为什么要使用访问控制修饰符？private
使用户不要触碰他们“不该”触碰的代码（private）
类库设计者可以安全的修改实现细节

封装

1.封装是一种信息隐藏技术
是指将数据和基于数据的操作封装在一起
数据被保护在内部（结合访问权限）
系统的其他部分只有通过在数据外面的被授权的操作才能进行交互
目的在于将类使用者class user和类设计者class creator分开
2.在定义类中定义的私有成员变量，如果有时，由需要在其他类中访问怎么办？ get/set方法
get方法：具有public访问权限的，用来获取成员变量值得方法。（xxx指目标成员变量名）

public 成员变量数据类型 getXxx() {
		return xxx;
}

set方法：具有public访问权限的，用来修改成员变量值的方法。（xxx指目标成员变量名）

public void setXxx()	{
		...
		this.xxx = 参数；
}

注意，针对boolean类型的私有成员变量比如a,其get方法也可以命名为

public 成员变量数据类型 isA{}

3.get/set方法的好处：
通过get，set方法，可以获取/修改对象的私有成员变量值
通过get，set方法，完成对成员变量的访问的读，写分离
正是因为，外部只能通过get，set方法来访问私有成员变量，可以以这种方式控制外部，对成员变量值访问

继承

1.被继承的类称之为父类（基类或超类），继承其他类的类称之为子类（派生类，导出类）
2.语法： class 子类名 extends 父类名 {}
3.继承的优点：
实现代码复用
提高代码的可维护性
“弱化”java语言中的类型约束

XX 对象名 = new XX();  // 在学习继承之前，创建什么样的对象，就得用什么样的引用变量接收
父类型类 对象名 = new 子类类型();// 在学习继承之后，可以用父类引用指向子类对象，因为一个子类对象可以被看做是一个父类对象

4.继承的缺点：
对于父类的修改，会出现在其所有的子类中
5.继承的注意事项
子类只能访问父类所有非私有的成员（成员方法和成员变量）
子类不能继承父类的构造方法

子类对象的初始化

1.java语言的结论是，一定是先初始化子类对象中，继承自父类的成员变量的值，后初始化子类对象中，子类自己定义的成员变量值，即先父后子（子类对象中，子类成员变量值的初super始化过程有可能依赖于父类成员变量的值，所以有先父后子的顺序）
2.如何实现在子类对象中，先父后子的成员变量值的初始化顺序呢？
首先，构造方法本身的功能，就是初始化对象成员变量值的
所以，显然，我们只需要保证，父类的构造方法，先于子类的构造方法运行
只需要在子类的构造方法第一条语句的位置，先调用父类的构造方法
3.根据实现子类对象中成员变量值，先父后子的初始化顺序方式的不同
子类对象的 隐式 初始化方式(jvm来自动保证父类构造方法先执行)
子类对象的 显式 初始化方式(coder,通过写代码的方式保证，父类构造方法先执行)
4.子类对象的隐式化 需要满足：
当父类提供了默认的构造方法
且子类的构造方法中没有显示调用父类的其它构造方法
则在执行子类的构造函数之前会自动执行父类的构造函数
5.子类对象的显式初始化
只要在子类构造方法的第一条语句的位置，显式调用父类的构造方法，初始化父类中定义的成员变量值
6.如何在子类构造方法中调用父类的构造方法呢？ 使用super关键字
super关键字：代表父类对象的引用 this关键字：表示当前对象的引用
super 访问继承自父类的成员变量的值 this访问 当前对象的成员变量值
super 访问继承自父类成员方法 this访问 当前对象的成员方法
super 调用父类中定义的构造方法 this调用 当前类中定义的构造方法
super(实参列表) this(实参列表)
注意：
1)必须保证，子类每个构造方法，都要满足子类对象的初始化流程
2) 在子类构造方法中，通过super调用父类构造方法时，该super语句必须出现在，子类构造方法第一条语句的位置
3)父类成员变量初始化语句和构造代码块都，优先于子类中成员变量的初始化语句和构造代码块执行
7.父类域(Field)的隐藏
1)在子类中是否可以定义和父类同名的成员变量–可以定义
2)如果可以，
a.那么在子类中访问这个同名变量，究竟访问到的是父类中定义的成员变量的值，还是子类中定义的成员变量的值？
–在子类类体中，通过同名变量的变量名，只能访问到子类中定义的同名成员变量的值
b.如果在父类中访问呢?
–访问到的是父类中定义的同名成员变量的值
3)是否可以在子类中，同时访问到子类和父类中定义的同名成员变量的值–可以
–可以，如果要在子类中访问到，继承自父类的同名成员变量的变量值，利用super（super.同名成员变量的变量名）
8.父类域(Field)的隐藏
如果在子类中，定义了和父类同名的成员变量
在子类类体中，通过同名成员变量的变量名，访问到的是，子类中定义的同名成员变量值
看起来，就好像父类成员变量，在子类中，被隐藏起来了
总结，访问规律：
1)通过同名成员的变量名，访问父类和子类定义的同名成员变量值
a.如果是在父类的方法中，访问同名成员变量，访问到的就是父类的成员变量值
b.如果是在子类的方法中，访问同名成员变量，访问到的就是子类的成员变量值
2)如果，我们在子类对象上，对象名.成员变量名 的方式来访问
a.先在子类对象，子类自己定义的成员变量中去找，找到就访问
b.如果没找到，就继续去父类对象中，相应的成员变量，找到就访问

方法的覆盖或重写(override)

1.子类中能否定义和父类一模一样的方法？
可以
2.如果可以，
a.那么在子类中访问这个一模一样的方法，究竟访问到的是父类的方法，还是子类中的方法？ 访问到的是子类中定义的“一模一样”的方法b.在父类中访问到的还是子类中定义的一模一样的方法(就好像父类中定义一模一样的方法，被子类中定义的“一模一样”的方法给覆盖掉)
3.是否可以在子类中,同时访问到子类和父类中的一模一样的方法？
当然可以，在子类方法体中，利用super关键字即super. 方法，调用到父类中定义的一模一样的方法
4.方法的覆盖或重写
如果子类中定义了和父类“一模一样”的方法
那么在子类对象上，不论调用父类中或是子类中的方法去访问这个“一模一样”的方法
访问到的都是子类中定义的“一模一样”的方法，就好像父类中的那个“一模一样”的方法被覆盖掉了
5.访问规律
当在子类对象上，通过调用父类或子类的方法，去访问那个父类子类中“一模一样”
无论是调用父类方法，或者是子类自己定义的方法，访问到的都是子类中那个“一模一样”的方法
当我们在子类对象上，通过对象名. 的方式访问成员方法
jvm先在子类中找，如果找到了就访问子类中定义的方法
如果子类中，没找到，再去父类中找
6.方法覆盖的条件
是否子类中必须定义和父类完全一模一样(方法声明)的方法才能实现方法覆盖的效果呢----------不是
子类和父类方法的访问权限不必完全相同，只要保证，子类方法访问权限 >= 父类方法的访问权限
父类方法 子类方法
void accessMethod() {} public void accessMethod() {}
如果方法返回值类型是引用类型，子类方法返回值类型，可以和父类方法返回值类型不同，但必须是父类返回值类型的子类类型
父类方法 子类方法
A returnMethod() {} B returnMethod() {}
class B extends A {}
7.方法覆盖的使用场景
当我们需要在子类中，修改父类方法的实现的时候，可以利用方法覆盖，在子类中修改父类方法的实现
8.方法覆盖的注意事项
父类中私有方法不能被重写
静态方法不能被重写

final

1.final是最终的意思，可以修饰类，变量，成员方法
修饰类，类不能被继承
修饰方法，方法不能被重写(override)
修饰变量，变量就变成了常量，只能被赋值一次
final修饰局部变量，必须保证，在使用之前赋值一次，而且只能赋值一次
final修饰成员变量，必须保证，在创建完对象之前，必须自己给final修饰的成员变量赋一次初值
且仅一次(不考虑jvm默认赋值那一次赋值)
2.注：一旦成员变量被final修饰，且我们是通过构造方法给该成员变量赋初值，一定要保证，每个构造方法都需要给该成员变量赋初值

多态

1.Java中的多态：“同一个对象”的行为，在不同的时刻或条件下，表现出不同的效果
2.多态的发生前提条件
继承
方法覆盖
父类引用指向子类对象
3.多态下的成员访问特征
成员变量：编译看左边，运行看左边
编译看左边，这里的左边是指赋值符号的左边
运行看左边，
一个对象 属性(成员变量) 和 行为，一个对象的属性(成员变量表示)，表示了一个对象的外貌
在多态中，对于子类对象而言，把子类对象赋值给父类类型的引用，就相当于给子类对象披上了一个父类类型马甲
因此，该子类对象看起来，就像是一个父类对象(外貌特征表现出的就是父类的外貌特征)
所以，访问到的是父类的同名属性值
成员方法：编译看左边，运行看右边
对于成员方法的，运行(结果)看 右边(多态)
对于成员方法而言，通过引用变量，实际访问到的行为(方法)，是由引用实际指向的对象来决定的
4.多态的优点：
提高了程序的维护性(由继承保证)
提高了程序的扩展性(由多态保证)
5.多态的弊端：
不能访问子类特有功能
6.引用变量的类型转化
前提：针对的有父子关系的，引用变量的类型的转化
父类类型的引用 <--------> 子类类型的引用
1)将子类引用——>父类引用 引用变量的向上转型，编译器默认允许
Duck duck = new Duck()
Animal animal = duck;
2)父类引用 子类引用 称之为向下转型 编译器默认是不允许
目标引用类型 目标引用变量 = (强制转化的目标引用类型)带转化的引用变量
Duck duck = (Duck)Animal
7.可以利用instanceof运算符，判断一个对象所属的实际类型
引用变量 instanceof 目标类型
instanceof就可以帮我们判断，引用变量所指的对象，是否是 目标类型的 对象
如果是，则运算结果是true
如果不是，则运算结果是false
null instanceof 任何类型 结果固定 false