java基础概念整理，上课培训笔记，希望大家指正不足

字节码文件放在方法区，对象在堆，栈存放对象的临时变量，垃圾回收机制回收的是堆区的内存。

java跨平台是因为java针对jvm（java虚拟机）编程，jvm不跨平台

主类是编译器的入口

主方法是虚拟机的入口，主方法可以不在主类中

lang包里面的六个类：String SystemInteger Exception Thread Math

类是事务在问题领域的抽象

实体完整性：唯一标示，主键

参照完整性：外码必须是外部表的主键或者是空

自定义完整性：例如性别为男或女，不可违背，年龄不可超越某个值

Jajava源文件的基本结构：

打包编译：javac –d . 文件名.java;

常用的包：

Java.lang,    java.util   java.io   java.net  

 

基本数据类型：int boolean char byte float double long short

复杂类型：即引用类型{类、接口、数组}

引用类型中：

Students1=new Student();

s2=s1;

s1给s2 的是s1中存放的内容，不是s1自己的地址。

变量：

1、局部变量：调用时开辟空间，一定在栈区开辟空间，必须赋初值，

2、全局变量：（包括实例全局变量、静态全局变量也叫类变量）

（1）在类中定义的变量就是实例全局变量，创建对象的时候在堆区开辟空间，可开辟多次空间，用对象访问。在对象销毁的时候释放

（2）静态全局变量在加载类时开辟内存空间，在栈区开辟空间，仅开辟一次内存空间，用静态初始化块初始化。可为所有对象引用。程序不关闭一直存在。静态全局变量最大弊端：增加对象间的耦合性！不存在this指针！

静态变量 若为int n;不用初始化就有值为0；

Strings=new String (a String);

以上代码会出现内存泄露！（String s已经在栈区创建空间，现在将new的对象给s，new的对象的内存在堆区中，s指向对象，则s开辟的空间造成内存泄露）将创建对象语句放在主方法里面。

Jdk中只对Integer String Date File 重写了equals方法

Java中位移是循环位移，int型共32位，若右移33位，相当于右移1位！

题目： 1、模式匹配

2、排序

3、单例

(1)单例类只能有一个实例  

(2)单例类必须自己创建自己的唯一实例。 

(3)单例类必须给所有其他对象提供这一实例。

短路与和非短路与

&&短路与     &非短路与（前一个为FALSE，后一个继续执行，返回值还是FALSE）

||短路或     |非短路或（前一个为TRUE，后一个还是继续执行，返回值为TRUE）

 

 

switch语句的选择值：short byte intchar switch语句中的选择值是能够自动转换成int的值，short byte char都是可以自动转换int的类型，long会损失精度。

若是char n=2;

Intm=n+1;m的值是3，单独输出n,则输出的是2对应的ASCII码

循环语句：

Continue是跳出本次循环，break是跳出本层循环。即continue是终止一次循环，但是不会跳出for循环。Break是跳出for循环

 

System.in标准字节输出对象

System.in.read()从键盘缓冲区读取字符

While(true){

Intk= System.in.read();

System.out.orintln(k);}

若输出，则输出的k是三个字符的ascII码 ，分别是键盘敲的字符，\r和\n

*作业：找到子串在父串的所有位置，并模块化

*将子串在父串的位置替换成新串

charAt(找到子串的位置) replaceAll(替换子串的方法)

 

数组：

数组也是一种引用类型。数组的元素可以是简单类型的数据，也可以是引用类型的数据。

 

int[]intArray;

int[]num=new int[]{1,2,3,4,5,6};

以上的数组初始化与int []num={1,2,3,4,5,6};原理一致

选择：

For(inti=0;i<10;i++){

For(intj=i;j<10-1;j++){

If(a[i]>a[j]){

   a[i]与a[j]交换；

}

}

}

冒泡：

For(inti=0;i<10;i++){

For(intj=0;j<10-i-1;j++){

If(a[j]>a[j+1]){

交换；

}

}

}

 

 

Arraycopy是java给lang提供的静态方法，用于从一个数组拷贝数据到另一个数组

int[][]a=new int[3][];

int[][]a={{1,2},{2,3},{3,4}}

