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<arr.length;i++){

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<arr.length-1;i++){

for(int j = 1;j<arrlength-1-i;j++){

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

int t = arr[i];

arr[i] = arr[j];

arr[j] = t;

}

}

}

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

写两层for循环

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

int index = i;

boolea f = true

for (int j = i+1;j<arr.length;j++){

if(arr[index]<arr[j]){

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);

 

 

 

 

 

    

 

 

 

 

 

 

 

 

 

 

 

 

    

展开阅读全文
©️2020 CSDN 皮肤主题: 大白 设计师: CSDN官方博客 返回首页
实付0元
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值