a java runtiome environment(jre)_知不知

最新推荐文章于 2024-04-19 17:45:45 发布

weixin_39610085

最新推荐文章于 2024-04-19 17:45:45 发布

阅读量105

点赞数

文章标签： a java runtiome environment(jre)

本文链接：https://blog.csdn.net/weixin_39610085/article/details/114837066

版权

Java-Java中的基本数据类型

主要内容有：Java编译、环境配置、内存模型、基本数据类型、原码、反码、补码、排队系统、数组二分查找。

基本概念

编译执行java文件

C:\~>javac -d . ch01/HelloWorld.java

C:\~>java ch01.HelloWorld

Hello World!

C:\~>java ch01/HelloWorld 这样也可以

Hello World!

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

C:\~>javadoc -d doc ch02

C:\~>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)

引用类型：类类型

类：对现实实体的抽象

包含属性和方法(函数)

属性：描述现实的实体

Person：name gender age

方法：操纵属性

java中的基本数据类型

//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("-----------------------------------");

}

修饰符及属性的说明

//类没有protected和private修饰符

//被public 修饰的类，可以被其它包中的类访问

public class TestA

{

//private 级别的属性和方法

private int a=101;

private void printA()

{

System.out.println("printA方法："+this.a);

}

//默认级别的属性和方法

int b=102;

void printB()

{

System.out.println("printB方法："+this.b);

}

//protected级别的属性和方法

protected int c=103;

protected void printC()

{

System.out.println("printC方法："+this.c);

}

//public级别的属性和方法

public int d=104;

public void printD()

{

System.out.println("printD方法："+this.d);

}

//没有被public 修饰的类不能被其它包中的类访问

class TestB

{

//private 级别的属性和方法

private int a=101;

private void printA()

{

System.out.println("printA方法："+this.a);

}

//默认级别的属性和方法

int b=102;

void printB()

{

System.out.println("printB方法："+this.b);

}

//protected级别的属性和方法

protected int c=103;

protected void printC()

{

System.out.println("printC方法："+this.c);

}

//public级别的属性和方法

public int d=104;

public void printD()

{

System.out.println("printD方法："+this.d);

}

//被final修饰的类不能被继承

final class TestC

{

//private 级别的属性和方法

private int a=101;

private void printA()

{

System.out.println("printA方法："+this.a);

}

//默认级别的属性和方法

int b=102;

void printB()

{

System.out.println("printB方法："+this.b);

}

//protected级别的属性和方法

protected int c=103;

protected void printC()

{

System.out.println("printC方法："+this.c);

}

//public级别的属性和方法

public int d=104;

public void printD()

{

System.out.println("printD方法："+this.d);

}

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

对于有符号的数而言(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 [] 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[i]=i+1;

}

二维数组

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

数据库中的表的行和列

声明：

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/3时间收集客户需要的功能并进行抽象——》生成面向对象里面的类

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

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

叫号机：

基于数组实现

class Queue{

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

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

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

public int value;//存放号码值

public void add();//添加

public void remove();//叫号

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

//取号：始终在队尾插入

//叫好：始终在队首删除

//数组的搬移

}

ch04/Queue.java* ch04/QueueTest.java

/**

*排号系统

public class Queue {

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 add() {

testArray();

array[size] = value + 1;

size++;

value++;

}

/**

*叫号

public void remove() {

if (size == 0) {

return;

}

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

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

}

array[size - 1] = null;

size--;

}

/**

*查询数据并动态开辟

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;

}

/**

*查看数组所有元素

public void print() {

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

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

}

System.out.println();

}

队列操作

public class QueueTest{

public static void main(String args[]){

Queue queue=new Queue();

queue.add();

queue.print();

queue.remove();

queue.print();

queue.remove();

queue.print();

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

queue.add();

}

queue.print();

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

queue.remove();

}

queue.print();

}

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

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

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

}

System.out.println();

}

知不知 is maintained by luowei. Developed by luowei.

weixin_39610085

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