变量只有a ；对象有a[][] a[0] a[1] a[2]四个对象 ；元素有 1,2,2,3,3,4，{1,2}，{2,3}，{3,4}共九个元素

 

 

上转型父类引用性变量指向子类对象，1、只能访问子类对象继承或者隐藏的属性，2、不能访问父类新增的方法或属性和子类新增的方法和属性

*创建子类对象不会创建父类对象，用父类的引用创建子类的对象，为的是用父类的构造方法为子类没有继承的父类的私有属性创建空间

子类继承父类的方法，用子类对象调用此方法，调用的就是子类方法，this指针指向的也是子类。                                                           

父类不提供构造方法，子类对象不能被创建！子类想使用父类的私有属性，必须调用父类的方法。子类在创建的过程中，父类的私有属性会开辟空间，但是不能直接使用。

用父类的引用创建子类的对象，创建的对象不能访问子类新增的属性和方法。需要造型！

用父类的引型变量创建子类的对象，访问子类重写的父类的属性（或者静态方法），访问的还是父类的属性（或者静态方法）。这种叫做隐藏

 

 

        父类的引用类型创建子类对象，访问子类继承的父类的方法，子类继承的父类方法调用

 

 

*重载：

方法名相同，参数签名不同，叫做编译多态，也叫静态多态，静态连边。

特别说明：主方法也可以被重载，静态方法也可以被重载，抽象方法也可以被重载

 

*重写

子类对父类的重写只能一次，子类重写的访问权限必须大于或等于父类该方法的访问权限。

派生类对基类的重写叫覆盖，对属性或静态方法的重写叫隐藏

！！！私有方法不能被重写和覆盖。

！！！引用类型都是4个字节

AnimalmyDog=new Dog(“mydog”);用父类的引用变量创建子类对象，不能直接访问子类新增的方法，则需要下转型

1、造型发生在子类继承父类之间2、造型发生在上转型的前提之下3、造型不改变对象的本身的类型

//判断myDog对象是否是Dog类型，

