Java课程重点

面向对象三个基础
封装
继承
多肽







类
1.对象共性的抽象
2.客观对象在人脑中的主观反应 类是人对对象的认识
3.类是对象的模板

如何编写一个类
属性：实例变量
1.有默认值 数值类型：0；布尔类型：false 对象类型：null
2.作用范围：至少是全类的内部
3.可以和局部变量发生命名冲突，冲突的时候局部优先；


局部变量:
1：先赋值后使用；
2：作用范围：从定义开始到代码块结束
3：在重合范围内不允许两个局部变量命名冲突；


方法：
方法的声明：对象能做什么；（相对实现来说较为重要）
修饰符 返回值类型 方法名（参数表） 跑出的异常

方法的实现：对象怎么做；
方法的重载（overload）：
允许在一个类里面定义多个同名的方法，参数表不同
1.参数个数不同
2.参数类型不同
3.参数类型排列不同
仅仅是方法形参不同怎不能算是方法重载；

由编译器在程序编译的时候，根据实参的类型选择一个合适的方法调用

方法的重载又叫编译时多态
向上就近（类型相近）匹配原则 避免混淆！！！

作用：让一个对象的同类方法，由于参数表的不同造成的差异，对用户屏蔽！

构造方法：
1.没有返回值类型
2.方法名必须和类名相同
3.不允许手工调用，在对象构造的工程中自动调用一次

如果一个类 没有定义任何构造方法 系统会默认添加一个公开的无参构造方法；

对象的创建工程：
1：分配空间 所有的实例变量都被分配了默认值
2：初始化属性 所有的实例变量被赋予初始值
3：调用构造方法 实例变量常常被第三次赋值

构造方法经常用来给属性赋值；


变量按照类型的划分：
简单变量 ：存值
对象变量（引用）：存的是对象的地址

java中参数的传递规则：
简单类型的参数 传值
对象类型的参数 传地址 传引用 实参和形参

this
java中参数的传递规则：
简单类型的参数 传值
对象类型的参数 传地址 传引用 实参和形参指向同一对象


1.引用 指向当前对象
当实例变量和局部变量命名冲突的时候 用this。表示实例
2.只能用在构造方法中 this（...）调用本类的其他构造方法
必须是构造方法中的第一个语句；在构造方法中只能写一个 this调用


==================================================



封装
任何对象都要有一个明确的边界
对象的边界队对象的
内部起到一个保护的作用
数据隐藏

public 公开 不受边界约束
private 私有 只能在本类内部访问 无法通过边界

属性私有 提供公开的setXXX/getXXX来访问属性；

方法私有 只给自己调用

方法公开 声明公开 实

现隐藏
实现的改变的架构的影响最小


-------------------------------------------------
继承
父类——>子类 一般到特殊
父类：子类的共性 抽象出来
所有子类能够访问的父类的属性和方法；即是子类从父类中继承的属性和方法；


从严到宽
private 私有 本类内部 不能继承
（default） 本类+同包 同包子类可以继承
protected 受保护的 本类+同包+异包子类边界是不同包不是子类 可以继承
public 公开 可以继承

构造方法不能继承

方法的覆盖（override）
子类用特殊的方法实现来替换掉父类继承给它的一般方法的实现

返回值类型 方法名 参数表相同 访问修饰符相同或更宽；


============================================================

对象构造过程
1.分配空间 本类+父类 一并分配
2.递归的构造父类对象 （2,4）
3.初始化本类属性
4.调用本类的构造方法



A<---B<----C
创建C对象


分配空间
初始化A属性
调用A的构造方法
初始化B属性 ----
调用B的构造方法 ！构造B对象
初始化C属性 ----
调用C构造方法

super
1.引用 ：父类对象
访问父类被遮盖的属性或调用父类被覆盖的方法；
2.用在构造方法中 指定调用父类哪一个构造方法
必需是构造方法中第一个语句；

如果一个构造方法的第一句话，不是this（...），也不是super（...）
，系统会默认添加 super（），即是系统默认的无参构造方法；
常常会用来把构造参数传给父类，去设置父类的属性；

Java中的单继承
一个类中只能有一个直接父类

简单 类之间会形成简单的树状结构



========================================================================
多态

子类的对象可以看作是父类的对象
子类对象可以放入父类引用

1.对象类型不变
2.只能对其引用调用其引用类型中的声明方法
3.运行时，根据对象实际类型找子类覆盖之后的方法


子类引用赋值给子类引用 可以直接赋值

父类引用赋值子类引用 需要强类型转换 保证编译通过但是运行时可能发生类型转换异常

==========================================================


private 属性 方法 构造方法
（default） 属性 方法 构造方法 类
protected 属性 方法 构造方法
public 属性 方法 构造方法 类


static 静态的
1.属性
类变量 全类共有 允许直接用类名访问
类加载：当JVM第一次使用一个类时，需要通过classpath找到这个类对应的.class文件，把这个文件中包含的类的信息读入JVM并保存起来，一般来说，一个类只会加载一次

；
类变量是在类加载的时候分配空间，并初始化 ；


类加载的时机
1.创建类的对象
2.访问类的静态成员
3.加载子类必须先加载父类
4.如果仅仅是声明引用，不会类加载

2.方法
静态方法 允许直接用类名调用
在静态方法中，只能访问类的静态成员
静态方法可以被子类的静态方法覆盖，而且没有多态

对一个引用调用其静态方法，仅仅相当于对引用类型调用静态方法
3.初始代码块
静态初始代码块中的代码，在类加载的时候执行一次

