面向对象

面向过程思想： 所有的操作自己来完成 
面向对象思想： 找对象做事情，自己不做了


面向对象的思想特点：
符合我们的思维思考方式
执行者 转换成了 指挥者
将复杂的时间简单化了

面向对象使用方式：
没有对象，就创建对象，使用对象的功能
有对象，就拿过来，直接使用对象中的功能


-------------------------

类：在java中，是用来描述现实世界中的事物的属性与行为的集合
    它是一个抽象的概念
对象：就是类的具体化体现


类的定义：
使用 关键字 class 来定义java中的类
格式：
class 类名 {
}
如何创建对象：
格式： 类名 对象名 = new 类名();

---------------------------
成员变量与局部变量的区别？
成员变量： 在类中方法外，定义的变量
局部变量： 在方法中或者方法声明中定义的变量

位置区别：
成员变量： 在类方法外
局部变量： 在方法中或者方法声明中

内存中位置：
成员变量：堆内存中
局部变量：栈内存中

生命周期：
成员变量：随着对象的创建而存在，随着对象的消失而消失
局部变量：随着方法的调用而存在，随着方法执行完毕后消失了

初始化值：
成员变量： 有默认值
基本数据类型:
byte short int long  默认值0
float double 默认值 0.0
char 默认值 '\u0000' 空字符，相当于空格的效果
boolean 默认值 false
引用数据类型：
[] 数组： null
class类： null
interface接口： null

局部变量： 没有默认值，需要先定义变量，再赋值，最后使用

--------------------
匿名对象： 就是没有名字的对象
作用：
1，调用方法的时候，作为实际参数传递使用
2, 当方法仅调用一次，之后该对象不再使用了，这时候，用匿名对象合适
为什么呢？因为，当方法调用完毕后，该匿名对象就没有对应的引用了，该对象为垃圾
会由Java虚拟机中的垃圾回收机制，进行回收，这个回收的时间由JVM决定

------------------
封装： 把对象的属性与方法的实现细节隐藏，仅对外提供一些公共的访问方式


封装的体现：
变量:使用 private 修饰，这就是变量的封装
方法:也是一种封装，封装了多条代码
类： 也是一种封装，封装了多个方法
接口:也是一种封装，封装了多个方法的声明

---------------------
private : 关键字， 私有的意思
它可以用来修饰类中的成员(成员变量，成员方法)
注意： 也可以用来修饰成员内部类

private的特点：
private修饰的成员只能在当前类中访问，其他类中无法直接访问

---------------------
this : 关键字，本类对象的引用
this是在方法中使用的，哪个对象调用了该方法，那么，this就代表调用该方法的对象引用

this什么时候存在的？
当创建对象的时候，this存在的

this的作用：
用来区别同名的成员变量与局部变量
this.成员变量;
可以用来调用本类中其他的构造方法
this(..);

---------------------
构造方法： 用来给类的成员进行初始化操作

格式： 
修饰符 类名 (参数列表) {
...
}

构造方法的特点：
1, 方法名与类名相同
2，没有返回值，也没有返回值类型，连void也没有


构造方法什么时候会被调用执行？
只有在创建对象的时候才可以被调用

----------------------
方法的划分：
按照返回值划分：
有返回值的方法
没有返回值的方法
按照参数来划分：
有参数的方法
没有参数的方法
-----------------------
类的初始化过程：
Person p = new Person();
1，将Person.class 文件加载到内存中
2, 在栈空间中开辟一个空间，用来存储 Person类型 变量 p
3, 在堆内存中开辟一个空间，用来存储 new Person()对象中的成员信息
4, 为对象中的成员变量执行默认初始化操作
    String name = null;
5, 为对象中的成员变量执行显示初始化操作
String name = "小明";
6, 执行构造方法，通过构造方法为当前对象中的成员变量初始化赋值
7, 将new Person()的地址引用 赋值给 变量p

