杰普Core Java课程笔记1

——年金波老师上课笔记

Core Java课程笔记1 1

编译执行java文件 1

生成Javadoc:标准的注释文档(html) 1

编译执行java文件

F:\杰普培训笔记>javac -d . ch01/HelloWorld.java

F:\杰普培训笔记>java ch01.HelloWorld

Hello World!

F:\杰普培训笔记>java ch01/HelloWorld 这样也可以

Hello World!

生成Javadoc:标准的注释文档(html)

F:\杰普培训笔记\core_java>javadoc -d doc ch02

F:\杰普培训笔记\core_java>javadoc -author -version -d doc ch02

window下默认字符编码:GBK

linux下的默认字符编码：utf-8

生成javadoc：标准的注释文档（html）

javadoc -d doc ch02; （不显示单行注释和多行注释。不显示）

win下默认的字符编码是：gbk

linux下默认编码是：utf-8

-d ：生成的文档放在哪里

-author：生成作者

-version:生成版本

java api 用javadoc 来生成的

java内存模型

1.堆区（heap）：放置新生成的对象

2.栈区（stack）：存在我们程序运行过程中的变量

变量：内存节点的值可以被重写

常量：内存节点的值不可以被重写

3.方法区：方法的信息，程序运行过程中类的信息

4.常量区静态存储区：存放程序运行过程中的常量

程序中随着数据的增加，堆地址不断地向高地址增加，栈地址不断地向低地址减小

String a = "abc";//常量区

String b = new String ("abc");//堆区

String c = new String ("abc");

String d = "abc";

a==b 错 b==c 错（两个不同的对象） a==d 对

==:用来比较地址（对于对象来说），比较值（对于基本类型）

java运行环境的搭建

JDK：JAVA DEVELOPMENT TOOLKIT //java 开发

JRE：JAVA RUNTIOME ENVIRONMENT //java 运行环境

jdk：编译源代码同时运行class

jre：运行class文件

配置环境变量

Unix ： PATH：命令搜索路径

cat .bashrc

oracle_home :说明了oracle的安装路径

java_home

env 查看所有环境变量

将java_home的bin路径添加到path里面

unix 用 '：' 分隔路径

path=$path:$java_home/bin

配置:

source.bashrc:环境变量立刻生效。

java中的类型

java是强类型语言，在定义变量的时候必须声明变量的类型

弱类型：声明变量不需要指定的类型语言

html css js 对于js来说是弱类型语言

在js里面声明任何一个变量都用变量一个声明 var

强类型的好处：在编译期进行类型检查，减少程序出错的概率。

强类型的坏处：灵活性差

1.基本类型

八种:

表示整数的： 4个 int（32位），long（64位），short（16位），byte（8位）

表示小数的（浮点数）： 2个 float，double

表示布尔类型的：boolean （true|false）表示判断条件

便是字符类型：char

2.引用类型

object 类：任何自定义的类都继承object

表示字符串的：多个字符

String 用来声明字符串（java.long.String）

ch02/PrimitiveTest.java

引用类型：类类型

类：对现实实体的抽象

包含属性和方法（函数）

属性：描述现实的实体

Person：name gender age

方法：操纵属性

java中的基本数据类型

例1：

package ch02;

public class PrimitiveTest

