java语言基础知识点

jdk的使用和安装：

    jdk是java开发工具包，包括jre和java运行工具

    java运行工具有：

    调试器，编译器，javadoc.exe  java.exe,javac.exe

    jre是java运行环境，包括jvm和类库

    jvm是java虚拟机，用程序模拟一台计算机，使java程序能够运行在此程序上

    类库是资源库

    jdk:程序员用jdk；

    jre :写好的程序用jre

    javadoc.exe，调用编译器对源文件进行编译，生成字节码文件(.class)文件，编译过程中会检查源文件语法，如果源文件语法      有错误，就不会生成字节码文件。

    安装好jdk后，需要配置环境变量，在计算机的属性设置中-->高级设置-->高级-->环境变量-中配置

    需要对path的值进行追加，在系统变量里创建JAVA_HOME和CLASSPATH,并且写上变量值

    检验jdk是否安装成功的方法

    打开DOS命令窗口：

    输入 javac

     java -version

    只要不出现“不是内部或外部命令”即安装成功

变量

    变量是jvm在内存中开辟的一个存储空间，用于存储数据

  变量的命名规则：

（1）变量是由字母，数字，_和$等任意组成，数字不能作为开头

（2）大小写敏感

（3）驼峰命名法 见明知意

（4）不能使用关键字

（5）可以使用汉字，但是不建议使用

  变量的使用规则：

（1）变量首先进行定义和初始化

（2）变量可以重复使用，再次使用不用强调类型，变量名必须要和类型一致

（3）变量有自己的作用域，即从一大括号的开始到大括号的结束；出了作用域，在想使用变量，需要重新定义和初始化。

java语言的特点：

（1）跨平台性

也即任何的操作系统都可以使用java语言

例如：Linux，Mac等都有自己的运行平台，但是所有的运行平台都可以运行.class文件（字节码文件），

（2）强类型转换

byte short char 类型先转换成int类型，再进行运算，结果也是int类型

再进行多个数据类型数据进行运算时，先转换成较大的类型

java语言的数据类型分为两大类：

（1）基本数据类型：8种

（2）引用数据类型：无数种

基本数据类型：

    整型

byte，short，int，long

    浮点型

float,double

    字符类型

char

    布尔类型

Boolean

byte是最小的数据类型，也叫字节类型，在内存中占8位二进制，1字节大小（不常用）

最小的数 1111 1111  -128

最大的数 0111 1111 127

byte类型的范围就是-2^7~2^7-1    -128~12

short 也叫短整型，在内存中占16位二进制，2字节大小（不常用）

范围 -2^15~2^15-1

-65536~65535

int 也叫整型，在内存中占32位二进制，4字节大小（常用）

范围-2^31~2^31-1

-2147483648~2147483647

int数据类型在运算时是封闭式运算，即max+1=min，min-1 = max；

long 也叫长整型，在内存中占64位二进制吗，8字节大小（常用）

范围：-2^63~2^63-1；

封闭式运算

float 浮点数类型

在内存中占4字节大小，32位二进制
  范围：
  -3.403E38~3.403E38
double 浮点数类型

  在内存中占8字节大小，64位二进制
 范围：
-1.79E308~1.79E308

字面量问题，整型的字面量默认的是int类型，在不规定类型时赋值都是int类型；

如；int a = 5;

a = 10;//10也为int类型

在进行赋值时，如果想要转化成自己想要的类型；

int 转换成byte或short

可以：如：byte a = (byte)5;

short b = (short)6;

也即在想要赋的值前面加上括号，括号内是较小类型的类型名

int 转换成long类型只需要在值后面加上L/l;

如：

long c = 8L;

就可以将int类型的8转换成long类型的8；转换的原理是在原来的数的二进制表达式上加上32个0；

浮点数类型的字面量默认是double类型，想要float类型需要进行类型转换；

如：float d =  5F;

在值后面加上F/f;

char 字符类型；

字符类型与String字符串类型的区别；

（1）字符类型用单引号括起来

如 

char a = '王';

字符串类型用双引号括起来；

如：

String a = "王"；

（2）字符类型内有且只有一个字符，字符串类型可以有至少0个字符；

（3）引用字符可以做字符串拼接操作

另外，低层二进制也是无符号的整数类型，在书写时直接赋值，存入时是整数对应的值

范围 0~65535

如：

char s = 14687;//运行时显示的是在Unicode字符集上对应的数值

如果想找某个汉字在Unicode上对应的低层二进制数，

int a = "王"；

System.out.println(a);