=============================================
final
1.变量 常量一旦赋值不能被改变
对于final属性 系统不会提供默认值
如果final实例变量 可以再初始化属性或者是构造方法中赋值
如果final类变量可以在初始化属性或者是静态初始代码块中赋值
2.方法 该方法不能被子类覆盖
3.类 该类不能被子类继承


abstract 抽象的

1.类
抽象类只能声明引用，不能创建对象
2.方法
抽象方法 只有声明 没有实现
如果一个类中有抽象方法，这个类就必须是抽象类；
但是抽象类中未必有抽象方法；
抽象类中可以有构造方法；
子类继承抽象类，如果子类不希望也成为抽象类，就
必须实现父类中声明的所有抽象方法
利用abstract，可以把方法声明抽象到类中，而方法实现留在子类，更好的体现“共性放在父类”原则
修饰符组合：
private static final均不能和 abstract联用


=============================================================================================

接口
定义接口关键字interface
特殊的抽象类；
1.所有的属性都是公开静态常量
2.所有的方法都是公开抽象方法
3.没有构造方法
接口的实现implements

一个类去实现接口，如果这个类不希望也称为抽象类 ，就必须实现接口的所有方法；
接口之间可是实现多继承
一个类在继承另外一个类的同时，还可以实现多个接口

利用接口实现多继承，不会破坏类之间的树状关系的简单性
解耦合的工具 标准
把标准的使用者和标准的实现者分离
====================================================
接口的回调
在定义接口之后，先有接口的使用者，后有接口的实现者，使用者通过接口调用
实现着中的方法
=========================================================
内部类 类中定义类
成员内部类
1）可以访问外部类的私有成员
2）创建成员内部类对象，必须先创建外部类对象，在通过外部类对象.new 构造内部类对象
3）成员内部类中不能有静态成员
4）外部类名.this指向外部类的静态成员
静态内部类
1）静态内部

类只能访问外部类的静态成员
2）创建静态内部类对象，不需要先创建外部类对象
局部内部类
1）使用范围等同于局部常量
2）不仅可以访问外部类的私有成员，还可以访问外部类的局部变量，
但是必须被声明为final
匿名内部类
1）特殊的局部内部类
2）继承一个类或者是实现一个接口
3）只会创建该类的一个对象
没有构造方法，因为构造方法需要和类名相同
new IA（）{接口的实现方法}

1，内部类可以访问外部类的私有成语昂，而不破坏封装；
2，接口公开，接口的实现类作为内部类隐藏起来，强制弱耦合；
=============================================================
Object Java中所有类的对象，类继承关系树的树根
1.Object o；o中可以装任何对象
2.Object类中的方法 是所有对象都具有的方法

1）finalize（）；由垃圾收集器在回收垃圾对象时，最后调用
a：垃圾回收器如何认定垃圾对象 零引用算法
b：垃圾回收器何时释放垃圾对象 在必须释放的时候
2）getClass（）；返回对象的实际类型
3）toString()； 返回对象的字符串形式 打印一个对象就是打印这个对象的toString 方法
的返回值；

4)boolean equals(Object o)

//1判断自反性
if（this==o）return true；
//2判断是不是为空
if（o==null）return false;
//3判断this和o是不是同一类的对象
if(this.getClas()!=o.getClass())return false;
//4将o强制类型转换
Student s=(Student)o;
/*5逐个比较属性
对象类型的属性用equals比较
简单类型的属性有==比较
*/
if(this name.equals(https://www.360docs.net/doc/fe3602758.html,)&&this.age==s.age)
return true;
包装类：
1：为8种简单类型提供对象形式让Object统一所有数据
2：对于数值类型的属性，区分0和null
包装类 简单类型String 之间的转换
JDK5.0之后 自动封箱
由编译器自动完成简单类型和包装类之间的转换
//int <--->Integer
int i = 12;
Integer ii = new Integer(i);
int i2=ii.intValue();
//int<--->String
int i3 = Inter.parseInter(i)
//inter<--->String
Integer ii2 = Integer.parseInt(s);
===============================================================
集合框架
集合：容器 一个对象 ，用来储存其他多个对象

接口的特点
接口中的方法
遍历
实现类

Collection
特点：元素是Object
add(Object o):添加数组元素 并判断是否添加成功
addAll(Collection c):把c中的所有对象放入集合
clear():清空集合
contains(Objcet o):判断对象o在集合中是否存在
remove(Object o):将o对象从集合中删除
size():返回集合中对象的个数
遍历：
实现类：无


List
特点：元素有顺序 可以重复
方法：
add(int pos,Object o):把对象插入到pos位置
get(int pos):返回pos位置的元素
indexOf(Object o):返回对象o的下标
remove(int pos):删除pos

位置的元素
set(int pos,Object o)：把pos位置的元素替换给o
遍历：
1：for下标遍历
2：迭代遍历
static void print（Collection con）{
//创建一个迭代器 将con元素放入迭代器
Iterator it = con.iteratr()
while(it.hasNext()){
Object o = it.next();
System.out.println(o);

}
}


实现类
1，ArrayList:用数组实现List 查询快 增删慢
1.2轻量级 线程不安全
2,Vectot :用数组实现
1.0重量级 线程安全
3，LinkedLIist 用链表实现的 查询慢 增删快
Set:
特点：元素无顺序 不可以重复（指的是内容不重复）
方法：全部继承自Collection接口
遍历：迭代遍历
实现类：
HashSet 把自定义对象放入HashSet ,为保证元素不重复 必须
1）覆盖hashCode() 保证相同对象返回相同int
2）覆盖equals（） 保证相同对象返回true