{

public static void main(String []args)

{

int ivar1=0x11; //16进制

int ivar2=011; //8进制

int ivar3=17; //10进制

float fvar1=12.5e5f;

double dvar1=0.1234d;

System.out.println("fvar1="+fvar1);

System.out.println("dvar1="+dvar1);

boolean flag=true;

System.out.println("boolean:"+flag);

System.out.println("ivar1="+ivar1);

System.out.println("ivar2="+ivar2);

System.out.println("ivar3="+ivar3);

char gender='F';

char test='\u0065'; //unicode码

System.out.println("gender:"+gender);

System.out.println("test:"+test

例2：

//java中的基本数据类型 .

public class PrimitiveTypeTest {

//private static PrimitiveTypeTest primitiveType;

private int i1;

public int getI1()

{

return i1;

}

public Integer getI2()//调用它是因为自动拆箱、装箱，所有不报错

{

return i1;

}

public int obtainInt()

{

return i1;

}

/**

public void initVal()

{

System.out.println("-----------------initVal int i1:"+i1);

primitiveType=new PrimitiveTypeTest();

}

private Integer i2;

public Integer getInteger()

{

return i2;

}

private byte b1;

public Byte getB1(){

return b1;

}

boolean bool;

public Boolean getBoolean()

{

return bool;

}

short srt;

public short getShort()

{

return srt;

}

long lg;

public long getLong()

{

return lg;

}

float flt;

public float getFloat()

{

return flt;

}

double dble;

public double getDouble()

{

return dble;

}

char cha;

public char getChar()

{

return cha;

}

public static void main(String[] args) {

PrimitiveTypeTest primitiveType=new PrimitiveTypeTest();

// byte

System.out.println("基本类型：byte 二进制位数：" + Byte.SIZE);

System.out.println("包装类：java.lang.Byte");

System.out.println("最小值：Byte.MIN_VALUE=" + Byte.MIN_VALUE);

System.out.println("最大值：Byte.MAX_VALUE=" + Byte.MAX_VALUE);

//Byte b1=new Byte("0");

//System.out.println("Byte默认赋值为："+b1);

System.out.println("byte默认赋值为："+primitiveType.getB1());

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

//-------------------short-----------------------

System.out.println("基本类型：short 二进制位数：" + Short.SIZE);

System.out.println("包装类：java.lang.Short");

System.out.println("最小值：Short.MIN_VALUE=" + Short.MIN_VALUE);

System.out.println("最大值：Short.MAX_VALUE=" + Short.MAX_VALUE);

System.out.println("short默认赋值为："+primitiveType.getShort());

//Short s1;

//short s2;

//System.out.println("Short默认赋值为："+(s1==0));

//System.out.println("short默认赋值为："+s2);

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

//-------------------------int-------------------------

System.out.println("基本类型：int 二进制位数：" + Integer.SIZE);

System.out.println("包装类：java.lang.Integer");

System.out.println("最小值：Integer.MIN_VALUE=" + Integer.MIN_VALUE);

System.out.println("最大值：Integer.MAX_VALUE=" + Integer.MAX_VALUE);

//Integer i1;

//System.out.println("Integer默认赋值为："+(i1==0));

//只有通过new 了之后才能取到默认值

System.out.println("int默认赋值为："+primitiveType.getI1());

System.out.println("int默认赋值为："+primitiveType.getI2());

System.out.println("int默认赋值为："+primitiveType.obtainInt());

System.out.println("Integer默认赋值为："+primitiveType.getInteger());

//System.out.println("int默认赋值为："+i1);

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

//--------------------------long-------------------

System.out.println("基本类型：long 二进制位数：" + Long.SIZE);

System.out.println("包装类：java.lang.Long");

System.out.println("最小值：Long.MIN_VALUE=" + Long.MIN_VALUE);

System.out.println("最大值：Long.MAX_VALUE=" + Long.MAX_VALUE);

System.out.println("long默认赋值为："+primitiveType.getLong());

//Long l1;

//long l2;

//System.out.println("Long默认赋值为："+(l1==0));

//System.out.println("long默认赋值为："+l2);

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

//------------------------float---------------------------

System.out.println("基本类型：float 二进制位数：" + Float.SIZE);

System.out.println("包装类：java.lang.Float");

System.out.println("最小值：Float.MIN_VALUE=" + Float.MIN_VALUE);

System.out.println("最大值：Float.MAX_VALUE=" + Float.MAX_VALUE);

System.out.println("float默认赋值为："+primitiveType.getFloat());

//Float f1;

//float f2;

//System.out.println("Float默认赋值为："+(f1==0));

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

//-------------------------double------------------------

System.out.println("基本类型：double 二进制位数：" + Double.SIZE);

System.out.println("包装类：java.lang.Double");

System.out.println("最小值：Double.MIN_VALUE=" + Double.MIN_VALUE);

System.out.println("最大值：Double.MAX_VALUE=" + Double.MAX_VALUE);

System.out.println("double默认赋值为："+primitiveType.getDouble());

//Double d1;

//double d2;

//System.out.println("Double默认赋值为："+(d1==0));

//System.out.println("double默认赋值为："+d2);

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

//---------------------char----------------------

System.out.println("基本类型：char 二进制位数：" + Character.SIZE);

System.out.println("包装类：java.lang.Character");

// 以数值形式而不是字符形式将Character.MIN_VALUE输出到控制台

System.out.println("最小值：Character.MIN_VALUE="

+ (int) Character.MIN_VALUE);

// 以数值形式而不是字符形式将Character.MAX_VALUE输出到控制台

System.out.println("最大值：Character.MAX_VALUE="

+ (int) Character.MAX_VALUE);

System.out.println("char默认赋值为："+primitiveType.getChar());

//Character c1;

//char c2;

//System.out.println("Character默认赋值为："+(c1=='\0'));

//System.out.println("char默认赋值为："+c2);

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

//-----------------------Boolean---------------------

System.out.println("包装类：java.lang.Boolean");

Boolean b=new Boolean(false);

System.out.println("boolean默认赋值为："+primitiveType.getBoolean());

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

}

二进制：原码、反码、补码

对于有符号的数而言(Java中全都是有符号的数)

二进制的最高位是符号位:0表示正数，1表示负数
正数的原码，反码，补码都一样(直接为此数二进制数表示)
负数的原码，符号为1，其余各位为此数的二进制表示
负数的反码=它的原码符号不变，其它位取反(1à0,0à1)
负数的补码=它的反码+1
0的反码、补码都是0
java中没有无符号数，换言之，java中的数都是有符号的
在计算机运算的时候，都是以补码的方式运算的

例：1-2=1+(-2)

计算[1+(-2)]在计算机中是以补码的方式运算的，首先计算：

[1的补码]+[(-2)的补码]

[1的补码]= 【0000000000000000000000000000001】

[(-2)的原码]=【1000000000000000000000000000010】

[(-2)的反码]=【1111111111111111111111111111101】

[(-2)的补码]=【1111111111111111111111111111110】

[1+(-2)的补码]=[1的补码]+[(-2)的补码]=【1111111111111111111111111111111】

然后，将 [1的补码]+[(-2)的补码]=[(1+(-2))的补码] à [1+(-2)的原码]：

[1+(-2)的补码 – 1]=【1111111111111111111111111111110】

[(1-2)原码]= [{1+(-2)的补码 – 1}符号位不变，其它各位取反]=【1000000000000000000000000000001】

即：[(1-2)原码]=【1000000000000000000000000000001】=-1

位运算符：

按位与&:两位全为1，结果为1

按位或|:两位有一个为1,结果为1

按位异或^:两位一个为0，一个为1，结果为1

按位取反~:0 à 1,1 à 0

例：

~-5=4 (在计算机中，取反运算符是给一个数补码取反)

[(-5)的原码]= 【1000000000000000000000000000101】

[(-5)的反码]= 【1111111111111111111111111111010】

[(-5)的补码]= 【1111111111111111111111111111011】

[{(-5)的补码}按位取反后]=【0000000000000000000000000000100】=4

集合：collection，List很多子类的实现都是基于数组

链表：内存地址不连续

数组和链表的比较：

1.内存开辟：链表开辟内存更容易

2.对元素的访问：对于数组来说，检索效率高，插入和删除效率低，可能涉及到数组的重新开辟和拷贝

1.声明数组：

制定数组的类型 [] 数组的引用名 = new 数组的类型[数组的大小] --> 一维数组

int [] array = new int[30];

Person array [] = new Person[30];

2.初始化：

a.在声明的时候进行初始化

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

Person array [] = new Person [] {new Person(), new Person()};

b.对数组内的单个元素进行初始化

数组的索引：用来对数组内的元素进行访问。从0开始

array[index]:访问数组内的特定元素

array[4]->5//访问

array[4]=10;//修改

c.可以通过循环进行初始化

for(int i=0;i<array.length;i++){

int [][] array=new int [10][10];

array[i][j];

锯齿数组

锯齿数组：指定有多少行，但是不指定列数

int [][] array=new int [10][];

array[0]=new int [10];

array[1]=new int [5];

array[2]=new int [8];

减少内存使用在程序运行期间确定列数

tdd：test driven development 测试驱动开发先写测试代码，再写功能代码

应用举例

例1：

package ch04;

public class SumTest{

public static void main (String args[]){

int [] array = new int[100];

int sum=0;

for (int i=0;i<array.length;i++){

array[i]=i+1;

sum=sum+array[i];

System.out.print(array[i]+"\t");

}

System.out.println("Sum 1~100:"+sum);

}

例2：

package ch04;

public class ArrayTest{

public static void main (String args[]){

int [][] array=new int [2][];

array[0]=new int [5];

array[1]=new int [3];

for (int i=0;i<array[0].length;i++){

for(int j=0;j<array[0].length;j++){

System.out.print(array[0][j]+"\t");

}

System.out.println();

for(int k=0;k<array[1].length;k++){

System.out.print(array[1][k]+"\t");

}

数组中常见问题

运行时异常：

ArrayIndexOutboundException （index 越界）

NullpointerException 空指针异常

Person p1 = new Person

p1.name p1.getName()

p1=null;

p1.name p1.getName()

NullpointerException 出错。

螺旋数组

螺旋数组：二维结构 4*4

数组的拷贝

数组的拷贝：由于数组构造的一次性。当数组无法满足需求时，需要重新创建一个新的数组，并将元数组的内容拷贝到新数组中，同时把引用指向新数组。

System.arraycopy(1,2,3,4,5)

static 使用static修饰方法条用时不需要类的实例。

类名.static修饰的方法（参数列表）

ch04/ArrayCopyTest.java

package ch04;

public class ArrayCopyTest{

public static void main(String args[]){

int [] srcArray=new int[100];

for(int i=0;i<srcArray.length;i++){

srcArray[i]=i+1;

}

int [] destArray=new int[50];

System.arraycopy(srcArray,50,destArray,0,50);

for(int j=0;j<destArray.length;j++){

System.out.print(destArray[j]+"\t");

}

性能测试：代码执行时间

long start = System.ourrentTimeMillis();

代码

。。。

long end = System.ourrentTimeMills();

long duration=end-start;

数组实例项目

银行排号系统

需求描述：描述程序的基本功能.

需求分析：1/3时间收集客户需要的功能并进行抽象——》生成面向对象里面的类

public int [] array;//存放号码

public int size;//存放当前数组里最大的元素的个数

public int maxSize;//说明数组的容量

public int value;//存放号码值

public void add();//添加

public void remove();//叫号

public void testArray()//查看数组容量是否够用,动态开辟数组的拷贝

*Created in 2011-11-22

public int [] array;//存放数据的数组

public int size;//记录当前队列下一个元素的index

public int maxSize;//记录当前队列的最大内容

public int value;//下一个号码

/**

*初始化队列

public Queue(){

this.array=new int [20];

this.maxSize=20;

}

public Queue(int maxSize){

this.maxSize=maxSize;

this.array=new int [maxSize];

public void remove(){

if (size==0){

return;

}

for(int i=1;i<size;i++){

public void testArray(){

if (size>=this.maxSize){

int [] newArray=new int [this.maxSize+20];

System.arraycopy(this.array,0,newArray,0,size);

this.array=newArray;

this.maxSize+=20;

for(int i=0;i<size;i++){

System.out.print(this.array[i]+"\t");

}

System.out.println();

}

队列操作

package ch04;

public class QueueTest{

public static void main(String args[]){

Queue queue=new Queue();

for(int i=0;i<30;i++){

queue.add();

}

queue.print();

for(int j=0;j<20;j++){

import java.util.Arrays;

public class ArraysTest{

public static void main(String args[]){

int [] array = new int []{10,1,2,5,9,8,6,7,4,3};

int index=Arrays.binarySearch(array,0,array.length,5);

System.out.println("6`s index:"+index);

Arrays.sort(array);//对整个数组进行排序

print(array);

}

public static void print(int [] array){

for(int i=0;i<array.length;i++){

System.out.print(array[i]+"\t");

}

System.out.println();

public static void main(String []args)

{

int [][] array=new int[10][10];

for(int i=0;i<10;i++)

{

for(int j=0;j<=i;j++)

{

if(j==0 || i==j) //如果是第一列或者对角线

array[i][j]=array[i-1][j-1]+array[i-1][j];

}

System.out.print(array[i][j]+"\t");

}

System.out.println();

public class MaxDivisor

{

public static void main(String []args)

{

MaxDivisor opt=new MaxDivisor();

//System.out.println(Integer.valueOf(args[0])%Integer.valueOf(args[1]));

System.out.println("最大公约数为："+opt.commonDivisor2(Integer.valueOf(args[0]),Integer.valueOf(args[1])));

System.out.println("最小公倍数为："+opt.commonMultiple(Integer.valueOf(args[0]),Integer.valueOf(args[1])));

//问号表达式

int b=Integer.valueOf(args[0]);

int a=(b==0 ? b:(b+2));

System.out.println("opt.ret(b): "+opt.ret(b) + "\na = "+a+" b = "+b);

System.out.println("Add(a,b) = "+opt.Add(a,b));

System.out.println("1^1:"+(1^1)); //得0

System.out.println("0^0:"+(0^0)); //得0

}

//测试问号表达式

public int ret(int b)

{

return b==0 ? b:(b+=2);

}

//最大公倍数

public int commonDivisor1(int num1,int num2)

{

return (num1%num2 == 0) ? num2:commonDivisor1(num2,num1%num2);

}

public int commonDivisor2(int num1,int num2)

while((a=num1%num2)!=0)

public int commonMultiple(int num1,int num2)

{

return num1*num2/commonDivisor1(num1,num2);

}

//交换函数

public void shift1(int num1,int num2)

public void shift2(int num1,int num2)

public void shift3(int num1,int num2)

{

num1=num1^num2; //异或，相同为0，不同为1，找出不同的位(异或之后，为1的位)，

num2=num1^num2; //再异或得到初始num1的值赋给num2

num1=num1^num2; //再异或得到初始num2的值赋给num1

//num2的各位与0异或(两数中相同的位)保持不变，num2的各位与1异或(两数中不相同的位)反转，

}

//位运算实现加法

public int Add(int num1,int num2)

{

return num2==0 ? num1 : Add(num1^num2,(num1 & num2)<<1);

//先不计进位相加(num1^num2),得出的结果，再与进位相加，随着递归，直至进位变为0，递归结束

}

位运算简例

十进制转换成二进制

public class d2binary

{

public static void main(String []args)

{

int a=10;

for(int i=31;i>=0;i--)

{

System.out.print(a>>i&1); //输出二进制

}

System.out.print("\n\n");

d2binary op=new d2binary();

int b=15;

int c;

c=op.add(1,1);

System.out.println("\nAdd(10,15)-->c="+c);

public void shift3(int num1,int num2)

{

num1=num1^num2; //异或，相同为0，不同为1，找出不同的位(异或之后，为1的位)，

num2=num1^num2; //再异或得到初始num1的值赋给num2

num1=num1^num2; //再异或得到初始num2的值赋给num1

//num2的各位与0异或(两数中相同的位)保持不变，num2的各位与1异或(两数中不相同的位)反转，

}

//从32位的单元中取出某几位

public int getMidBits(int val,int n1,int n2)

{

int z;

z=~0; //将z初始化16位的1

z=(z>>n1)&(z<<(32-n2)); //将两端的化成0,中间的化成1

//对32的二进制数取出它的奇数位(从左边起1，3，5 。。。)

public int getOddBits(int val)

{

int z,a,q;

z=0;

for(int i=1;i<=31;i+=2)

{

q=1;

for(int j=1;j<=(32-i-1)/2;j++) //要取的数的位数为原来的数的位数的1/2

q=q*2; //原数进位指针进两位，要取的数的指针进一位

a=val >> (32-i); //将第i个位置的数移到最低位

a=a << 31; //通过左移31位，将将最低位移到最高位去，其后的位全都补0

a=a >> 31; //右移31位，将最高位移到最低，其前面的位全都补零，得到第i位

//算术右移：低位溢出，符号位不变，并用符号位补溢出的高位

//算术左移：符号位不变，低位补0

//逻辑右移:低位溢出，高位补零

//实现算术右移函数

public int shiftRightArithmetic(int val,int n)

public int shiftRightLogical(int val,int n)

{

int z;

z=(~(1 >> n))&(val >> n);

return z;

}

//实现右在循环移位

public int moveRightCircle(int val,int n)

{

int z;

z=(val >> n)|(val << (32-n));

public static void main(String[] args) {

System.out.println("~2="+(~2));//取反

System.out.println("2&3="+(2&3));//与

System.out.println("2|3="+(2|3));//或

System.out.println("~-5="+(~-5));//取反

System.out.println("-3^3="+(-3^3));//异或

//算术右移：低位溢出，符号位不变，并用符号位补溢出的高位

//算术左移：符号位不变，低位补0

//逻辑右移:低位溢出，高位补零

System.out.println("1>>2="+(1>>2));

System.out.println("-1>>2="+(-1>>2));

System.out.println("1<<2="+(1<<2));

System.out.println("-1<<2="+(-1<<2));

System.out.println("3>>>2="+(3>>>2));//逻辑右移