java 基础概念

和类名相同的方法不一定是构造方法构造方法一定和类名相同
this 调用属性方法和构造方法 只能 在本类中使用
静态方法 是不能使用this this调用是对象 静态时类的
this 初始化必须放在类中所有动作之前 初始化必须先被执行
static 用于修饰成员变量和方法
生命周期最长
静态东西被所有对象共享 被类名调用

上节课复习

主函数//主方法
是一个特殊的方法，作为程序的入口，可以被jvm调用
public static void main(String[] args)
public 代表着该方法访问权限最大
static 代表方法随着类的加载已经存在了
void 主函数没有具体返回值
main：不是关键字，但是是一个特殊的单词，可以被jvm识别
String[] args 函数参数，参数是一个数组，数组元素是字符串

主函数是固定格式，jvm识别
2 什么时候使用静态
静态变量：当对象中出现而来的共享数据时，该数据被静态所修饰
静态方法：当功能内部没有访问到非静态数据，那么该功能可以被定位静态的。

匿名对象
    匿名对象是对象的简写形式
        Person p = new Person();
        new Person().show();
适用情形1：当对象方法只调用一次，可以使用匿名对象这样写简化
如果对一个对象进行多个成员调用，必须给这个对象起个名字

适用情形二 可以将匿名对象作为实际参数进行传递

静态代码块
格式：
static
{
}
特点 随着类的加载而执行，只执行一次，用于给类进行初始化
jvm都做了什么
1因为new 用到了 Person.class所以会先找到Person.class 文件
并加载到内存中
2 执行该类中的static代码块 如果有的话 给Person.class 类进行初始化
3.在堆内存中开辟空间，分配内存地址
4.在堆内存中建立对象特有的属性，并进行默认初始化
5.对地形进行显示初始化
6.对对象进行对象构造代码块的初始化
7.对对象进行对应的构造方法初始化
8.对内存地址赋给栈内存中的变量

4.单例模式
解决方案 对于一类问题比较优化的方案
解决一个类在内存中只存在一个对象
反反复复在用类的一个对象

gof 二十三中经典模式
***********************************************************************
饿汉式
懒汉式
对象 一种先将对象初始化 另一种调用方法在对对象进行初始化

单例模式代码中的体现
将构造函数私有化
在类中创建一个本类的对象
提供一个方法可以获取到该对象

继承 extends
protected 只能在有继承的环境下时候使用
protected 全体类 不能访问
        夸包 子类可以访问它的修饰方法 不写子类不能用对象调用它的方法
         同包 同类 可以访问它修饰的方法 属性

提高代码的复用性
让类与类之间产生了关系，有了这个关系，才有了多态的特性
继承是产生多态的基础
作用域在子类的范围中
方法调用同名变量时，会优先调用作用域更小的变量
注意 千万不要为了获取其他类的功能，简化代码而继承
必须是类与类之间所属关系才可以继承，所属is a
键盘显示器组合关系
机箱主板聚合的关系

java是单继承
接口 多实现 implements
interface 接口
java只支持单继承 不支持多继承

java支持继承体系。多层继承，也就是一个继承体系。
那么在具体调用上，要创建最下层子类对象
1.因为有可能父类不能创建对象
2.创建子类对象可以使用更多的功能，包括基本的也包括特殊的。

变量
如果子类中出现了非私有同名成员变量时，
子类要访问本类的变量，用this
子类要访问父类中的同名变量，用super

夸包继承类
super 的使用与this 关键词相同
this是本类对象的引用
super是父类对象的引用
子类创建对象构造 son（）{super()}隐士调用父类构造方法
父类没有空参构造方法子类必须显示调用 父类的构造方法
son（）{super(“”)}子类构造方法必须显示调用它的构造方法
只要夸包访问，只有public和protected可以用，protected需要继承后才能夸包用， default private其他类型不管继承 还是不继承只要夸包就不能用。super调用方法或者属性，根据方法和属性的修饰符决定
***********************************************************************
子父类中构造方法
    this与super不能在一个构造方法中出现
子类构造方法运行时，父类的构造方法也会运行，隐式
    的调用了super（）

子类一定要访问父类的构造方法


因为父类的数据,子类可以直接访问，所以子类对象在建立时，
    需要先查看父类是如何对这些
    数据进行初始化的，所以子类在对象初始化的时候，
    先访问父类中构造方法，
    如果访问父类中指定的构造方法，可以通过手动定义
    super语句来指定。

super调用父类构造方法一定定义在子类构造方法第一行。

结论：子类所有的构造方法，默认都会访问父类中空参构造方法
    因为子类每一个构造方法内的第一行都会有一句隐式的super（）

       当父类没有空参数的构造方法时，子类必须手动通过super语句
    来指定访问父类中构造方法


当然子类的构造方法第一行也可以手动指定来访问本类中
    其他构造方法,子类至少有一个构造方法访问父类的构造方法。
方法

    当子类对象和父类有一摸一样的方法时，
    当子类对象调用该方法时，会运行子类方法的内容
    如同父类的方法被覆盖一样

