JavaSE

一：java语言基础：

c,c++,java的学习，开始都得学习表达式，变量，函数，流程控制结构，数组这些最基础的内容，而它们的内容又几乎差不多

(1)java数据类型：两种：基本数据类型跟引用数据类型

基本数据类型分为四大类八小种：

整型：byte short int long

浮点型：float double；float定义的变量，赋值时候要加f，float a=12.8f

字符型：char ；

布尔型：boolean

1.Char能不能存储汉字？

Char是用来存储Unicode编码的，Unicode中包括汉字，所以char可以存储汉字，但是一个汉字不在Unicode编码字符集中，那么就没法存储；char变量占用两个字节；int占4个字节

2.switch(ch)语句中ch的类型是哪几种？

整型跟字符型表达式，long跟String不可以

 

引用数据类型：类，数组，接口，枚举；存储的是对象的引用

String是一个类，是引用数据类型

(2)基本数据类型对象包装类

全部位于java.lang包下

Byte，Short ，Integer， Long，Float，Double，Character，Boolean，它们都是Number的子类；

Java中的自动装箱跟自动拆箱机制，可以使用面向对象的方法，操作基本数据类型；

将int类型数据封装成Integer对象，调用floatValue()方法，以 float类型返回Integer值

 

 

 

二：数组、函数、跟String

一：数组

1.常见数组类型：

整型数组,浮点型数组，String类型数组，对象数组

Object[] 里面用来存储对象的，但是数组的容量一旦定义了，不可更改，后来就出现了集合框架àjava collections framework，专门用来存储对象的

 

2.数组在堆栈内存中的操作

int [] a=new int[10];

拆分成两步

int[] a=null;--à数组是引用数据类型的,在栈内存中定义

a=new int[10];-à在堆内存中开辟空间

引用a指向了new int[10]的位置，此时将堆内存的使用权交给a；

 

3：数组赋值分为动态赋值跟静态赋值

上面开辟了堆内存空间，现在给元素赋值

a[0]=7;a[2]=2………..动态型

int[] a={0,2,2,2};赋值同时，指定开辟大小为4的空间--à静态型

 

4：数组常见异常：

ArrayIndexOutOfBoundsException

5：数组常用方法

数组名.length-à不是length();

Java.util.Arrays

sort()

fill()填充数组，[fromIndex，toIndex )包括开始，不包括结束

toString

 

6：数组的七大算法(遍历，求和(求积)，极值，查找，倒置，排序，插入)

1：遍历

       遍历就是把这个数组的每个元素显示出来遍历的方法就是先定义这个数组的大小

       然后用FOR循环来完成数组例如【1：for装元素 2：for取元素】

这个就是一个double 型的数组用for去遍历每个元素而结束条件就是这个数组的最后一个数组 score.length就可以遍历这个数组了

 

2：求和(求积)

 

3：极值

极值的目的就是求一个最大值或者最小值

方法就是假定数组里面的一个数据是最大的然后用其他的数据遍历他与他进行对比,

如果新的数据值比这个定义的值大的话那么就替换他的这个位置然后继续遍历

遍历结束后就输出这个值就是最大的值或者最小的值  例如

4：查找

判断方法就是当用户输入的值与数组中的某一个值是一样的那么就输出

否则(else)就没找到

代码中的booleanflag=false；是为了跳出多重循环而设定的

 

5：倒置

倒置的意思就是最后一个元素变成第一个元素第一个元素变成最后一个

过程就是折中取半，不遍历整个数组了遍历一半，那么就/2就可以，但是计算机数数的方法是从0开始的,也就是说最后一个值里面是没有任何意义的，所以要在最后一个值那-1,并且还要定义一个空的变量  因为要用到三步换值（变量）;

 

 

 

6: 排序:

排序种类很多，数据结构中的，现在讲解两种

(1)   Arrays的sort()方法

(2)   冒泡排序：(前后两个数字做比较，小数放在前面，大数放在后面)

外循环变量设为i，内循环变量设为j。假如有10个数需要进行排序，则外循环重复9次，内循环依次重复9，8，...，1次。每次进行比较的两个元素都是与内循环j有关的，它们可以分别用a[j]和a[j+1]标识;

 

7:插入

 

 

 

 

