java程序设计基础知识.docx

上传人:b****6 文档编号:5964681 上传时间:2023-01-02 格式:DOCX 页数:26 大小:30.19KB
下载 相关 举报
java程序设计基础知识.docx_第1页
第1页 / 共26页
java程序设计基础知识.docx_第2页
第2页 / 共26页
java程序设计基础知识.docx_第3页
第3页 / 共26页
java程序设计基础知识.docx_第4页
第4页 / 共26页
java程序设计基础知识.docx_第5页
第5页 / 共26页
点击查看更多>>
下载资源
资源描述

java程序设计基础知识.docx

《java程序设计基础知识.docx》由会员分享,可在线阅读,更多相关《java程序设计基础知识.docx(26页珍藏版)》请在冰豆网上搜索。

java程序设计基础知识.docx

java程序设计基础知识

目录

1、JAVA概述3

1.1程序设计语言3

1.2Java的特点3

1.3JDK的设置3

1.4编译和运行java程序3

2、Java基础4

2.1标识符和关键字4

2.1.1标识符4

2.1.2关键字:

4

2.2数据类型与常量、变量5

2.2.1字符类型(char)5

2.2.2布尔型(Boolean)6

2.2.3常量(final)6

2.2.4变量6

2.3运算符和表达式6

2.3.1运算符6

2.3.2数据类型转换7

3、基本控制结构7

3.1顺序结构7

3.2选择结构7

3.2.1If语句7

3.2.2switch语句7

3.3循环结构8

3.3.1While语句8

3.3.2Do…while8

3.3.3for语句8

3.3.4多重循环8

3.4跳转语句8

4、方法9

4.1书写方法的格式:

9

4.2方法声明9

4.3方法调用9

4.4递归9

5、数组10

5.1一维数组10

5.1.1声明10

5.1.2初始化数组11

5.1.3数组长度11

5.2多维数组11

5.3数组长度11

6、字符串11

6.1字符串变量的声明和初始化11

6.2字符串操作11

6.2.1访问字符串11

6.2.2字符串比较12

6.2.3数据类型转换12

7、类和对象12

7.1架构师的思维方式:

12

7.2注意区分:

对象(本身)、对象的实现者、对象的调用者。

13

7.3面向对象内存结构13

7.4类的声明14

7.5实例化对象14

7.6构造方法:

14

8、类的封装15

8.1访问权限15

8.2类成员15

8.3实例成员变量的使用:

16

静态(Static)16

8.4什么情况下直接调用属性,什么情况下调用封装属性的get和set方法17

8.5数学函数类方法17

9、类的继承18

9.1继承的实现18

9.1.1定义子类18

9.1.2继承原则18

9.1.3Super引用18

9.1.4This引用18

9.2类的多态性18

9.2.1方法重载18

9.2.2方法覆盖19

10、Final类和final成员19

11、抽象类和方法19

12、接口19

12.1声明接口19

12.2实现接口20

13、包20

13.1声名包20

13.2使用包中的类20

13.3导入包中的类20

14、输入输出20

15、设计模式20

15.1单例模式21

15.1.1什么时单例模式:

21

15.1.2单例模式实例21

15.2工厂模式21

15.2.1工厂模式:

21

15.2.2工厂模式实例:

21

16java集合框架22

16.1、Collection接口:

线性结构的存储(类似数组的存储)22

a、集Set接口:

22

b、列表List接口:

22

16.2、Map接口:

存储数据是基于Key/value对23

16.3、中文排序问题23

17Java泛型23

1、JAVA概述

1.1程序设计语言

1.机器语言

2.汇编语言

3.高级语言

1.2Java的特点

1.简单性

2.面向对象

3.安全性

4.平台独立

5.多线程

6.网络功能

7.执行效率

1.3JDK的设置

Path:

--------是bin目录

ClassPath----是lib目录

1.4编译和运行java程序

编译:

javac文件名.java

运行:

java文件名