-----------------------
static : 关键字， 静态的意思
可以用来修饰类中的成员(成员变量，成员方法)
注意： 也可以用来修饰成员内部类

特点：
被静态所修饰的成员，会被所有的对象所共享
被静态所修饰的成员，可以通过类名直接调用，方便
Person.country = "中国";
Person.method();

注意事项：
静态的成员，随着类的加载而加载，优先于对象存在
在静态方法中，没有this关键字
静态方法中，只能调用静态的成员(静态成员变量，静态成员方法)

静态变量和成员变量的区别？
内存中的位置：
静态变量： 在方法区的静态区中
成员变量： 在堆内存中

生命周期：
静态变量： 随着类的加载而存在，随着类的消失而消失
成员变量： 随着对象的创建而存在， 随着对象的消失而消失

调用方式：
静态变量： 通过对象名方式调用，也可以通过类名方式调用
p.age
Person.age
成员变量： 通过对象名方式调用
p.age

所属不同：
静态变量，随着类的加载而存在，与类相关的，类变量
成员变量：随着对象的创建而存在，与对象相关的，实例变量，成员变量

---------------------
main主方法的解释
public static void main(String[] args){}

public : 公共的意思，它是一个权限修饰符，代表着最大的访问权限,为了让JVM使用，设置权限最大
static : 静态的意思，静态修饰的方法可以类名直接调用，无需创建对象，方便JVM使用
void   : 返回值类型为空，代表没有数据返回，该方法由JVM调用，返回结果我们获取不到，所以不需要返回值
main   : 不是关键字，但是会被JVM所识别，代表着程序的执行入口
String[] args : 代表的是一个字符串数组， 早期用它来接收键盘输入的数据
java Demo "abc" "def" "11" "22" 


--------------------
帮助文档的制作方式：
编写文档注释：
@version 版本号
@author 作者
@param  参数的描述
@return 返回值的描述

通过javadoc工具，生成html 网页格式的帮助文档
javadoc -d doc -version -author ArrayTools.java

-d doc : 代表生成的帮助文档目录
-version -author : 生成的文档中包含作者与版本号信息
ArrayTools.java : 代表需要生成文档的java源文件


-------------------------
Math: 数学工具类
public static double random()
返回一个 0.0<=x<1.0之间的随机小数, 有效长度为小数点后15到17位之间

获取一个1-100之间的随机整数
int num = (int)(Math.random()*100+1);

-----------------------
代码块：
局部代码块：定义在方法中的，用来限制变量的作用范围
构造代码块：定义在类中方法外，用来给对象中的成员初始化赋值
静态代码块：定义在类中方法外，用来给类的静态成员初始化赋值
同步代码块：多线程部分详解

代码块的执行顺序：
静态代码块 --> 构造代码块 --> 构造方法

-----------------------
继承： 在原有类的基础上，产生了一个新类，新类可以使用原有类中所有的非私有成员(成员变量，成员方法)


继承的好处：
提高了代表的可维护性
提高了代码的复用性
让类与类之间产生了继承关系

继承的弊端：
类与类之间的耦合度过高

设计代码的原则：
高内聚，低耦合

内聚： 自己能做的事情尽量自己完成，好处是，但其他人的代码更新的时候，对我的影响不大
耦合： 类与类之间的关联程度

继承特点：
java中类只能够单继承，不能多继承，可以多层继承
class Yy extends Object {}
class Fu extends Yy{}
class Zi extends Fu {}
所有的类都直接或者间接的继承了 Object类，Object类称为祖宗类

继承的注意事项：
1，使用关键字 extends 让类与类之间 产生继承关系
2, 父类私有的成员，子类不能继承，因为根本看不到
3, 构造方法不能继承 
4，不能为了继承某个功能而随意进行继承操作， 必须要符合 is a 的关系
苹果 is a 水果
男人 is a 人
狗   is a 人 ， 这种情况就不能继承了