二：函数

 Overload-----在同一个类中【这属于java函数的知识，即方法重载，方法重载的表现形式：方法名相同，参数个数不同，参数类型不同(在参数个数相同的前提下出现)，返回类型跟修饰符可以相同，也可以不同】

 

 

 

三:Sring

(一)String的特殊之处

1.      一个字符串就是一个匿名对象

2.      String是final的，不可被继承

3.      要想比较String的内容，必须使用equals关键字，要是比较String的引用地址，就用==

4：不管上面操作，String的内容都不会被改变

String s=”张三”;

str=s+”李四”;

syso(str);à此时打印的内容是“张三李四“;但是原有的str的内容还是”张三“，只是此时的str不再指向它了，它只能等着垃圾回收机制回收了

(二)String常用方法

 

(三)String跟StringBuffer区别

1.String内容不可更改，StringBuffer内容可以更改

2.String可以直接赋值，StringBuffer不可以直接赋值，需要new

3.String连接字符串使用+,StringBuffer连接字符串使用append()

4:String覆盖了equals()跟hascode()方法，可以存入集合中，StringBuffer没有实现这两个方法，不能存入集合中

 

StringBuffer可以任意插入内容，使用insert()，也可以反转内容reverse(),replace(),delete();

选择：当频繁操作字符串中的内容，使用StringBuffer；

 

StringBuffer跟StringBuilde的区别

StringBuilde是jdk1.5的新功能

区别就是：前者线程同步，后者线程不同步，优先考虑StringBuilde；它们的方法都一样

 

 

 

 

                     面向对象---封装、继承、多态

一：封装性

       Java宝典书籍《Thinking in java》在封装性这一节提出：把数据和方法包装进类中，以及具体实现的隐藏，常共同称为封装；公式表现出来-à数据跟方法(函数)封装在类中+具体实现的隐藏=封装；

而且声明的变量要跟调用这些变量的方法放在一起，且将变量声明为私有的private的，只有这个类中的方法才可以访问这些成员属性，就称之为封装！看个小小程序

      

publicclassOOPTest {

   

    privateStringname;

    privateintage;

   

    publicOOPTest(String name,int age) {

       super();

       this.name= name;

       this.age= age;

    }

 

    publicvoidzuofan(){

       System.out.println(name+"你去给我做饭。。。。。。");

    }

   

    publicvoidshenghaizi(){

       System.out.println(name+"我俩结婚3年了，你也快"+age+"岁了，赶紧给我生个孩子");

    }

   

    publicstaticvoidmain(String[] args) {

       OOPTestoopTest=new OOPTest("如花",30);

       oopTest.zuofan();

       oopTest.shenghaizi();

    }

   

}

  

打印结果：

如花你去给我做饭。。。。。。

如花我俩结婚3年了，你也快30岁了，赶紧给我生个孩子

 

上面的代码就是在一个类中定义了一个女人所共有的属性跟功能，做饭跟生孩子是功能，名字，年龄是属性，这是对所有女人的抽象。在main方法中通过OOPTestoopTest=new OOPTest("如花",30);

来给你创建一个真真的媳妇，名字叫如花的媳妇，在java跟C++中对象都是通过new关键字来体现出来的！在java中除了通过new关键字创建对象，也可以通过在反射、clone()方法、序列化的方法创建对象，也有的人说单例设计模式也算一种，其实单例设计模式是将构造方法私有化，在类的内部创建对象，保证的是对象的唯一性，而不是不通过new关键字创建的对象！单例设计模式也是Spring开源框架的设计思想之一；

 

封装性知识还涉及构造方法、匿名对象、this关键字、static关键字、构造代码块、静态代码块、main()方法作用、构造函数私有化(单例设计模式)等内容！先暂时放一下，回顾一下继承、多态的知识，再回来继续复习

 

继承性

现在有学生，工人，人三个类，学生跟工人都同属于人这个类！那么现在的代码如下

 

packagetest;

 

publicclassPerson {

   

    privateStringname;

    privateintage;

    publicvoid eat(){

       System.out.println("是人都要吃饭");

    }

}

 class Student{

     privateStringschool;

     privateStringname;

       privateintage;

       publicvoideat(){

          System.out.println("是人都要吃饭");

       }

       publicvoidstudy(){

          System.out.println("学生上课");

       }

 }

 

 class Worker{

     privateStringtool;

     privateStringname;

       privateintage;

       publicvoideat(){

          System.out.println("是人都要吃饭");

       }

       publicvoiduseTool(){

          System.out.println("工人使用Tools干活");

       }

 }

 