是方法的另一个特性：重写/覆盖
    @Overrides

final 关键字 作为修饰符

1 可以修饰类，方法，变量。
    2 被final修饰的类不能被继承 为了避免父类被子类所复写
    3 被final修饰的方法不能被重写
    4 被final修饰的变量是常量。既可以修饰成员变量，也可以
    修饰局部变量

当描述事物时，一些数据是固定的，为了增强阅读性，给这些值起
    个名字方便阅读，值不会改变，加上final关键字

    常量：变量名全部由大写组成，多个单词之间由_组成，
    并由final修饰

抽象类abstract

有抽象方法的类一定是抽象类
    抽象类不一定有抽象方法

    无抽象方法的抽象类作用只是不能实例化抽象类本身


    1 抽象类

对象名.方法名（）;

当多个类中出现了相同功能，但是功能主体
    不同，可以向上抽取，这时只抽取功能定义
    而不抽取功能主体

特点：
    1 抽象方法一定在抽象类中
    2 抽象方法和抽象类必须被abstract关键字修饰
    3 抽象类不可以用new创建对象。
    4 抽象类中的抽象方法要被使用，必须由子类复写所有
    的抽象方法后，建立子类对象调用
    （假如子类重写了部分的抽象方法，子类也还是个抽象类）

抽象类与普通类的区别：
    1 抽象类可以定义抽象方法，普通类不可以。
    2 抽象类无法实例化。

示例：模板模式
************************************************************************
抽象方法可以被普通方法调用 在抽象类中。
模板模式

接口 interface
功能性接口：抽象方法
标识性接口:无抽象方法
一个接口中没有任何方法 就是标识性接口 一个类实现没有了 任何抽象方法的接口不用做任何动作 可以传 传接口作为参数 传的是标识性接口的子类
实现类的本地序列化（实现标识性接口） 将我们在内存中的对象 以文件的形式进行保存   可以将代码进行远程传送。

webservice
可以实现rmi  remote method invoke 远程方法调用

 
接口里面的属性
接口里面所有的方法都是抽象的。

interface 里面 abstract关键字可以省略 但方法都是抽象的。
接口里所有方法都是抽象的 都是公共的 public也可以省略。
接口没有构造方法 只有类有构造方法
接口里面的属性 必须加上final

接口 可以理解为一个特殊的抽象类
接口里面的方法都是抽象的 也可以没有一个方法
单继承 多实现接口
特点
 不可以创建对象
需要对象子类实现，子类接口中所有方法实现后，方可对子类进行实例化 否则子类时抽象类

优势
对外暴露的规则
程序的功能扩展
接口用来多实现
接口与接口之间继承

接口也只能有一个父类接口 可以实现多个接口
子接口有父接口的同名方法 覆盖父接口的方法； 实现多个接口有一个同名方法实现一个

多态
    可以理解为事物存在的多种体现形态
体现
父类的引用指向了自己子的类对象
father f = new son();
父类的空间 塞进去子类的对象 被抛弃子类所特有的 留下和父类匹配的
f可以调用父类特有的方法 也可以调用与子类覆盖父类同名的方法。
特殊的父类

多态也可以运用接口
多态前提
必须是类与类之间有关系，继承或实现。
存在方法的重写或实现
多态好处
多态的出现大大提高了程序 的扩展性
弊端
提高了扩展性，但是只能使用父类的成员


向上转型 向下转型
多态成员方法的特点：
编译看左边 父类，运行看右边 看子类。
多态成员变量的特点
无论编译运行都参考左边

多态，静态成员方法的特点：
无论编译运行 都参考左边
************************************************************************
多态只有静态的方法 属性一定调用父类 子类重写没用不能调用
内部类
    普通类 内部类 抽象类 匿名类
inner class
1.内部类可以直接访问外部类的成员，包括私有的，内部类之所以能够访问外部类的变量，因为有一个外部类的引用
格式 外部类的类名.this  Outer.this隐含的
2外部类访问内部类必须建立内部类的对象

内部类可以被 private static修饰。

其他类里面定义内部类的对象
格式为
外部类名.内部类类名 对象 = 外部类对象.内部类对象
Outer.Inner 对象 = new Outer().new Inner();

staitic 内部类具备了static特性
内部类被static修饰后，只能访问外部类中的static成员

在外部其他类中，如何访问static内部类的非静态成员呢
new Outer.Inner().functon()
在外部其他类中，如何访问static内部类的静态成员呢
Outter.Inner.function();

注意：如果内部类定义了静态成员，那么该内部类必须是static
内部类与外部类的方法等价 静态方法里面只能是静态的东西

静态内部类可以有非静态成员。 一个类里面可以有静态的方法 和非静态的方法

当外部类的静态方法访问内部类时，内部类必须是static 可以访问静态内部类的非静态方法吗？

内部类的使用描述
当描述事物时，事物的内部还有事物，该事物用内部类的描述