2、Java基础

2.1标识符和关键字

2.1.1标识符

由字母、数字、下划线、和美元符组成,且第一个字符不能是数字!

不成文的约定:

1.类名首字母大写;

2.常量名全部字母大写;

3.其余的全小写,但第二个单词的第一个字母大写

2.1.2关键字:

int

整型

long

长整型

float

浮点型

double

双精度

char

字符

byte

字节

boolean

布尔型

final

常量

if

如果

else

其它

switch

开关

case

事例

break

跳出循环

default

违约

for

循环

continue

跳出当前循环

do

while

在..之间

null

this

当前对象

implements

实现接口

package

extends

继承

class

void

空的

static

静态的

return

返回

import

导包

true

false

private

私有的

protected

保护的

public

公共的

abstract

抽象的

new

新的

super

父类

throws

抛出异常

throw

抛出异常

Instanceof

类型检查

transient

catch

finally

native

synchronized

volatile

Instanceof//对于父对象的类型检查,父类是否是子类的类型

//用于检查当前Object对象的类型是不是为Integer

If(objInstanceofInteger){}

 

2.2数据类型与常量、变量

Long长整型8字节

Int整型4字节

Short短整型2字节

Byte字节1字节

Float单精度浮点型4字节

Double双精度浮点型8字节

2.2.1字符类型(char)

Charch=’a’;

转义字符功能

\b退格

\t小平制表

\n换行

\r回车

 

2.2.2布尔型(Boolean)

True(真)false(假)

2.2.3常量(final)

[修饰符]类型标识符常量名=(直接)常量;

FinalfloatPI=3.14;

2.2.4变量

[修饰符]类型标识符变量名[=常量];

floata=2.5;

2.3运算符和表达式

2.3.1运算符

●单目运算符:

自增(++)、自减(--)、绝对值(-)

●双目运算符:

加(+)、减(-)、乘(*)、除(/)、取余(%)

●三目运算符:

表达式1?

表达式2:

表达式3

●关系运算符:

大于(>)、小于(<)、等于(==)、

大于等于(>=)、小于等于(<=)、不等于(!

=)

●逻辑运算符:

与(&)、或(|)、非(!

)、异或(^)、条件与(&&)、条件或(||)

●位运算:

运算符用例功能

~~a将a逐位取反

&a&ba、b逐位进行与操作

|a|ba、b逐位进行或操作

^a^ba、b逐位进行异或操作

<

>>a>>ba向右移动b位

>>>a>>>ba向右称动b位移动后的空位用0填充

 

2.3.2数据类型转换

由高到低:

Double

Float

Long

Int

Short

Byte

 

3、基本控制结构

3.1顺序结构

3.2选择结构

3.2.1If语句