说一下：一个java文件中的public class只能有一个，而且该类名要与文件名一致；

以上的Student，Worker类某些属性跟方法与Person类的重复，就会使得代码变得冗余；这时候，Student类跟Worker类就可以继承Person类，那么name，age属性跟eat方法就可以不用写了！上面的代码就可以精简成以下的形式

 

packagetest;

 

publicclassPerson {

   

    privateStringname;

    privateintage;

    publicvoid eat(){

       System.out.println("是人都要吃饭");

    }

}

 class StudentextendsPerson{

     privateStringschool;

       publicvoidstudy(){

          System.out.println("学生上课");

       }

 }

 

 class WorkerextendsPerson{

     privateStringtool;

       publicvoiduseTool(){

          System.out.println("工人使用Tools干活");

       }

 }

 

在Student跟Worker类中就默认的包含了Person中的属性跟方法，其实在java中的任何类都是extends于Object类的，所以Student类中不仅有study(),eat()方法之外，还包括Object类中的方法！Object类的将在java常用API中讲解

java中的继承，其实就是子类扩展了父类的功能，在java程序设计，儿子都是比老子有前途的！

 

继承的限制：

(1)   java中不允许有多重继承，只能存在单继承，但是可以有多层继承！java中的多态，在一定程度上就是在为了拟补多重继承的不足；

(2)   子类不能直接访问父类的私有成员属性，需要通过父类的setget方法去访问

 

 

继承的深入：

(1)    子类在实例化的时候，要先调用父类的构造方法，用super关键字调用-à这些知识将在本节的结尾用一道综合性的程序题目来体现

(2)   子类在Overrride父类的方法的时候，方法的权限一定大于父类方法的访问权限

 Java的访问权限四种

Public protected  default private

Public 访问权限最大，到处可以访问

Protected 只能是该类的子类都可以访问，不论是本包中，还是其他包中

Default：默认的访问权限，只能在本包中进行访问

Private：只能在本类进行访问

 

下面看继承性的两个很重要的知识：抽象类跟接口

在上面的PersonStudent代码修改

 

packagetest;

 

publicclassPerson {

    publicvoid eat(){

      

    }

}

 class StudentextendsPerson{

    publicvoid eat(){

       System.out.println("学生吃的饭稍微好点");

    }

 }

 

 class WorkerextendsPerson{

     publicvoideat(){

          System.out.println("工人可能吃的饭稍微差点");

       }

 }

 

学生类跟工人类都要吃饭，只是吃的有好有差；这时候Person类中eat()方法就没有必要再说吃些什么了，由具体的子类去决定自己吃什么，所以可以给Person类修改为抽象类

packagetest;

 

public abstractclassPerson {

    publicabstractvoideat();

    publicvoidsleep(){

       System.out.println("sleep...");

    }

}

 class StudentextendsPerson{

    publicvoid eat(){

       System.out.println("学生吃的饭稍微好点");

    }

 }

 

 class WorkerextendsPerson{

     publicvoideat(){

          System.out.println("工人可能吃的饭稍微差点");

       }

 }

(1)抽象类中要有抽象方法，也可以存在具体的实现方法；而一个类中只有存在一个抽象方法abstract修饰的方法，那么这个也得用abstract修饰，也就成了abstract类；

(2)抽象类不能实例化，只能通过子类来实例化；抽象类最常用的设计模式就是模板设计模式；可以参见SSH开源框架的知识

(3)抽象类虽然不能实例化，但是可以有构造函数【构造函数是给数据成员初始化的，抽象类既然不能实例化，为什么还能存在构造？因为抽象类里面也可以存在其他的实现方法】

 

 

接口

接口用interface来修饰

packagetest;

 

publicinterface TestInterface {

   

    publicstaticfinalStringNAME="张三";

    publicabstractvoideat();

}

 

以上就是一个接口， 固定格式：publicstaticfinal跟publicabstract，接口中的成员属性都是静态常量，不可更改，常量名要大写，且要赋值；

 

上面的接口可以简写成如下形式

 

packagetest;

 

