java进阶

数据封装

构造方法

提供一个方法，并且这个方法能够在创建对象的时候被调用，进行初始化操作
用更严格的访问级别修饰sex和name属性，防止外部修改
构造方法是JAVA语言中的一个特殊方法，其特点是无返回值，与对应的类同名，可以重载。

数据封装的总结

类中属性和方法都可以用public、protected和private来改变其访问属性
只有public修饰的属性和方法可以被类的外部访问
protected和private修饰的属性不能再类外被访问。
类中的方法可以在自身类中声明的属性自由访问和修改，不受访问修饰符的限制
构造方法是类中的一种特殊方法，在创建对象的时候被调用
构造方法可以有参数，可以重载，参数的传递在创建对象的时候进行
如果没有自己定义构造方法，java会默认提供一个无参数的构造方法，但是这个默认的构造方法什么都不会做

数据封装的概念与规则

每一个对象都有自己的属性值，这些属性值互相不能独立。
但是日常生活中我们有时候需要知道的是一个类相关的信息，而不仅只是类对象的信息
类属性：类属性与类相关，即使没有创建对象，属性也存在，因此可以用类名直接访问
类方法：类方法与类相关，可以用类名直接调用，但是类方法只能访问类属性和调用类方法，不能访问对象属性，也不能调用对象方法。

static关键字的作用

增加一个修饰符可以区分类属性和对象属性以及类方法和对象方法
JAVA语言中声明属性和方法只需要加上static关键字

继承和多态

继承的基本概念

生活中的继承指的是晚辈得到长辈的一些事物和特性，java语言通过extends关键字来声明两个类之间的继承关系，子类通过继承能够得到父类的属性，子类也可以添加自己特有的属性和方法。

再论public,protected,private;

public修饰的属性和方法可以在类外部被访问。
protected和private修饰的属性和方法不能在类的外部被访问
protected和private的区别是什么呢？
protected修饰的属性和方法是可以被子类继承的
private修饰的属性和方法不能被子类所继承

类的继承

继承是面向对象编程的三大特征之一。JAVA的继承通过extends关键字来实现。实现继承的类称为子类，被继承的类称为父类。

[修饰符] class 子类名 extends 父类名{}

子类继承了父类，将可以获得父类的全部属性和方法，java的子类不能调用父类的构造方法。java类只能有一个直接父类。从子类角度来看，子类扩展了父类，但从父类的角度来看，父类派生出了子类。
但子类可以重写父类的方法。
如需在子类调用父类中杯覆盖的方法，使用super（被覆盖的是实例方法），或者父类类名进行直接调用。
子类中定义的方法可以通过super关键字来访问父类被覆盖的属性。

