doc java pdf spire 乱码 core java pdf 中文

转载

数据探索先锋 2023-07-18 15:05:33

文章标签 System java 赋值 文章分类 Java 后端开发

——年金波老师上课笔记

Core Java课程笔记1 1

编译执行java文件 1

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

java内存模型 1

java运行环境的搭建 2

配置环境变量 2

配置: 2

java中的类型 2

1.基本类型 2

2.引用类型 2

java中的基本数据类型 2

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

位运算符： 2

Java中的数组 2

1.声明数组： 2

2.初始化： 2

二维数组 2

应用举例 2

数组中常见问题 2

数组实例项目 2

Java基础算法题 2

杨辉三角 2

最大公约数 2

位运算简例 2

编译执行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("abc");//堆区

String c =new("abc");

String d ="abc";

a==b 错==c 错（两个不同的对象）==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;

 
publicclass PrimitiveTest

{
publicstaticvoid(String []args)
{
int=0x11;//16进制
			
int=011;//8进制
			
int=17;//10进制
			
float=12.5e5f;
double=0.1234d;
.out.println("fvar1="+fvar1);
.out.println("dvar1="+dvar1);
        
 
boolean=true;
.out.println("boolean:"+flag);
        
 
.out.println("ivar1="+ivar1);
.out.println("ivar2="+ivar2);
.out.println("ivar3="+ivar3);
        
 
char='F';
char='\u0065';//unicode码
			
.out.println("gender:"+gender);
.out.println("test:"+test

例2：

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

publicclass{
//private static PrimitiveTypeTest primitiveType;

privateint;
publicint()
{
return;
}
     
 
public()//调用它是因为自动拆箱、装箱，所有不报错
			
{
return;
}
     
 
publicint()
{
return;
}
     
 
/**

     public void initVal()

     {

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

        primitiveType=new PrimitiveTypeTest();

     }

     
 
private;
public()
{
return;
}
     
 
privatebyte;
public(){
return;
}
     
 
boolean;
public()
{
return;
}
     
 
short;
publicshort()
{
return;
}
     
 
long;
publiclong()
{
return;
}
     
 
float;
publicfloat()
{
return;
}
     
 
double;
publicdouble()
{
return;
}
     
 
char;
publicchar()
{
return;
}
     
 
publicstaticvoid(String[]){
=new();
// byte    

.out.println("基本类型：byte 二进制位数："+.SIZE);
.out.println("包装类：java.lang.Byte");
.out.println("最小值：Byte.MIN_VALUE="+.MIN_VALUE);
.out.println("最大值：Byte.MAX_VALUE="+.MAX_VALUE);
//Byte b1=new Byte("0");

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

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

.out.println("基本类型：short 二进制位数："+.SIZE);
.out.println("包装类：java.lang.Short");
.out.println("最小值：Short.MIN_VALUE="+.MIN_VALUE);
.out.println("最大值：Short.MAX_VALUE="+.MAX_VALUE);
.out.println("short默认赋值为："+primitiveType.getShort());
//Short s1;

//short s2;

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

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

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

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

.out.println("基本类型：int 二进制位数："+.SIZE);
.out.println("包装类：java.lang.Integer");
.out.println("最小值：Integer.MIN_VALUE="+.MIN_VALUE);
.out.println("最大值：Integer.MAX_VALUE="+.MAX_VALUE);
//Integer i1;

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

//只有通过new 了之后才能取到默认值
				
.out.println("int默认赋值为："+primitiveType.getI1());
.out.println("int默认赋值为："+primitiveType.getI2());
.out.println("int默认赋值为："+primitiveType.obtainInt());
.out.println("Integer默认赋值为："+primitiveType.getInteger());
//System.out.println("int默认赋值为："+i1);

.out.println("-----------------------------------");
   
 
//--------------------------long-------------------  

.out.println("基本类型：long 二进制位数："+.SIZE);
.out.println("包装类：java.lang.Long");
.out.println("最小值：Long.MIN_VALUE="+.MIN_VALUE);
.out.println("最大值：Long.MAX_VALUE="+.MAX_VALUE);
.out.println("long默认赋值为："+primitiveType.getLong());
//Long l1;

//long l2;

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

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

.out.println("-----------------------------------");
   
 
//------------------------float---------------------------    

.out.println("基本类型：float 二进制位数："+.SIZE);
.out.println("包装类：java.lang.Float");
.out.println("最小值：Float.MIN_VALUE="+.MIN_VALUE);
.out.println("最大值：Float.MAX_VALUE="+.MAX_VALUE);
.out.println("float默认赋值为："+primitiveType.getFloat());
//Float f1;

//float f2;

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

.out.println("-----------------------------------");
   
 
//-------------------------double------------------------   

.out.println("基本类型：double 二进制位数："+.SIZE);
.out.println("包装类：java.lang.Double");
.out.println("最小值：Double.MIN_VALUE="+.MIN_VALUE);
.out.println("最大值：Double.MAX_VALUE="+.MAX_VALUE);
.out.println("double默认赋值为："+primitiveType.getDouble());
//Double d1;

//double d2;

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

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

.out.println("-----------------------------------");
   
 
//---------------------char----------------------    

.out.println("基本类型：char 二进制位数："+.SIZE);
.out.println("包装类：java.lang.Character");
// 以数值形式而不是字符形式将Character.MIN_VALUE输出到控制台
				
.out.println("最小值：Character.MIN_VALUE="
				
+(int).MIN_VALUE);
// 以数值形式而不是字符形式将Character.MAX_VALUE输出到控制台
				
.out.println("最大值：Character.MAX_VALUE="
				
+(int).MAX_VALUE);
.out.println("char默认赋值为："+primitiveType.getChar());
//Character c1;

//char c2;

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

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

.out.println("-----------------------------------");
         
 
//-----------------------Boolean---------------------

.out.println("包装类：java.lang.Boolean");
=new(false);
.out.println("boolean默认赋值为："+primitiveType.getBoolean());
.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

Java中的数组

数组：存放相同类型数据的连续的内存空间

相同类型连续的内存空间

地址号连续

存储数据（基本类型对象类型）

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

链表：内存地址不连续

数组和链表的比较：

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

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

1.声明数组：

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

int[]=newint[30];

Person array []=new[30];

2.初始化：

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

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

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

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

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

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

[4]->5//访问

[4]=10;//修改

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

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

[i]=i+1;

}

二维数组

二维数组：通过两个索引确定一个元素

数据库中的表的行和列

声明：

int[][]=newint[10][10];

array[i][j];

锯齿数组

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

int[][]=newint[10][];
array[0]=newint[10];
array[1]=newint[5];
array[2]=newint[8];

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

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

应用举例

例1：

package;
publicclass{
publicstaticvoid(String args[]){
int[]=newint[100];
int=0;
for(int=0;i<array.length;i++){
[i]=i+1;
=sum+array[i];
.out.print(array[i]+"\t");
}
.out.println("Sum 1~100:"+sum);
}
}

例2：

package;
publicclass{
publicstaticvoid(String args[]){
int[][]=newint[2][];
[0]=newint[5];
[1]=newint[3];
for(int=0;i<array[0].length;i++){
[0][i]=i+1;
if(i<3){
[1][i]=i*10;
}
}
for(int=0;j<array[0].length;j++){
.out.print(array[0][j]+"\t");
}
.out.println();
for(int=0;k<array[1].length;k++){
.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)

1.原数组的引用

2.原数组开始拷贝的起始索引

3.目标数组的引用

4.目标数组的插入索引位置

5.拷贝的数量

例：

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

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

ch04/ArrayCopyTest.java

package;
publicclass{
publicstaticvoid(String args[]){
int[]=newint[100];
for(int=0;i<srcArray.length;i++){
[i]=i+1;
}
int[]=newint[50];
.arraycopy(srcArray,50,destArray,0,50);
for(int=0;j<destArray.length;j++){
.out.print(destArray[j]+"\t");
}
}
}

性能测试：代码执行时间

long=.ourrentTimeMillis();

代码

。。。

long=.ourrentTimeMills();

long=end-start;

数组实例项目

银行排号系统

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

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

银行排号系统：取号机：先到显得

数据结构：队列：先进先出 FIFO

叫号机：

基于数组实现

class{

publicint[];//存放号码

publicint;//存放当前数组里最大的元素的个数

publicint;//说明数组的容量

publicint;//存放号码值

publicvoid();//添加

publicvoid();//叫号

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

取号：始终在队尾插入

叫好：始终在队首删除

数组的搬移

}

 
ch04/Queue.java

ch04/QueueTest.java


 
/**

 *Created in 2011-11-22

 *

package;

 
/**

 *排号系统
			
 *@author
 *@version 0.1

publicclass{
publicint[];//存放数据的数组
			
publicint;//记录当前队列下一个元素的index

publicint;//记录当前队列的最大内容
			
publicint;//下一个号码
			
/**

     *初始化队列
			
public(){
this.array=newint[20];
this.maxSize=20;
        
 
}
public(int){
this.maxSize=maxSize;
this.array=newint[maxSize];
}
/**

     *取号
			
publicvoid(){
();
[size]=value+1;
++;
++;
}
/**

     *叫号
			
publicvoid(){
if(size==0){
return;
}
for(int=1;i<size;i++){
[i-1]=array[i];
}
[size-1]=null;
--;
}
/**

     *查询数据
			并动态开辟
			
publicvoid(){
if(size>=this.maxSize){
int[]=newint[this.maxSize+20];
.arraycopy(this.array,0,newArray,0,size);
this.array=newArray;
this.maxSize+=20;
}
}
/**

     *查看数组所有元素
			
publicvoid(){
for(int=0;i<size;i++){
.out.print(this.array[i]+"\t");
}
.out.println();
}
    
 
}

队列操作

package;
publicclass{
publicstaticvoid(String args[]){
=new();
.add();
.add();
.print();
.remove();
.print();
.remove();
.print();
for(int=0;i<30;i++){
.add();
}
.print();
for(int=0;j<20;j++){
.remove();
}
.print();
}
}

数组二分查找、排序、输出

ch04/ArraysTest.java

package;
import.util.Arrays;
publicclass{
publicstaticvoid(String args[]){
int[]=newint[]{10,1,2,5,9,8,6,7,4,3};
int=Arrays.binarySearch(array,0,array.length,5);
.out.println("6`s index:"+index);
.sort(array);//对整个数组进行排序
			
(array);
}
publicstaticvoid(int[]){
for(int=0;i<array.length;i++){
.out.print(array[i]+"\t");
}
.out.println();
}
}

Java基础算法题

杨辉三角

//杨辉三角
			
package;

 
publicclass YHTest

{
publicstaticvoid(String []args)
{
int[][]=newint[10][10];
for(int=0;i<10;i++)
{
for(int=0;j<=i;j++)
{
if(j==0||==j)//如果是第一列或者对角线
			
{
[i][j]=1;
}
else
{
[i][j]=array[i-1][j-1]+array[i-1][j];
}
.out.print(array[i][j]+"\t");
}
.out.println();
}
}
}

 
最大公约数
			
/*

求两个数的最大公约数
			与
			最大公倍数
			
*/

package;

 
publicclass MaxDivisor

{
publicstaticvoid(String []args)
{
=new();
//System.out.println(Integer.valueOf(args[0])%Integer.valueOf(args[1]));

.out.println("最大公约数为："+opt.commonDivisor2(Integer.valueOf(args[0]),Integer.valueOf(args[1])));
.out.println("最小公倍数为："+opt.commonMultiple(Integer.valueOf(args[0]),Integer.valueOf(args[1])));
        
 
//问号表达式
			
int=Integer.valueOf(args[0]);
int=(b==0?:(b+2));
        
 
.out.println("opt.ret(b): "+opt.ret(b)+"\na = "+a+" b = "+b);
.out.println("Add(a,b) = "+opt.Add(a,b));
.out.println("1^1:"+(1^1));//得0

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

}
    
 
//测试问号表达式
			
publicint(int)
{
return==0?:(b+=2);
}
    
 
//最大公倍数
			
publicint(int,int)
{
return(num1%num2 ==0)?:commonDivisor1(num2,num1%num2);
}
    
 
publicint(int,int)
{
int,a;
if(num1<num2)
{
//shift1(num1,num2);

//shift2(num1,num2);

(num1,num2);
}
while((a=num1%num2)!=0)
{
=num2;
=a;
}
return;
}
    
 
//最小公倍数
			
publicint(int,int)
{
return*num2/commonDivisor1(num1,num2);
}
    
 
//交换函数
			
publicvoid(int,int)
{
int=num1;
=num2;
=t;
}
    
 
publicvoid(int,int)
{
=num1+num2;
=num1-num2;
=num1-num2;
}
    
 
publicvoid(int,int)
{
=num1^num2;//异或，相同为0，不同为1，找出不同的位(异或之后，为1的位)，
				
=num1^num2;//再异或得到初始num1的值赋给num2 

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

//num2的各位与0异或(两数中相同的位)保持不变，num2的各位与1异或(两数中不相同的位)反转，
				
}
    
 
//位运算实现加法
			
publicint(int,int)
{
return==0?:(num1^num2,(num1 &)<<1);
//先不计进位相加(num1^num2),得出的结果，再与进位相加，随着递归，直至进位变为0，递归结束
				
}
}

位运算简例

十进制转换成二进制

publicclass d2binary

{
publicstaticvoid(String []args)
{
int=10;
for(int=31;i>=0;i--)
{
.out.print(a>>i&1);//输出二进制
			
}
.out.print("\n\n");
        
 
=new();
        
 
int=15;
int;
        
 
=op.add(1,1);
.out.println("\nAdd(10,15)-->c="+c);
        
 
}

/*交换两个变量的值，有三种方法：

1.利用位操作(异或 ^)

2.两数相加、相减、相减

3.使用中间变量

//利用位操作交换两变量的值
			
publicvoid(int,int)
{
=num1^num2;//异或，相同为0，不同为1，找出不同的位(异或之后，为1的位)，
				
=num1^num2;//再异或得到初始num1的值赋给num2 

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

//num2的各位与0异或(两数中相同的位)保持不变，num2的各位与1异或(两数中不相同的位)反转，
				
}
    
 
//从32位的单元中取出某几位
				
publicint(int,int,int)
{
int;
=~0;//将z初始化16位的1

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

=val&z;
=z>>(32-n2);
return;
}
    
 
//对32的二进制数取出它的奇数位(从左边起1，3，5 。。。)

publicint(int)
{
int,a,q;
=0;
for(int=1;i<=31;i+=2)
{
=1;
for(int=1;j<=(32-i-1)/2;j++)//要取的数的位数为原来的数的位数的1/2

=q*2;//原数进位指针进两位，要取的数的指针进一位
			
=val >>(32-i);//将第i个位置的数移到最低位
				
=a <<31;//通过左移31位，将将最低位移到最高位去，其后的位全都补0

=a >>31;//右移31位，将最高位移到最低，其前面的位全都补零，得到第i位
				
=z+a*q;//积加取出的数
			
}
return;
}
    
 
//算术右移：低位溢出，符号位不变，并用符号位补溢出的高位
			
//算术左移：符号位不变，低位补0   

//逻辑右移:低位溢出，高位补零
				
    
 
//实现算术右移函数
			
publicint(int,int)
{
int;
=~0;
=z>>n;
=~z;
=z|(val >>);
return;
}
    
 
//实现逻辑右移函数
			
publicint(int,int)
{
int;
=(~(1>>))&(val >>);
return;
}
    
 
//实现右在循环移位
			
publicint(int,int)
{
int;
=(val >>)|(val <<(32-n));
return;
}
 }

移位运算

package;
publicclass{
publicstaticvoid(String[]){
.out.println("~2="+(~2));//取反
			
.out.println("2&3="+(2&3));//与
			
.out.println("2|3="+(2|3));//或
			
.out.println("~-5="+(~-5));//取反
			
.out.println("-3^3="+(-3^3));//异或
			

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

//逻辑右移:低位溢出，高位补零
				
.out.println("1>>2="+(1>>2));
.out.println("-1>>2="+(-1>>2));
.out.println("1<<2="+(1<<2));
.out.println("-1<<2="+(-1<<2));
.out.println("3>>>2="+(3>>>2));//逻辑右移
			
}
}

 
/*

~2=-3

2&3=2

2|3=3

~-5=4

-3^3=-2

1>>2=0      //算术右移
			
-1>>2=-1

1<<2=4      //算术左移
			
-1<<2=-4

3>>>2=0     //逻辑右移
			
*/

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。