publicinterface TestInterface {

   

    String NAME="张三";

     void eat();

}

 

接口存在的原因：

现在一个孩子既想有家产，又想有强壮的体魄，又想有出色的智慧；但是他老爸虽然有钱，但是身体不行，脑子也不聪明，正巧他的二表哥，三大爷具备这些功能，这些他的儿子就可以都拿来了！所以说，在现实生活中得不到的东西，在程序中是无所不能的！但是java中只允许有一个老爸，那么二表哥跟三大爷只能 用implements来现实了！

 

假设Father为抽象类；但是二表哥跟三大爷一定是接口

class Son extends Father implements 二表哥，三大爷{

       publicvoid财产(){

             Syso(“钱。。。。。。”);

}

Public void 身体好(){

       Syso(“身体好”)；

}

Public void 智慧(){

       Syso(“聪明”);

}

 

}

 

Java中不允许存在多重继承，但可以允许实现多个接口；接口可以继承多个接口，中间用逗号分开；

后面还会有综合性的程序来体现OOP的三大特性；

      

 

 

三大特性之--------多态

 

多态：同一消息被不同的对象所调用，会产生不同的行为结果，就是多态；

 

多态的产生是因为存在继承性；

 

多态的三个条件

(1)   继承关系

(2)   子类重写父类的方法

(3)   父类引用指向子类对象

 

多态的体现：

(1)   Override ----在继承关系中

(2)   Overload-----在同一个类中【这属于java函数的知识，即方法重载，方法重载的表现形式：方法名相同，参数个数不同，参数类型不同(在参数个数相同的前提下出现)，返回类型跟修饰符可以相同，也可以不同】

 

 

接口跟抽象类的区别：

 

语法上的比较

1.抽象类可以有构造方法，接口中不能有构造方法。

2.抽象类中可以有普通成员变量，接口中没有普通成员变量

3.抽象类中可以包含非抽象的普通方法，接口中的所有方法必须都是抽象的，不能有非抽象的普通方法。

4. 抽象类中的抽象方法的访问类型可以是public，protected和（默认类型,虽然

eclipse下不报错，但应该也不行），但接口中的抽象方法只能是public类型的，并且默认即为publicabstract类型。

5. 抽象类中可以包含静态方法，接口中不能包含静态方法

6. 抽象类和接口中都可以包含静态成员变量，抽象类中的静态成员变量的访问类型可以任意，但接口中定义的变量只能是public static final类型，并且默认即为public static final类型。

7. 一个类可以实现多个接口，但只能继承一个抽象类。

 

实际应用中的比较：

       抽象类：模板设计模式

       接口：工厂设计模式、代理设计模式

具体参考SSH部分的《SHH三大开源框架的代码整合分析》

 

Java程序设计的原则：永远不要去继承一个已经实现好的父类，只能去继承一个抽象类或者实现一个接口

                                  

                                         

包、异常

一：包

相当于文件夹，除了public，类的访问权跟包有关系

 

二：异常

throws在方法体抛出异常，将异常交给方法调用者去处理，要写方法的调用者里面处理异常

throw抛出的是一个异常类的实例 throw new Exception(“测试”);

 

三：Exception跟RuntimeException

运行异常可以不处理，交给JVM处理

声明时异常必须处理，否则无法通过编译(IO中最多)

 

四：常见的RuntimeException

 

                     IndexOutOfBoundsException,

                                   |--ArrayIndexOutOfBoundsException

                                   |--StringIndexOutOfBoundsException

 

 

                     ArithmeticException

 

                     ClassCastException

 

                     IllegalArgumentException

 

                     SecurityException安全器异常

 

                     NullPointerException

 

                     NoSuchElementException

 

 

IO流

 

 

(一)字节流

 

InputStream                                                  OuputStream

|                                                                     |     

FileInputSream                                                FileOutputStream

DataInputStream    <------------------->       DataOutputStream-->RandomAccessFile()  --->seek方法，以字节为单位的，double占了8个字节

BufferedInputStream                                        BufferedOutputStream

                                                                      PrintStream

                           

(二)字节流

 

Reader                                                   Writer

               |                                                       |

  BufferedReader                                    BufferedWriter

InputStreamReader                     OutputStreamWriter

FileReader                                       |FileWriter 

                                                               PrintWriter

                           

(三)文件类

File