class BaseClass{    public int a = 5;}public void accessBase(){    system.out.println(super.a);//输出a=7；}

调用父类的构造方法

子类不会获得父类的构造方法，但是有的时候子类构造方法却需要调用父类构造方法的初始化代码。在一个构造方法中需要调用另一个重载的构造方法，一般采用this调用来实现：在子类的构造方法中调用父类的构造方法，一般使用super调用来实现。

public Base(double size,String name){this.size = size;this.name = name;}public class Sub extends Base{public Sub(double size,String name,String color){super(size,name);//必须出现在第一行this.color = color;}}

子类对象和父类对象的相互转换

与强制数据类型转化有关，存在继承关系的父类对象和子类对象之间也可以在一定条件下相互转换，转换需要遵循一定的条件。
1子类对象可以视为父类的一个对象
2父类对象可以当作一个子类的对象
3如果一个方法的形参定义的是父类对象，那么调用这个方法时，可以使用子类对象作为实际参数。
4如果父类对象与引用指向实际是一个子类对象，那么这个父类对象的引用可以强制类型转化成子类对象

静态初始化

普通初始化块只能在创建对象时自动执行而且在构造函数前执行。

如果定义初始化时使用了static修饰符，这个初始化块就变成了静态初始化块。静态初始化块是类相关的系统将在类初始化阶段执行它，而不是在创建对象是执行它。静态初始化通常对于整个类进行初始化，可对类属性执行初始化，但不能对类方法执行初始化。

class Root{static{    System.out.println("Root的静态初始化块")；}{    System.out.println("Root普通初始化模块")；}public Root{    System.out.println("Root无参数的构造方法")；}}class Mid extends Root{static{    static.out.println("Mid静态初始化块")；}{System.out.println("Mid的普通初始化模块")；}public Mid(){    System.out.println("Mid的无参数的构造方法")；}public Mid(String msg){this();System.out.println("Mid的带参数的构造方法，其参数值：" + msg)；}}class Leaf extends Mid{    static{        System.out.println("Leaf的静态初始化块")；    }    {        System.out.println("Leaf的静态初始化块")；    }    public Leaf()    {        super("struct2权威指南")；        System.out.println("执行Leaf的构造方法")；    }  }public class Test{    public static void main()    {        new Leaf();        new Leaf();    }}

运行结果

Root的静态初始化块Mid静态初始化块Leaf的静态初始化块Root普通初始化模块Root无参数的构造方法Mid的普通初始化模块Mid的无参数的构造方法Mid的带参数的构造方法，其参数值：struct2权威指南Leaf的静态初始化块执行Leaf的构造方法Root普通初始化模块Root无参数的构造方法Mid的普通初始化模块Mid的无参数的构造方法Mid的带参数的构造方法，其参数值：struct2权威指南Leaf的静态初始化块执行Leaf的构造方法

第一次创建一个Leaf对象时，因为系统中还不存在Leaf类，因此需要先加载并初始化。初始化Leaf类时先执行顶层父类的静态初始化，然后执行其直接父类的静态初始化块，最后执行Leaf本身的静态初始化块。
一旦Leaf类初始化成功，Leaf类在该虚拟机里将一种存在，因此当第二次创建Leaf实例无须对Leaf类进行初始化。
普通初始化块和构造方法的执行顺序与前面介绍的一致，每次创建一个Leaf对象时，都需要执行最顶层父类的初始化块，构造方法，然后执行其父类的初始化块，构造方法……，最后才执行Leaf类的初始化和构造方法。

final变量

final修饰变量的时候，表示变量一旦获得初始值就不会再改变。final既可以修饰成员变量，也可以修饰局部变量，形参。final修饰成员变量和局部变量时有一些不同。
使用final修饰成员变量时，要么在定义成员变量时指定其初始值，要么在初始化块、构造方法中为成员变量赋初始值。如果在定义该成员变量时指定了默认值，则不能在初始化块、构造方法中为该属性重新赋值。final修饰的类属性、实例属性能在指定初始化的地方初始化。

final修饰局部变量

由于系统不会对局部变量进行初始化，局部变量必须由程序员手动赋值。因此，使用final修饰局部变量时既可以在定义时指定默认值，也可以不指定默认值，如果final修饰的局部变量在定义时没有指定默认值，则可以在后面的代码中对该final变量赋初始值，但只能一次，不能重复赋值。如果final修饰的局部变量在定义时已经指定默认值，则后面的代码中不能再对该变量赋值。

final方法

fianl修饰的方法不能被重写，如果处于某些原因不希望子类重写父类的某个方法时，可以使用final修饰该方法。
final修饰的方法仅仅是不能被重写，并不是不能被重载。因此，在TestFinalMethod类中添加和test互为重载的方法是合法的。
public class TestFinalMethod{
public final void test(){}
}
class Sub extends TestFinalMethod{
public void test(){}
}
以上是错误的；
public class TestFinalMethod{
public final void test(){}
public final void test(String arg){}
}

final类

final类不可被继承
public final class FinalClass{}
class Sub extends FinalClass{}
以上错误。

文件写入操作

//写入文件 try{            FileWriter tfw = new FileWriter("X:\\test.java");            tfw.write("Hello World!");            tfw.write("Hello chen!");            tfw.close();        }        catch(Exception e){}//读取文件        try{            FileWriter tfw = new FileWriter("X:\\test.java",true);            tfw.write("\nHello Worldchen!\n");            tfw.write("\nHello chenmiaohong!\n");            tfw.close();        }        catch(Exception e){}        try {            FileReader tf = new FileReader("X:\\test.java");            while (-1 != (ch = tf.read())) {                System.out.print((char) ch);            }        }        catch (FileNotFoundException e)        {    System.out.println("找不到文件!");            System.exit(-1);        }        catch (IOException e)        {    System.out.println("文件读取失败!");            System.exit(-1);        }

Java的包

名称冲突问题

C语言所有函数都是全局的，因此在多人合作的大型项目开发中容易出现两个函数同名的情况
C语言中一般是通过在函数名上加上前缀来解决名称冲突问题
每个类在经过编译之后将生成一个对应的.class文件。.class是java虚拟机上的字节码文件，是JAVA虚拟机上的可执行文件，java源文件在经过编译之后会在其目录下生成源文件中每个类的字节码文件
JAva的包，包是java中组织类和管理类名空间的方式，位于不同包中的类及时同名也不会冲突，包实际上是类的容器并且提供了类的可见性限制机制，package关键字用于将文件中对应类的字节码文件装入包中，从操作系统的观念看，每个package对应一个逻辑文件夹。

#

每个属性和方法都显示声明的发那个文权限，不使用默认权限。
对于裸机上对外不可见的属性和方法尽量设置为private，虽然java语言中同一个包中的其他非子类可以相互访问，但不推荐。
将逻辑上相关的类组织在同一个包中，以包的形式组织程序的类。

java中的数组

int [] arr =  new int[3];int [][] brr = new int[2][3];//brr[0] = new int[2]:int[]//brr[1] = new int[3]:int[]对象数组：Point p[] = new Point[4];p[0] = new Point(3,5);p[1] = new Point(4,6);p[2] = new Point(7,8);p[3] = new Point(5,9);foreach数组遍历：String[] names = {"tom","lucy","johy"};

for(string name:names)
{
System,out.println(names);
}

java的异常

异常是在程序运行过程中发生的异常事件：除0溢出、数组越界、文件找不到
为了加强程序的健壮性必须考虑可能发生的异常事件并做出相应处理，iava中通过面向对象方式处理异常
java中把可能产生异常的程序语句“放入”try语句块中，在try语句块后必须跟上一个或者多个catch语句块。每个catch语句块处理一种类型的异常，当对应异常产生的时候catch语句将执行，catch语句块后面可以跟上finally语句块，finally语句块一定会被执行的语句块
java的异常总是由某一条语句触发的
throw new NullPointerException(“oops,the parameter is null”);
try{
}
catch(Exception e)
{
System.out.println(e.getMessage());
}
###总结：
try用于定义可能发生的异常代码段，catch代码段紧跟在try代码段的后面，try后面可以有一个或者多个catch代码段，如有多个catch代码段那么程序智慧进入某一个catch，catch扑捉的多个异常之间由继承关系。

java中的泛型

基本概念：泛型是一种将数据类型参数以最大限度的进行代码重用的技术。
为什么需要泛型？取两个数的最大值函数max，链表类
java中泛型你的最小定义单位是类，java定义的泛型的类叫做泛型类。
###泛型类的定义
在类声明的同时通过<>声明泛型参数，<>中声明的类型参数可以用于定义类属性和方法。
泛型类的生命的类类型可以在定义引用创建对象时传入类型参数
传入类型实参后创建的对象是一个在逻辑上处理特定类型的“专用”对象
class list{}
public class Tesr{
public static void main()
{
Listlist1 = new List();
Listlist2 = new List();
}
}
list和List是由同一个泛型类实参化得到的泛型类。但不能相互赋值。
##深入泛型
泛型其实是一种模板机制，通过泛型就可以创建出任意个处理特殊类型的类，理论上可以把任何一个类都定义成泛型类。实际的开发中一般吧容器类型的类定义成泛型类（如链表、栈、队列），可以在定义泛型类时指定任意个类型参数，声明引用和创建对象时必须指定所有的类型参数，定义泛型类的构造方法时不需要增加泛型声明。

泛型的本质

store和Store只是被编译器识别成“不同”的类。

java中的回调与事件