继承中的成员变量关系：
不同名的变量：
子类直接继承使用
同名的变量：
默认访问的是子类自己的成员变量, 想访问父类中的同名变量，请使用 super.成员变量;

------------------
super: 指的是父类的存储空间(理解为父类的引用)
调用父类的成员变量：
super.成员变量;
调用父类的构造方法:
super(参数);
调用方法的成员方法:
super.成员方法();
     -----------------
继承中的成员方法关系：
不同名的方法：
子类直接继承使用
同名的方法：
默认访问的是子类自己的成员方法，想访问父类中的同名方法，请使用 super.成员方法();


-----------------
方法重写：指 在子父类中，出现了方法声明相同的情况，也叫做方法覆盖，方法复写

方法重写的注意事项：
1，子类的方法声明要与父类相同
2, 子类要重写方法的方法，方法的权限修饰符不能比父类的更低
3, 父类私有的方法，子类不能够进行方法重写

方法重写(override)：指 在子父类中，出现了方法声明相同的情况，也叫做方法覆盖，方法复写
方法重载(overload)：指 在同一个类中，多个方法名称相同，它们的参数列表不同(个数不同，数据类型不同)

------------------
类的完整初始化过程：
(静态成员变量，普通成员变量，静态代码块，普通代码块，构造方法, 子父类继承)
Zi z = new Zi();

1, 由于继承的关系，会将Fu.class 与 Zi.class 加载到内存中
1.1, 在栈空间中，开辟一个空间，存储 Zi类变量 z
1.2, 在堆空间中，开辟一个空间，存储new Zi()对象的成员信息
2, 由于继承关系super()，会先去调用父类中的空参数构造方法
3, 在父类中，完成父类中静态成员变量默认初始化操作
4, 在父类中，完成父类中静态代码块操作，进行父类静态成员初始化
5, 在子类中，完成子类中静态成员变量默认初始化操作
6，在子类中，完成子类中静态代码块操作，进行子类静态成员初始化
7，在父类中，完成父类中普通的成员变量默认初始化
8，在父类中，完成父类中普通的成员变量显示初始化
9, 在父类中，通过构造代码块，完成普通的成员变量初始化操作
10,在父类中，通过构造方法，完成普通的成员变量初始化操作
11,在子类中，完成子类中普通的成员变量默认初始化
12,在子类中，完成子类中普通的成员变量显示初始化
13,在子类中，通过构造代码块，完成普通的成员变量初始化操作
14,在子类中，通过构造方法，完成普通的成员变量初始化操作
15,将new Zi()对应的地址引用 赋值给 变量 z

------------------------
继承中的构造方法注意事项：
1，如果我们手动给出了构造方法，JVM不会在给我们提供默认的空参数构造方法
  如果我们没写任何的构造方法，JVM提供给我们一个空参数构造方法
  
2, 在构造方法中，默认的第一条语句为 super();
  它是用来访问父类中的空参数构造方法，进行父类成员的初始化操作

3, 当父类中没有空参数构造方法的时候，怎么办？
a: 通过 super(参数) 访问父类有参数的构造方法
b: 通过 this(参数) 访问本类中其他构造方法
  注意:[本类中的其他构造方法已经能够正常访问父类构造方法]


4, super(参数) 与 this(参数) 不能同时在构造方法中存在
-------------------------
final：关键字，最终的意思
final修饰的类：最终的类，不能被继承
final修饰的变量： 相当于是一个常量, 在编译生产.class文件后，该变量变为常量值
final修饰的方法： 最终的方法，子类不能重写，可以继承过来使用

面试题：
1，局部变量使用final修饰
基本数据类型局部变量： 值不能改变
引用数据类型局部变量： 引用的地址值不能改变，元素内容可以改变,对象中的成员内容可以改变
2，final初始化时机
在构造方法结束之前，都可以为final修饰的成员进行初始化赋值
class Demo {
final int num;

public Demo(){
num = 10;//赋值成功
}
}
-----------------
多态：理解为同一种物质的多种形态