a~z;97~122

A~Z;65~90

0-9;48~57

\t  制表符

\r  换行符

\n  回车符

"\'"单引号

"\""双引号

"\\"反斜线

特殊字符之转义字符 \:意思是将特殊字符转义成普通字符对待

类型转换分为两种

自动类型转换：是将较小类型的转换城较大类型的数据，也叫隐式转换

强制类型转换：是将较大的数据类型转换成较小的数据类型

 

运算符：

（1）关系运算符：>,<,>=,<=,==,!=

（2）逻辑运算符:&&,||,!

&&，与，即当左右的条件都为true时，输出为true，有一个为false，结果就输出为false；

||，或，即当条件表达式中有一个为true时，条件表达式就输出为true，当所有的条件为false时，才会输出false，

有一个为真，结果为真

！，当条件为true时，输出为false，当条件为false时，输出为true；

（3）赋值运算符:+=，-=,*=,/=,%=

（4）三目运算符:条件表达式1：变量 = 条件表达式2？值1：值2；

表达式为true时，输出值1，表达式为false时，输出值2，表达式的值要与条件类型要么一样，要么可以进行自动类型转换

（5）字符串拼接符:+

（6）算术运算符:+,-,*,/,&

 

程序的运行结构

（1）顺序结构

（2）分支结构

（3）循环结构

顺序结构，程序自上而下运行

分支结构，程序在运行的过程中，可以向多个分支选择运行，

常用的分支结构有if，if else if，switch：

if分支的结构为：

  if(条件表达式){

        代码块；//条件表达式为true时执行

};

if 语句在执行过程中，如果条件表达式为true，执行大括号内的语句，如果为false，跳出分支，执行后续代码，在执行if语句时，程序有可能全部执行if语句内的表达式，也有可能一条也不执行；

if(条件表达式1){

    代码块；//条件为true时执行；

}else if(条件表达式2){

代码块1；

}else{

代码块2；

}

if else 在程序执行过程中，先进行判断条件表达式1，如果为true，执行代码块1，如果为false，进行判断条件表达式2，如果为true，执行代码块2，如果为false，执行后续代码.if else语句在程序执行的过程中一定会执行一条分支

switch语句，