if(布尔表达式){//为真就执行语句1

语句1

}elseif(布尔表达式){//为真就执行语句2

语句2

}else{//为假就执行语句3

语句3

3.2.2switch语句

switch(变量){

case常量1:

语句1;break;

case常量2:

语句2;break;

………

default:

语句n

3.3循环结构

3.3.1While语句

While(布尔表达式){

循环体

3.3.2Do…while

Do{

循环体

}while(布尔表达式);

3.3.3for语句

For(inti=1;i<=100;i++){

循环体

3.3.4多重循环

For(){

外循环体

For(){

内循环体

3.4跳转语句

Break语句--------->退出循环

Continue语句------->退出当次循环

 

4、方法

4.1书写方法的格式:

修饰符返回值方法名调用过程中方法体

可能出现的例外

publicint/voidaddNumber(参数)throwExcepion{}

例:

publicintaddNumber(inta,intb){

}

注:

方法名中的参数inta,intb为局部变量

 

4.2方法声明

[修饰符]类型标识符方法名([形参列表]){

声明部分

语句部分

注:

方法分为:

有返回值、无返回值;或都可以分为有参或无参!

有返回值的方法必须在最后一句中有:

return(表达式)

4.3方法调用

方法名(【实际参数】)

注:

参数传递时形参是不能改变实际的,只有参数传递时,所传的是数据地址时,实参才会改变!

4.4递归

n!

=n*(n-1)!

(n-1)!

=(n-1)*(n-2)!

importjava.util.Scanner;//导包

publicclass递归算法{

/**

*采用递归算法求n!

*fac()=1n=1

*n*fac(n-1)n>1

*/

publicstaticvoidmain(String[]args){

递归算法cjc=new递归算法();//实例化类对像

Scannersc=newScanner(System.in);

intk=sc.nextInt();//输入

longf=cjc.fac(k);//调用方法

System.out.println(f);

}

publiclongfac(intn){//定义一个方法

if(n==1){

return1;

}else{

returnn*fac(n-1);//递归调用

}

}

}

5、数组

5.1一维数组

注:

传引用(地址传递):

数组在进行方法的参数传递的时候,传的是数组的首地址,那就意味着在调用的时候,方法里面处理的那个数组就是调用时传入的数组;

所以能够对传入的数组产生影响(比如:

数组,或者类的对象,string)

传值(值传递):

传入的值的拷贝,那么传入的变量,和方法体的变量不是一回事;

所以方法体不能对传入的变量产生作用(比如:

值类型intdoublecharfloat)该类型的变量,

如果能(.)出东西来,那么就是引用类型,反之则不是

5.1.1声明

类型标识符数组名[]

类型标识符[]数组名

5.1.2初始化数组

类型标识符[]数组名=new类型标识符[元素个数]

类型标识符数组名[]={初值表}

5.1.3数组长度

数组名.length

5.2多维数组

和一维数组一样

5.3数组长度

行数:

列数:

数组名.length数组名[行标].length

数组排序:

Arrays.sort(a);//对数组a进行排序

6、字符串

6.1字符串变量的声明和初始化

String字符串变量=newString();

6.2字符串操作

6.2.1访问字符串

1.length()//提取字符串长度

intn=str.length();

2.charcharAt(intindex)//提取字符串中的第index个字符

charch=str.charAt(int3);//提取第三个字符

3.intindexOf(intch)//返回”个“在字符串中的下标

4.intindexOf(Stringstr,intindex)//返回”字符串“在字符串中从7开始出现的位置

5.substring(intindex1,intindex2)//提取出从3到8之间这一个子字符串

publicstaticvoidmain(String[]args){

Stringstr=newString("这是一个字符串操作的测试程序");

intn=str.length();//提取字符串长度

charch=str.charAt(5);//提取字符串中下标为5的字符

intn2=str.indexOf('个');//返回”个“在字符串中的下标

intn3=str.indexOf("字符串",7);//返回”字符串“在字符串中从7开始出现的位置

Stringstr2=str.substring(3,8);//提取出从3到8之间这一个子字符串

System.out.println(n);//14

System.out.println(ch);//符

System.out.println(n2);//3

System.out.println(n3);//-1

System.out.println(str2);//个字符串操作

}

6.2.2字符串比较

equals(objectobj)//区分大小写字符串比较

equalsIgnoreCase(Stringstr)//不区分大小写的字符串比较

compareTo(Stringstr)//比较二个字符串的大小

6.2.3数据类型转换

String.valueof(基本类型数据)

7、类和对象

什么是对象:

EVERYTHINGISOBJECT(万物皆对象)

7.1架构师的思维方式:

当你设计类的时候:

1、你设计类是由你模拟的事务决定;

2、类的属性,仅限于你需要用到的;

3、设计类的行为的时候,用第一人称的视角来思考,假如你就是那个类,那么你的行为是什么;

4、对于行为方法中不能写死的东西,可以考虑用方法的参数来传入;

5、对于方法参数和方法的返回值,不在局限于intdouble之类的基本类数据类型,而是扩展到所有你自己定义的复杂的数据类型;

6、在进行方法的设计的时候,先考虑参数,后考虑反回值;

7、在实现方法的时候,想清楚你和被你施加动作的东西,想清楚动作施加了之后你发生了什么变化,被你施加动作的东西发生了什么变化。

注意:

在对象变量中存放的是引用(地址);在简单变量中存放的是数值。

面向对象思想来源:

我们因需要描述更加复杂的现实世界,比如星际争霸的场面,需要有更多的数据类型,但是正常情况下,我们没有,我们只有int、double等等,一些简单的数据类型,所以,我们需要创建更多更复杂的数据类型。

面向对象技术,让我们能够追寻更加复杂的数据类型,来模拟我们的现实世界

面向对象和面向过程的区别:

面向对象的思维方式,不再是一开始就去想一步步的步骤,而是先创建模拟世界中间需要的复杂的数据类型

星际争霸:

先创建复杂数据类型,比如机枪兵类型,飞龙类型

创建了之后才去实现具体的过程

面向对象的好处:

1、能够帮助我们更加形象的写出人性化的程序

2、能够实现内容的封装,比如:

兵1.攻击(飞龙1)

3、能够让代码变得更加简洁,继承等面向对象的技术

4、能够让你站在巨人的肩膀上

7.2注意区分:

对象(本身)、对象的实现者、对象的调用者。

分析对象主要从方法开始。

我们通过类来看待对象,类是对象的抽象。

其次,采用面向对象方法可以使系统各部分各司其职、各尽所能。

7.3面向对象内存结构

//所有变量都是存在栈中的,只是值类型存值,而引用类型存地址

创建对象时,分两步:

第一步是在堆中开辟空间,存放该新创建的对象

第二步是在栈中开辟空间,存放是该对象在堆中的首地址

堆和栈本质上都是内存中的一段区域,他们是不同的区域,分别取名为堆和栈,

功能使用上有不同,在创建对象时,堆存储的是对象,栈存储的是对象的首地址

java中,数据类型

1、值类型(基本数据类型)数值类型:

intdoublelongfloat

非数值类型:

char

值类存储在栈里

2、引用类型:

数组,字符串,对象

引用类型存储在堆里,但是栈里有一个空间存储该引用类型的首地址

值类型和引用类型的访问效率问题:

1、值类型直接在栈中进行访问,效率最高

2、引用类型是通过访问栈中存储的对象的首地址,然后找到对应堆中地址的对象,所以引用类型的访问效率低

变量都是存在栈里的,只不是值类型的变量直存储的是值,而引用类型的变量存储的是堆中对象的首地址

定义引用类型的变量时,如果不让它引用对象,而又要初始化,那么我们一般设定为null

null表示空的意思。

null本质上就是0,低表的就是0地址,对于0地址的空间,系统是不允许占用,所以,可以统一用于表示空对旬或者说没有引用任何对象。

7.4类的声明

【修饰符】class类名【extends父类名】【implements接口名列表】{

成员变量声明部分

成员方法声明部分

 

7.5实例化对象

实例化对象:

类名对象名=new类名(形参列表);

对象使用:

对象名.成员变量名;

对象名.方法名(实参列表);

 

7.6构造方法:

1.方法名与类名相同的方法称为构造方法;

2.构造方法没有返回值,前面不能有返回值类型,也不能有void;

3.程序中不能直接调用构造方法;

4.构造方法没有返回值。

格式为:

public方法名。

5.构造方法是在对象生成的过程中自动调用,不可能利用指令去调用。

6.如果我们未给系统提供一个构造方法,那么系统会自动提供一个为空的构造方法。

一个类可以构造多个构造方法,但多个构造方法的参数表一定不同,参数顺序不同即属于不同的构造方法:

publicstudent(stringname,inta){

}

publicstudent(inta,stringname){

}

8、类的封装

8.1访问权限

Java中共有四种访问权限:

public(公有的)、protected(受保护的)、缺省的和private(私有的)

访问权限

权限修饰符

本类

本类所在的包

其他包中的子类

其他包中的非子类

Public

Protected

缺省

Private

 

8.2类成员

类名.类成员变量名

对象名.类成员变量名

类名.类成员方法名()

对象名.类成员方法名()

类成员是属于类的,类成员需要使用static(静态的)修饰,类成员也称为静态成员。

类成员包括类成员变量和方法。

通过类名可以直接访问类成员变量、调用类成员方法即使没有创建对象,也可以引用类成员。

类成员也可以通过对象名引用。

publicclass类成员变量{

Stringname;//实例成员变量

Stringsex;//实例成员变量

staticintcount=0;//类成员变量

publicstaticvoidmain(String[]args){

System.out.println(类成员变量.count);//直接调用类成员变量

}

}

8.3实例成员变量的使用:

必须先要定义类对象:

对象名.实例成员变量名

对象名.实例成员方法

静态(Static)//静态的--->也就是类的专属

1、我们一般情况下,定义的属性,通常都属于该类型的个体,是具体对象所拥有的属性,比如名字,年龄,这些都是具体对象的属性。

具体对象的属性可以通过(通过对象,属性实现调用)

2、但是还存在另外一钏属性,它不再单单隶属于某些个体,而属于类的。

比如:

人类的数量这种属性。

(通过类,属性调用)

3、当你new对象的时候,第一次new的时候,系统首先会加载类,把它作为产生对象的模板,在这个模板中,包含类的(静态的),也包含对象的,类一经加载过后,无需再次加载。

4、new对象的时候,对象通过类的模板,实施对应拷贝,但是只会包含对象的成类,而不会包含类的成员。

5、属于类的成员,只会有一个。

比如人类的数量这样一个成员,就只有一个,但是属于人对象的年龄,则是每个具体的对象一个。

6、对象(非静态)的方法中,可以访问类(静态)的属性和方法。

7、静态的方法中,可以访问该类的静态属性。

8、静态的方法中,不可以直接访问该类的非静态属性,除非new对象,用对象来调用

9、静态块

static{

//这里面写静态属性,给他们赋值

}

静态块是在类被加载的时候自动调用的,但它只被调用一次;

静态块的作用:

静态块一般用于实现静态属性的初始化;可以放置更多,更复杂的初始化代码,而不是仅仅只是个初值。

10、非静态块

{//这是一个非静态块

//代码区

}

非静态块是在new对象时候自动调用的,只是先于构造方法执行(在构造方法之前执行)

非静态块的作用类似于构造方法,都用于非静态属性的初始化。

11、单例模式

什么时单例模式:

限制只能创建一个对象的设计模式(面向对象的应用)

8.4什么情况下直接调用属性,什么情况下调用封装属性的get和set方法

1、类中:

(调用自己的)

在本类中,如果需要访问自己的属性,一般情况下直接调用属性来访问;但在写构造方法的时候,最好要用自己封装的set属性方法来完成参数的初始化。

2、类外:

(调用别人的)

类中间调用其他的类的属性的时候,那么如果对方的属性是非公共的,那么只能通过对方提供的公共的get或set方法来实现访问。

8.5数学函数类方法

Math.方法名()

Sin(doublex)

Cos(doublex)

Log(doublex)//返回X的自然对数

exp(doublex)//返回E的X次方

abs(doublex)//返回X的绝对值

max(doublex,doubley)//返回X和Y中的较大值

sqrt(doublex)//返回X的平方根

random(doublex)//返回[0,1]区间内的随机数

pow(doublex,doubley)//返回y的x次方法

9、类的继承

9.1继承的实现

9.1.1定义子类

【修饰符】class类名extends父类名{

成员变量声名部分

成员

展开阅读全文
相关资源
猜你喜欢
相关搜索

当前位置:首页 > 教学研究 > 教学反思汇报

copyright@ 2008-2022 冰豆网网站版权所有

经营许可证编号:鄂ICP备2022015515号-1