多态使用的前提：
1，有继承或者实现关系
2，要方法重写
3，父类引用指向子类对象

多态的成员访问特点：
方法的运行看右边，其他都看左边

多态的好处：
提高了程序的扩展性
多态的弊端：
不能访问子类的特有功能
-------------------
instanceof 关键字
格式： 对象名 instanceof 类名
返回值： true, false
作用： 判断指定的对象 是否为 给定类创建的对象

-----------------
抽象：不具体的，不明确的
抽象方法： 方法只有声明部分，没有方法体
抽象类： 包含抽象方法的类，一定是抽象类
         使用 abstract 修饰的类，是抽象类


抽象类的特点：  
1，抽象类与抽象方法都必须使用 abstract来修饰  
2，抽象类不能直接创建对象
  需要通过多态的方式，由子类创建对象,抽象类多态
3，抽象类中可以有抽象方法，也可以没有抽象方法
4，抽象类的子类
a，实现了抽象方法的具体类
b，抽象类


抽象类的成员特点：
成员变量：
普通变量
final变量
构造方法：
有
成员方法：
普通方法
抽象方法

抽象类面试题：
1，抽象类中是否可以没有抽象方法？如果可以，那么，该类还定义成抽象类有意义吗？为什么？
可以没有抽象方法，有意义，不会让其他人直接创建该类对象
2，抽象类不能直接创建对象，那么还有构造方法，有意义吗？为什么？
   有，子类创建对象，默认访问父类构造方法，为父类的成员初始化
3, abstract关键字与那些关键字冲突？
1,private 冲突
2,final   冲突
3,static  没意义

------------------
接口：理解为是一个特殊的抽象类，但它不是类，是一个接口


接口的特点：
1，定义一个接口用interface关键字
interface Inter{}
2，一个类实现一个接口，实现implements关键字
class Demo implements Inter{}
3, 接口不能直接创建对象
  通过多态的方式，由子类来创建对象，接口多态

接口中的成员特点：
成员变量：
只能是final 修饰的常量
默认修饰符： public static final

构造方法：
无

成员方法：
只能是抽象方法
默认修饰符: public abstract 

类与类，类与接口，接口与接口之间的关系
类与类之间：继承关系，单继承，可以是多层继承
类与接口之间: 实现关系，单实现，也可以多实现
接口与接口之间：继承关系，单继承，也可以是多继承

Java中的类可以继承一个父类的同时，实现多个接口

---------------------------------------
形式参数与返回值问题：
形式参数：
普通类： 要接收的是一个普通类的对象
抽象类： 要接收的是一个抽象类子类对象
接口：   要接收的是一个实现接口的子类对象

返回值：
普通类：返回的是普通类的对象
抽象类：返回的是抽象类子类对象
接口：  返回的是实现接口的子类对象

method("哈哈") 
public void method(String name){}
---------------
包： package
理解： 文件夹的意思
包的划分：
按照模块:
cn.itcast.student
StudentAdd.java
StudentDelete.java
StudentUpdate.java
StudentFind.java

cn.itcast.teacher
TeacherAdd.java
TeacherDelete.java
TeacherUpdate.java
TeacherFind.java


功能分:
cn.itcast.add
StudentAdd.java
TeacherAdd.java
cn.itcast.delete
StudentDelete.java
TeacherDelete.java
cn.itcast.update
StudentUpdate.java
TeacherUpdate.java
cn.itcast.find
StudentFind.java
TeacherFind.java

-----------
包的定义与带包的类的编译和运行

格式： package 包名.类名;


带包的类的编译和运行:
手动式：
1, javac java文件名.java, 产生字节码文件.class
2, 创建包所对应的文件夹， 把.class字节码文件放入最里层文件夹
3, java 包名.类名 方式运行，看结果