switch(整数表达式){

case1：

System.out.println();

break;

case2:

System.out.println();

break;

case3:

System.out.println();

break;

......

default;

根据整数表达式中的值来判断执行哪条分支，break，有打断循环的作用，防止程序进行死循环；

循环结构：

循环三要素：

（1）循环变量的声明和初始化；

（2）循环条件的判断；

（3）循环变量的改变方向。

for循环，while循环，do while循环

for循环：

for(循环条件 ){

循环体；

}

当程序遇到for循环时，程序一定先执行一遍变量的声明和初始化，然后判断条件是否成立，如果成立执行循环体内的代码，

然后进行变量的改变，再判断条件数否成立....

for循环嵌套：

外层循环执行一次，内层循环执行一遍；

外层循环控制行数，内层循环控制列数；

while循环中写的是整数表达式；

int i =0；

while(循环条件){

    循环体；

i++;

}

while循环相较于for循环的循环三要素体现的不是很明显，循环变量的声明和初始化在循环结构以外，

程序在执行时一定先执行循环条件，条件为true时就执行循环体，为false跳出循环

do{

循环体；

}while(循环条件);

do while循环结构在循环时一定先执行一次循环体，然后进行循环条件的判断，直到循环条件为真跳出循环；

do while 循环容易陷入死循环；

for循环适用于知道循环次数的循环，

while和do while循环适用于不知道循环次数的循环

do while 循环：

做......直到...

while循环：

当......就执行....

引用类型：

Scanner，Math.random，Arrays，

数组：

（1）数组的概念：

数组是一类相同数据的组合；

数组也是一种类型，一种引用类型；

（2）数组的名称：

数组的名称不是固定的，与要存放的类型匹配；

如，字符串类型 String[] arr1 = {};//默认值为null；

整数类型 int[] b = {};//默认值为0；

字符类型 char[] c = {};默认值为"\u0000"；

布尔类型 boolean[] d = {};//默认值为false；

浮点数类型double[] e = {};//默认值为0.0；

float[] = {};

（3）数组的声明和初始化：

   数组的声明：元素类型[]   变量名 

数组的初始化时机：

<1>声明时直接初始化；

<2>先声明，再初始化（使用时初始化）

数组的定义有三种，

1，静态初始化：int[] arr2 = {1,2,4};

2，动态初始化：

规定长度的写法：

int[] arr3 = new int[8];//规定数组的长度为8

不规定数组长度的写法：

int[] arr4 = new int[]{};

double[] arr5 = new double[]{};

（4）数组的下标：

数组是从0开始的，最后一个元素的位置为length-1；

所以数组的长度为0~length-1；

int[index];

System.out.println(int[index]);//查询下标为index的数组元素的数据；

（5）数组的赋值，替换

int[index] = value;

（6）数组的下标越界异常：

数组要查询的下标超过数组的长度，就会出现数组越界异常。

（7）数组的遍历：

添加一个for循环

for(int i = 0;j

System.out.println(arr[i]);

}

（8）数组的长度

数组名.length；数组长度的查询

System.out.println(arr.length);

（9）数组间的赋值

数组之间如果改变某一个数组内的数据的话，另外一个数组也会改变，

（10）引用数组Arrays

Arrays.toString();//将元素拼接成字符串输出

System.out.println(Arrays.toString(arr));

Arrays.sort();//将数组内的元素进行排序

（11）数组的复制

数组一经创建，长度无法改变

系统复制法：

System.Arrays.copyOf(arr1,index1,arr2,index2,length)

arr1:源数组，即被复制的数组

index1:即从下标为index1的位置开始复制

arr2:复制的数组

index2:从复制的数组的下标index2处开始复制

length：即要复制的长度

（12）工具类提供的复制方法

Arrays.copy(src,newlength);

src:源数组

newlength:新数组的长度

从下标为0开始复制

String info = Arrays.toString(数组名)；

数组的排序：

冒泡排序法

数组下标为0的数据与下标为1的数据比较，结果为true，说明arr[0]>arr[1]，进行数组元素的互换，如果为false，不进行数组元素

的互换，然后arr1与arr2进行比较，直到找到最大值放到数组的最后一位上，依次比较，找出较大值，直到按从小到大排列；

用for循环结构，

for(int i = 0;i

for(int j = 1;j

if(arr[i]>arr[j]){

int t = arr[i];

arr[i] = arr[j];

arr[j] = t;

}

}

}

系统排序法：找出一个数组中的最大值，放到最旁边，然后再找数组的较大值，依次进行排序

写两层for循环

for(int i = 0;i

int index = i;

boolea f = true

for (int j = i+1;j

if(arr[index]

index = j;

f = flase;

}

}

if(!f){

int t = arr[i];

arr[i] = arr[index];

arr[index] = t;

}

}

二维数组：

{{1,2,4},{3,5,1},{2},{}}

二维数组的声明和初始化

int[]][] a = new int[8][3];

等长数组，每个数组元素的数组长度相同，即矩阵

int[][] b = new int[8][];

只规定了高维数组，此时每个高维数组内的元素为null；

null在使用时，需要重新定义，数组的长度任意；

面向对象

方法内：

引用数据类型与基本数据类型的区别：

    引用数据类型的数据，称为对象，存储在某一个特定区域，称之为堆；

    引用数据类型的变量，也存储在某一个特定区域内，称之为栈；

   引用数据类型的变量里存储的不是数据，是对象的地理信息

   基本数据类型的数据，不叫对象；

   基本数据类型的变量，存储的不是变量的地理信息，是数据

（1）方法：即功能，封装了一段逻辑代码；

（2）方法的定义：

修饰词  返回值类型 方法名（形式参数）{

  逻辑代码

}

（3）方法的位置：

在类中，方法是并列的，与main方法是并列关系，在一个类中可以有多个方法；

（4）修饰词：public 公共类

private：私有类

protected：受保护的类

（5）返回值类型：

void 无返回值类型；

如果返回值类型标记的是java语言的某一个类型名时，return关键字后面必须跟着一个此类型的数据或者变量，

return关键字后面的数据就是要返回的数据，返回给调用者使用；

如：public int Number(){

int num = Math.random();

return num;

}

在这段代码中，Math.random()返回一个随机数据给main方法，返回的随机数据存储在num中，main方法调用num来获取返回的数据；

4种类型

reg1:

    public void Angelbaby(){

      int a = 5;

      int b = 4;

      int c = a+b;

System.out.println(c);

}

reg2

    public int Angelbaby(){

        int a = 5;

        int b = 4;

        int c = a+b;

return c;

}

reg3

    public void Angelbaby(int a,int b){

          int c = a+b;

System.out.println(c);

}

reg4

    public int Angelbaby(int a,int b){

             int c = a+b;

return c;

}

方法的调用：