If(mydoginstanceof Dog) {

  ((Dog)myDog).bark;

 

 

作用域    当前类 同一package 子孙类 其他package

public    √     √          √       √

protected  √     √          √      ×

friendly   √     √          ×      ×

private    √     ×          ×      ×

super关键字  this关键字

super可用于调用父类中定义的属性。

super可用于调用父类中定义的成员方法。

super可用于调用子类构造器中调用父类的构造器。

super的追溯不仅于直接父类

 

1、出现在子类构造方法中：super子类显式的调用父类的构造方法（父类的构造方法重载了）super(20);(调用父类有参的构造方法)，不写super默认调用无参的。

2出现在任何地方，用super调用子类覆盖或者隐藏的方法或属性  super.showname();!说明：showname()被子类覆盖

 

this:

当new的时候，就有了this指针，this指向的是这个对象的地址。可以传给构造方法，或者实例方法/实例变量，也可以自动拥有this指针。静态变量和静态方法没有this指针，与类关联，与对象无关

特别注意：1、当用父类的引用创建子类的对象时，调用子类无参的构造方法，子类会自动调用父类的无参构造方法，再返回来调用子类构造方法。若子类调用有参的构造方法，如果需要调用父类有参的构造方法，需要super（参数）,若没有this也没有super，则自动调用父类的无参构造方法  

2、在调用构造方法时，先为新增的属性创建空间，再用初始化块初始化变量，最后调用构造方法。

PublicPerson(String name,int age){

this(name);//调用本类中带一个参数的构造方法

****//代码

}

V型图

PublicPerson(String name){

this();//调用本类中不带参数的构造方法

****//代码

}

调用三个构造方法，创建的是同一个对象。

注意：this和super不能同时出现在同一个构造方法里

//初始化块

{

对类中的属性进行初始化的语句。

}

//初始化块在构造函数之前被调用，初始化块在被调用之前，被初始化的变量必需先开辟空间。位置写在类的最后。

 

 

*作业：

V型图：

 

Java特点

Java面向接口编程

Java清晰第一，效率第二

封装类：

1、封装类重写了tostring和equals

2、Integer i=newInteger(10);创建封装类,封装类是final的，不能被继承

3、Integerk=Integer.valueof(“12”)双引号里面的值必须是封装类对应的基本数据类型的字符串，创建封装类对象

4、封装类的作用：(1)基本数据类型和String类型进行相互转换(2)基本数据类型和封装类的对象可以进行相互混合计算(jdk1.5以上版本)

5、java使用封装类的目的是为了使java的数据类型也符合面向对象的基本属性

 

重写toString()方法:

String，封装类，exceptionInterfaceAddress Date重写了tostring方法，集合重写了toString

Object类中，定义了toString，所以，所有类中都有toString方法，只是没有重写。

如果给一个引用型变量一个值为null，输出引用型变量，输出的也是null；

Personperson01=null;

System.out.println(person01);//输出为null

 

 

 

 

 

 

存放地址的空间字节数就是4

在java中任意定义一个类，都会继承equals方法。但只有四个类覆写了equals（）；String 封装类 Date File

This.getClass得到的该对象所映射的对象类型名

*作业：6-14例子中为市民添加几个不同类型的属性，覆写equals方法将属性进行比较

Static关键字

Static与属性、方法、初始化块、内部类四个关联

类的执行过程：1、加载类到内存空间2、有static则先为static的属性或变量开辟空间和初始化，3、加载主方法到内存空间4、创建对象，对象自动获得静态属性的引用。

Static的属性的初始化在调用主方法之前。所以创建多个对象，而静态方法或属性只会开辟一次空间，创建一个新的对象，该对象自动获得静态属性的引用。

注意：构造方法不能对静态全局变量初始化。但是构造方法可以改变静态全局变量的值。

 

 

单例模式：

1、只能创建一个对象。对外不提供构造方法

创建饥汉模式的单例：1、构造方法私有化2、定义静态全局变量instance，创建一个对象。3、对外提供公有的静态方法(public static voidgetInstance())，得到instance

创建饱汉（懒汉）模式单例：1、构造方法私有化2、定义静态全局变量instance，先不创建一个对象。3、对外提供公有的静态方法（public static void getInstance()），判断instance是否为null，如果为null，则创建对象，然后得到instance

先加载类到方法区，再将静态全局变量instance加载到方法区，创建对象，对象的名字即对象的引用，即instance放在堆区，成员变量放在堆区。当创建对象时，自动获得指向该对象的instance指针。

 

 

只有方法没有属性是充血类

只有属性没有方法是贫血类

*作业：把单例背下来

final关键字

①final类不能被继承，②final方法可以被继承，不能被覆盖，③final普通类型变量也会开辟空间，只能初始化，不能被赋值，不能更改！④final引用类型变量，存放的地址固定，但是地址指向的属性可以更改。

局部变量和形参都可以用final修饰，其实什么变量都可以加final。

 

Abstract关键字：

① 抽象类不能创建对象，即不能被实例化②抽象类可以被继承，继承抽象类，必须重写抽象类的抽象方法③抽象类可以有构造方法，但不能创建对象

如果类里面的所有方法都不是抽象方法，但是本类仍然可以定义为抽象类。

在以下条件下必须定义为抽象类：

1、   类中至少有一个抽象方法

2、   类继承了父类中的抽象方法，但是没有覆写

3、   类实现了某个接口，但没有全部实现接口中的方法

 

 

父类的方法在子类中有不同的实现就是多态，也叫动态多态。用父类的引用创建不同子类的对象

*作业：7-0  polyMorphism.java改为模块化

 

 

接口：

接口不是特殊的抽象类！接口里的属性默认是final，static，public的。接口里的方法当然全是抽象的，接口没有构造方法。

 

接口的隐形变量指向实现接口的类的对象，叫接口的回调。但是该对象不能访问类的新增的方法，需要下转型（造型）。

①和类不同的是，一个接口可以继承多个父接口

②多个无关的类可实现同一个接口。

③一个类可实现多个无关的接口

接口就是一个方法的标准和规范，没有接口依然可以实现类和方法，但是不利于管理。

业务层和持久层之间增加接口，则可以使业务层和持久层的耦合性降低，即用户需求的变化对持久层的影响降到最低

在实际项目当中，很少在接口中定义属性。

 

随堂说明：当一个类创建一个对象，则此对象自动拥有该类的属性，即有了this，可以引用该类的属性或方法

内部类

主要是：实例内部类，方法内部类。

实例内部类：

特别说明：创建内部类自动拥有包含该内部类在内的外部类的引用。即(外部类.this)

创建内部类的几种方法：

 

1、先有外部类的对象，外部类名.内部类名引用名= 外部类对象引用名.new内部类名();

2、在外部内中定义一个方法，在外部内的实例方法中创建内部类对象。

注意：内部类之间不能共享内部类的属性。内部类可以指定调用外部类的属性，即用外部类对象的引用.this.属性名访问。

内部类之间可以相互创建对象

如果内部类是私有的，那么不能在外部创建内部类对象，必须通过调用外部类的方法创建

 

 

 

方法内部类：

概念：定义在外部类的方法里面的内部类

方法内部类只在方法中使用。不能通过外部创建，只能在方法中创建

方法内部类被创建之后，自动拥有包含给方法的外部类的引用。

拥有内部类的外部类的方法的参数和定义的属性必须定义为final类型，前提是内部类需要使用该方法的属性

 

内部类总结：不管是方法内部类还是实例内部类，内部类在使用属性时，若直接写属性名a，如果内部类中有这个a,外部类也有a,则优先调用内部类的属性，若要使用外部类的属性，则需要写(外部类.this.a)

 

 

异常：

处理异常的目的是使程序能够正常运行

异常分为：error和exception

Error:jvm系统内部错误、资源耗尽等严重情况

Exception:运行时异常（程序可以控制的，比如空指针等）、编译异常（不可预知的异常）

 

异常数据结构：

基类：Throwable类中有一个私有的属性message，提供了一个公共的final的方法getMessage()，不能覆写;Throwable中不提供setMessage()方法，只通过构造方法设置message的值，子类通过super(message)设置值

异常类覆写了toString()；

 

注意：一个父类的方法不处理某个异常，throws出之后，子类继承父类，并覆写该方法时，throws的异常必须是父类抛出的异常类或父类异常的子类或不抛出异常

 

*作业：1、8-1  exampexception.java 2、aaa包中的细化try-catch

 

注意：在易出现异常的代码块，最好一行代码一个try-catch，并且最好用更准确的异常类捕获，最好不用exception全部来捕获，细化更好

 

Throw和throws都是处理异常的

不同点：

1、Throws出现在方法的说明部分，主方法也可以加throws，但是没意义，调用主方法的是虚拟机，不处理异常。throw出现在方法体

2、throws后面跟着一个活多个异常类，throw只能跟一个异常对象

3、throws不一定有异常发生，有throw就一定有异常抛出throw是程序员手动抛出异常 throw new Exception（“message”）;

 

 

对于运行时候的异常，如果某一个方法中没有声明抛出异常给调用该方法的地方（即没有throws），则默认将异常抛回调用此方法的地方！

 

 

有try可以没有catch，但是没有catch就必须有finally。

一个try可以对应多个catch

有try-catch可以没有finally

 

Finally不管出不出现异常，都会执行。

 

Throws和try-catch不矛盾

Publicint fun2()throws Exception{

   Try{

         Int a=10/0;

return 3;

}catch(ArithmeticExceptionex){

Throw new exception(“wrong”);

} finally{Sysotem.out.println(“”);

           //return 5;

}

            }

以上代码，先出现异常，被catch捕获，但是catch语句中有手动抛出了一个异常，这个异常没有继续try-catch，抛给调用本方法的方法。如果以上方法中finally里面出现return会掩藏出现异常

结论：

1、如果在一个方法的finally语句中有return语句，有可能会影响正常代码块的返回值。

2、如果在一个方法的finally语句中有finally语句，有可能影响处理异常的catch块里的返回值。

3、如果finally中出现return可能会隐藏出现的异常，所以一般不要在finally中出现return

 

编译异常：在编译时，如果不try-catch这些异常，就会导致编译失败，例如进行文件操作时，如果不对可能发生的文件不存在或者文件读取失败异常处理，则会出现编译异常。（即程序不可控的异常）在程序运行过程中，也可能会抛出异常！（即文件果真不存在，则抛出异常）

运行异常：例如要求用户手动输入两个值时，当进行除法运算时，若有一个值是0，则会出现异常，这就是运行异常，通过程序更改或者控制，是可以排除的。也可以不进行更改代码，用try-catch搞定。

 

 

Java处理异常原则：1、避免运行时异常，最好不让编译异常影响程序运行2、在处理异常过程中，try块不宜过大，3、不要放与异常无关代码到try块中4、不要用一个exception接收所有异常5、如果用catch捕获异常，必须处理。要不就往上抛6、尽量不要嵌套异常

 

 

最新技术：Properties存储数据（example 9-3）

 

 

项目：表示层com.cx.bank.text业务层：com.cx.bank.message持久层：model，只有money属性

Util包：两个类，余额不足，存款格式异常

表示层：执行存款，取款，转账，查询余额

 

控制台输入/输出：

System.out

System.in

System.err标准字节输入流对象

系统调用system的静态方法创建

 

 

 

Math:

Math类是final，不能被继承的

Math不提供构造方法，不可能创建对象

Math所有的方法都是static，PI和E两个属性也是static并且是final的， PI是圆周率E即e

截取：ceil大于某个数的最小整数（double），floor小于某个数的最大整数(double)，round求45度  abs求绝对值

 

String:

Strings1=”text”;

Strings2=”text”;

S1==S2返回值为true，因为s1和s2指向的是同一个对象。

Strings1=new String(“hello”);此处创建了两个对象，一个在方法区，一个在堆区。Hello是String创建的常对象，在方法区，s1是引用对象，在堆区创建

Strings2=new String(“”);创建了空对象，对象的值不是null，是“”；

StringBuffer

StringBuffer只能new出对象，无常量

Stringbuffer中只有16个字符供追加时扩展的缓冲区，当append追加了100个字符，先会判断100是否大于16，大于则自动扩展，不会截取前16个。

1、与String不同的是，更改字符串的长度或内容，是在原字符串上追加，不会创建新对象。即String不可改变。

2、StringBuffer没有重写equals,因此stringBuffer的对象引用用equals比较，即使指向的对象一样，还是false，与等值==比较无异

3、Stringbuffer不支持连接，即+不支持

4、Stringbuffer类型调用toString，先在堆区创建String类型的对象，然后把Stringbuffer里的字符串放在String类型对象里，最后返回的是String对象的地址，String对象的地址主动调用toString，输出String类型地址，即Stringbuffer里面的值。

 

 

 

集合：

数组和集合

共同点：存放元素的容器

不同点：1、数组长度是固定的，集合长度是不固定

2、数组既可以存放基本类型，也可以存放引用类型，集合只能存放引用类型的数据，即只能存放对象的地址。

3、数组存放的元素类型必须一致，而集合存放的元素可以不同

4、数组元素有序，可按下标访问，集合除list以外，基本是无序的。

5、数组元素可以相同，而集合元素不能相同，除了list

6、数组一旦创建，不可添加或删除元素。集合可以

7、数组没有覆写toString，集合覆写了toString。

8、集合一般是接口

Iterator和enumeration是结合接口，Iterator()和enumeration()是迭代器。

Collection和map都重写了toString，集合的基类接口。

 

 

Listlist=new arrayList();

System.out.println(list)；结果是[]，若list里面add了值，则输出的是各个元素，即[各个元素]。

集合除了list都是无序不可重复的

 

Setset=new hashSet();

System.out.println();

Iteratorit=set.iterator();//创建Iterator接口的对象，得到了set的迭代器；

While(it.hasNext){

  Systm.out.println(set.next());

}

结果与list一样，但是如果有值时，值不允许重复，且输出的顺序是无序的！

 

List输出的三种方式：直接1、system.out.println 2、用下标访问，3、用迭代器

 

Map<key,value>key一般是stringvalue一般是object类型。Key value在一起，叫entry，类型是map.entry

 

Map中放完值后，直接system.out.println(map);{key1=value1,key2=value2,.}并且输出是无序的，map是不可重复的，无序的。

map如果要遍历，需要将entry或者key放入set集合中，Setset=map.entrySet();再利用set集合的迭代器进行遍历。  map没有迭代器

（老师现在把我们引向一个更深的领域，是不是正确的呢？）

 

 

 

文件过滤器：

1、手工模拟回叫

2、递归搜索

回叫：

Filefile=new File(path);

String[] list=filr.list(new fileter());

其中fileter实现了implements FilenameFilter方法。自动调用accpect()方法