自动式：
1，javac -d 目录 java文件名.java
自动创建包所对应的文件夹， 把.class字节码文件放入最里层文件夹
2，java 包名.类名 方式运行，看结果

---------------------
包的注意事项：
1，在一个java文件中只能够定义一个包 package 
2，定义包的代码。必须是有效代码第一条
3, 在一个java文件中，可以使用多个 import 导包
4, 在一个java文件中，可以定义多个类class 

包的面试题:
package --> import --> class 

package 在最上面写
import  在中间
class   在最下面


----------------------
import: 导包， 用来导入包中所对应的类, 在调用类的时候，无需在编写包名
导包的格式：
import 包名.类名; 

import cn.lkp.Fu;
在创建对象的时候，不需要再编写包名
Fu f =new Fu();
-----------------------


权限修饰符
public : 公共的
protected: 受保护的
默认的：在jdk1.8时候， 使用default 进行修饰
private : 私有的

public protected 默认的 private
在当前类中 Y Y Y Y
同一包中的子类 Y Y Y
同一包中的其他类 Y Y Y
不同包中的子类 Y Y
不同包中的其他类 Y


    --------------------------
类及其组成可以用的修饰符


修饰符：
public : 公共的
protected : 受保护的
: 默认的
private ：私有的
final : 最终的
static : 静态的
abstract : 抽象的

类：
public 默认的 final abstract
使用最多的是 public

成员变量：
public : 公共的
protected : 受保护的
: 默认的
private ：私有的
final : 最终的
static : 静态的
使用最多的是 private 

构造方法：
public : 公共的
protected : 受保护的
: 默认的
private ：私有的
使用最多的是 public

成员方法：
public : 公共的
protected : 受保护的
: 默认的
private ：私有的
final : 最终的
static : 静态的
abstract : 抽象的
使用最多的是 public


---------------------------
内部类： 在类中，定义了一个新类，这个新的类就是内部类
class A {//外部类
class B{// 内部类

}
}

特点： 
1，内部类可以直接访问外部类的成员，包含私有的成员
2, 外部类想要访问内部类的成员，必须创建内部类对象才可以访问

内部类的分类：
位置划分：
成员内部类：
class Outer{
//成员位置
class Inner(){//成员内部类

}
}

局部内部类：
class Outer{
public void method(){
//局部位置
class Inner(){//局部内部类

}
}
}

成员内部类常见的修饰符：
private : 提高内部类数据的安全性
static  : 方便了数据的访问调用


局部内部类的使用：
1，局部内部类可以使用外部类的成员，包含私有成员
2, 当局部内部类访问 外部类的局部变量的时候，局部变量需要 final修饰
必须被final修饰?
为什么呢?
因为局部变量会随着方法的调用完毕而消失，
这个时候，局部对象并没有立马从堆内存中消失，
还要使用那个变量。为了让数据还能继续被使用，就用fianl修饰，
这样，在堆内存里面存储的其实是一个常量值。通过反编译工具可以看一下

匿名内部类： 就是没有名字的内部类

使用的前提：
要有一个父类(普通类，抽象类)
或者有一个接口

格式：
new 父类 (){
//重写父类中所有的抽象方法
};

new 接口() {
//重写接口中所有的抽象方法
};

代码演示：
interface Inter {
public abstract void method();
}

//创建匿名内部类
new Inter(){
public void method(){
System.out.println("匿名内部类");
}
};

//匿名内部类调用方法的方式
new Inter(){
public void method(){
System.out.println("匿名内部类");
}
}.method();

--------------------------
扩展：
interface Inter {
public abstract void method();
}
//使用下面的show方法
public void show( Inter in ){} // in --> 要的是接口子类对象
//使用的方式如下：
p.show(  new Inter(){
//重写接口中的抽象方法
public void method(){
System.out.println("我被调用了");
}
});
--------------------------