内部类定义在局部时：局部变量一个等级
1.不可以被成员修饰符修饰
2 可以直接访问外部类的成员，因为还持有外部类中的引用
但是不可以访问它所在方法的局部变量，
只能访问被final修饰的局部变量。

匿名内部类
1 匿名内部类就是内部类的简写格式
2定义一个内部类的前提 内部类继承一个类或实现了一个接口
3 匿名内部类的格式
    new 父类或者接口{定义子类的对象}
4.匿名内部类其实就是一个匿名子类对象，而且这个对象有点胖可以理解为带内容的对象
5.匿名内部类中的方法最好不要超过3个。多了代码长 可读性差。
***********************************************************************
异常
 ]]]
throwable
    
    java Error相当于cancer  出现重大问题，运行的类不存在，或内存溢出。
    
Exception 感冒一样。
    在运行时运行出现的问题，通过trycatch捕捉
类里面有两个异常 会先执行前一个异常。

所谓异常就是java对不正常的情况进行描述后的对象的体现。

对于问题的划分：一种是严重问题
非严重问题

严重：error
针对error
不编写针对性的处理
非严重：excepton
exception使用针对性处理

eception 编译时异常 运行时异常
编译时异常
出RuntimeException类及其子类以外的其他exception及其子类。
运行时异常 runtimeException及其子类。

当异常发生时，发生异常下的所有代码不会被执行。

try catch finally throw throws

运行时异常虽然不需要throws 和trycatc进行处理，但是在代码中要合理规避异常的产生。
五个最常用的异常类
ClassNotFoundException
IOException
SQLException
DataFormatException 数据格式异常
RuntimeException
ClassCastExcetion 类型转换
NullPointerException 空指针异常

throw 后面跟异常对象
throws 放在方法的后面使用
main方法抛出异常 抛给虚拟机
运行异常 不写throw try catch代码 不让他爆发 手动找到异常修改代码 改掉 不能让情况发生
编译异常 try catch throw 就可以搞定

运行异常虽然不需要throws 和trycatch进行处理，但是在代码中要合理规避
异常的产生
trycatch 完整功能时，对于抛出的编译时异常进行捕获，把问题进行统一处理。
throws 用在功能相对单一的方法中，常被其他代码所调用，出现问题通常是其他的错误调用 导致异常产生时，用throws。

多重catch
异常 父类写在下面 子类写在上面
多重catch时，父类异常放在异常捕获的下方，
子类异常放在上方，兄弟异常无先后顺序。
try
{需要被检测的代码
}
catch(异常类 对象)
{处理异常的代码
}
finally
{(一定会执行的代码)
}
获取异常类信息
getMessage()
toString()
printstacktrace(）;//jvm默认处理机制 就是调用打印异常的堆栈的跟踪信息

throws
对多异常处理
1.声明异常时，建议声明更为具体的异常，这样处理可以更具体
2.对方声明几个异常，就有对应几个catch块，不要定义多余的catch块，
如果多个catch块中的异常出先继承关系，父类异常catch块放在最下面
建议在进行catch处理时，catch中一定要定义具体处理方式不要简单的定义一句
e.printstacktrace() 也不要简单的书写输出语句。

自定义异常
1必须自定义类继承Exception
2通常会将异常的描述信息 放入自定义类的构造方法
3其他的信息可以根据自己需求，灵活定义。

throw和throws区别
throws使用在方法上
throw使用在方法内
throws后面跟异常类，可以跟多个，用逗号
throw后跟异常对象
Exception中有一个特殊的子类异常RuntimeException
运行时异常。
如果在方法内抛出该异常，方法上可以
不用声明，编译通过。
如果在方法上声明了该异常。调用者可以不用进行处理，编译一样通过。

之所以不用再方法声明，是因为不需要让调用者处理。
当该异常发生，希望程序停止，因为运行时，出现了无法继承的情况，程序停止后，
对代码进行修改。
对于异常：
1编译时的异常
2编译时不被检测的异常即运行时异常如 runtimeexception
finally执行优先级别是最高的 遇到return后 也会执行finally代码块。



在try块中如果有一个异常 throw new IOException 则编译器报错下面代码多余。
System.exit(0);//jvm关闭虚拟机
try 应该和catch 或finally 中的一个匹配。

finally
代码块中放的是一定会执行的代码
1.通常是关闭资源代码放入finally代码块中
2finally只有一种情况不黑被执行，那就是执行了System.exit（0）；

try
{}
catch
{}

try
{}
catch(){
}
finally{
}

try
{}
finally
{}
注意 如果没有catch就没有异常，如果是检测时异常，

异常的处理原则
1处理的方式有两种，try或throws
2调用到抛出异常的功能时，抛出几个，就处理几个一个多个catch
3多个catch 父类异常放在后面
4catch内 需要定义针对性的处理方法，不要简单的定义
e.printstacktrace(),但是也不要不写
当捕捉到的异常处理不了时，可以继续在catch继续抛。
try{
try{
}catch(){
}
}
catch(){
}
************************************************************************