杰普Core Java课程笔记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很多子类的实现都是基于数组
2.对元素的访问:对于数组来说,检索效率高,插入和删除效率低,可能涉及到数组的重新开辟和拷贝
制定数组的类型 [] 数组的引用名 = new 数组的类型[数组的大小] --> 一维数组
Person array [] = new Person[30];
int [] array= new int []{1,2,3,4,5};
Person array [] = new Person [] {new Person(), new Person()};
for(int i=0;i<array.length;i++){
int [][] array=new int [10][10];
int [][] array=new int [10][];
tdd:test driven development 测试驱动开发 先写测试代码,再写功能代码
public static void main (String args[]){
for (int i=0;i<array.length;i++){
System.out.print(array[i]+"\t");
System.out.println("Sum 1~100:"+sum);
public static void main (String args[]){
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");
for(int k=0;k<array[1].length;k++){
System.out.print(array[1][k]+"\t");
ArrayIndexOutboundException (index 越界)
数组的拷贝:由于数组构造的一次性。当数组无法满足需求时,需要重新创建一个新的数组,并将元数组的内容拷贝到新数组中,同时把引用指向新数组。
static 使用static修饰方法条用时不需要类的实例。
public static void main(String args[]){
for(int i=0;i<srcArray.length;i++){
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();
需求分析:1/3时间 收集客户需要的功能并进行抽象——》生成面向对象里面的类
public int size;//存放当前数组里最大的元素的个数
public void testArray()//查看数组容量是否够用,动态开辟 数组的拷贝
public int size;//记录当前队列下一个元素的index
public int maxSize;//记录当前队列的最大内容
int [] newArray=new int [this.maxSize+20];
System.arraycopy(this.array,0,newArray,0,size);
System.out.print(this.array[i]+"\t");
public static void main(String args[]){
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);//对整个数组进行排序
public static void print(int [] array){
for(int i=0;i<array.length;i++){
System.out.print(array[i]+"\t");
public static void main(String []args)
int [][] array=new int[10][10];
if(j==0 || i==j) //如果是第一列或者对角线
array[i][j]=array[i-1][j-1]+array[i-1][j];
System.out.print(array[i][j]+"\t");
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]);
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 commonDivisor1(int num1,int num2)
return (num1%num2 == 0) ? num2:commonDivisor1(num2,num1%num2);
public int commonDivisor2(int num1,int num2)
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 static void main(String []args)
System.out.print(a>>i&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异或(两数中不相同的位)反转,
public int getMidBits(int val,int n1,int n2)
z=(z>>n1)&(z<<(32-n2)); //将两端的化成0,中间的化成1
//对32的二进制数取出它的奇数位(从左边起1,3,5 。。。)
public int getOddBits(int val)
for(int j=1;j<=(32-i-1)/2;j++) //要取的数的位数为原来的数的位数的1/2
a=val >> (32-i); //将第i个位置的数移到最低位
a=a << 31; //通过左移31位,将将最低位移到最高位去,其后的位全都补0
a=a >> 31; //右移31位,将最高位移到最低,其前面的位全都补零,得到第i位
public int shiftRightArithmetic(int val,int n)
public int shiftRightLogical(int val,int n)
public int moveRightCircle(int val,int 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));//异或
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));