reg1

  public static void main(String[] args){

         Angelbaby();

}

reg2

public static void main(String[] args){

     int x = Angelbaby() ;

System.out.println();

}

reg3

public static void main(String[] args){

 Angelbaby(3,5);

}

reg4

public static void main(String[] args){

int x  = 5;

int z  = 4;

     int y  ==Angelbaby();

System.out.println(y);

}

总结：

无返回值时，

方法名（有参就传参 ）;

有返回值时

返回值类型  变量名  =  方法名（有参就传参）;

面向对象（使用eclipse）

新建项目 java protect

在src里创建一个包；

包名为 域名后缀.域名.项目名.模块

在包里创建一个类，类是程序里的基本单元，类里可以写多个方法，

想把那个在内存中运行的那个图画下来，好像不能画图

java编程语言是纯粹的面向对象思想语言，

现在程序开发有两个主流方法：

（1）结构化程序设计，也叫面向过程程序设计

结构化程序设计主张以功能步骤来进行软件设计。

如在解决问题时，主张是思考的是解决问题的思想步骤；

如在围棋游戏中；

游戏开始，白起先走，画图，判断输赢，黑棋走，画图，判断输赢...返回，游戏结束

结构化程序设计是以函数为程序单元，从一个函数开始，调用其他普通函数，进行一些数据处理，一直调用下去

设计思想：

自顶而下，逐步精分，模块化

（2）面向对象程序设计

     它使用类，对象，继承，封装，消息等概念来进行程序设计，主要从现实世界的客观事物（即对象）出发来进行开发软件系统

尽可能的运用人的自然思维方式，从客观事物来思考问题，认识问题，从这些事物的本质特点，来抽象出系统想要的类，

   类是程序的基本单元

运用面向对象思维来设计围棋游戏；

黑白棋子  棋盘  输赢规则；

类是面向对象编程的基本单元，类含有一类事物的共同特征，类可以产生多个对象，这些对象构成了程序中所需要的数据，

软件系统是由多个类组成，类是一类事物的抽象体现，而这些事物都有一些状态数据，即Filed，如人有身高，体重，名字，爱好等，在做程序设计时，只关心业务所需要的数据

Filed，我们称之为成员变量，成员变量是在类体中定义的，也可以称之为属性，是类带有的属性信息，

局部变量，是在方法中定义的，是用来实现方法的，

类除了封装一些事物的状态信息外，还提供了操作这些状态数据的方法（Method），实现逻辑

从以上我们可以总结出：

    成员变量+方法 = 类的定义

完成一个"猪八戒吃西瓜"这样的逻辑

面向过程：函数是核心

吃（猪八戒，西瓜）

面向对象：类是核心

猪八戒.吃（西瓜）

面向对象的粒度要比面向过程大，相对来说简单，容易

用成员变量总结一类事物的共同特征；

用方法来总结一类事物的共同行为，

类的定义： = 成员变量+方法

格式语法：

修饰词  class   类名{

type  Filed1；

type  Filed2；

...

    修饰词 返回值类型  Method1；

    修饰词 返回值类型  Method2；

....

}

定义一个Person类；

public class Person{

    String name;

    char gender;

    int age;

    String haboy;

public String name(){

String str = "他的名字叫"+name;

return str;

}

调用的用法如下：

public static void main(String[] args){

Person p = new Person();

p.name = "Angelbaby";

p.name();

}

对象：是类的实例化，即类中的个体；

 如何创建对象，使用关键字new；

类名  对象名（引用变量）   =   new 类名();

引用变量，简称引用，存储的是对象在内存中的位置信息；

成员变量的调用：

引用.变量名  =  

方法的调用：

引用.方法名(有参就传参)；

类与对象的关系：

类是对象的模板，对象是类的实例化

 

内存管理机制：

     jvm将其管理的内存分为三个区域：方法区，堆，栈

方法区：在程序运行时，将所需要的class文件（类的信息）加载到此空间；

堆：用于存放引用类型产生的对象，如果对象有成员变量，会给成员变量分配空间；

栈：方法内的变量（局部变量）是在栈中开辟的；

值传递：

基本数据类型的变量里存储的是基本数据类型的变量；

int a = 5;

int b = a;//将a中的5复制了一份，传递给了b；

址传递：

引用数据类型的变量里存储的是对象的地址信息；

Car c = new Car();

Car d = c;//将c里的地址信息复制了一份，转递给了d;

空指针异常：

程序在运行过程中，可能会出现空指针异常，出现的原因：

Car a = null;

System.out.println(c.color);