黑马程序员_java面向过程总结

本文详细介绍了Java编程的基础知识，包括计算机基础知识、Java语言发展史、版本、平台、特点、开发和执行流程等内容。重点阐述了Java的跨平台特性，通过JDK和JRE的介绍，解释了Java程序如何在不同环境下运行。此外，文章还深入讨论了Java环境变量设置、注释、关键字、标识符等核心概念，并提供了实际操作案例。对于初学者而言，这是一篇全面了解Java编程入门指南。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

------<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！ -------

第一部分：

1：计算机的基础知识

(1)计算机

俗称：电脑

(2)计算机硬件

支撑电脑软件执行的装备

(3)计算机软件

按照某种要求能够自动执行的东西。

系统软件：

windows,linux,mac,android

应用软件：

QQ,Editpls,飞Q

(4)软件开发

用开发工具+计算机语言制作软件

(5)计算机语言

人和计算机交流的一种特殊表现形式。

计算机只能识别0，1这样的数据。

(6)人机交互

图形界面方式：方便直观。

DOS窗口方法：需要记忆命令，稍微复杂。

(7)功能键和快捷键:

tab,shift,alt,ctrl,windows,空格,prtsc,上下左右键,回车键

(8)DOS命令:

A:盘符的切换：

d:回车

B:cd进入目录

单级

多级

C:回退目录

单级

多级

2：Java语言的知识:

(1)Java语言的发展史。

詹姆斯-高斯林 Java之父。

(2)版本：

1.4.2

1.5 -- 5.0

1.6 -- 6.0

1.7 -- 7.0

(3)Java的平台

A:JavaSE 桌面应用程序，其他两种的基础。

B:JavaME 移动设备的开发,目前我们要学习的话就学习android。

C:JavaEE web页面的开发,企业级开发,这是我们的重点。

(4)java语言的特点

A:几个小特点，将来都会学到。

B:两个比较重要的特点：

开源

跨平台

(5)java语言如何实现跨平台的呢(理解)

通过一个语言翻译的原理讲解的。

java语言的翻译是jvm。java虚拟机。

Java语言是跨平台的，jvm不是跨平台的。

3：Java语言的开发和执行流程:

(1)JDK,JRE各自的作用

JDK: JRE+开发工具是java程序的开发环境

JRE: JVM+class library 是java程序的运行环境

JVM: 保证Java语言跨平台

(2)JDK的下载，安装，卸载。

注意：

安装过程中，建议不要有空格和中文目录，以及其他的特殊字符目录。

(3)HelloWorld案例：

在JDK的安装的bin目录下。

class HelloWorld
		{
			public static void main(String[] args)
			{
				System.out.println("HelloWorld");
			}
		}

解释：

java程序的最基本单位是类。

A:class HelloWorld

class是定义类的关键字。后面跟的是类的名称。

B:public static void main(String[] args)

主方法，被jvm调用。是java程序的入口。java程序的执行必须从这里开始。

C:System.out.println("HelloWorld");

输出语句，"HelloWorld"的内容是可以改变的。

最后的分号不能少，是该语句的一个组成部分。

注意事项：

A:括号的问题。配对要一致。

B:格式的问题。该空格的，一定要空格。遇到{一般都会缩进一个tab的位置。

(4)Java程序的开发和执行流程

A:编写一个java源文件。

B:通过javac命令编译该文件，生成class文件。字节码文件。

javac java源文件名称

C:通过java命令执行class文件。

java class文件名不包括扩展名

举例：

javac HelloWorld.java

java HelloWorld

4：常见问题:

(1)文件后缀名被隐藏。

(2)大小写，及单词的拼写。

(3)非法字符的问题，肯定是中英文的问题。

5：环境变量(理解)

(1)path环境变量

path路径中配置某目录，那么，将来该目录下的exe文件的名称，就可以直接在dos窗口执行。

A:方式一

直接把D: \Java\jdk1.7.0_60\bin添加到path的最前面。

B:方式二

新建JAVA_HOME,值是：D:\ Java\jdk1.7.0_60

修改path,值是：%JAVA_HOME%\bin;以前的path内容。

作用：是为了javac命令可以在任意目录下执行。

(2)classpath环境变量

配置：

新建classpath,值就是class文件所在的目录。

作用：是为了class文件可以在任意目录下执行。

第二部分：

1：注释:

(1)就是对代码的解释说明性的文字。

(2)分类：

A:单行注释 //

B:多行注释 /* */

C:文档注释(面向对象部分讲解)

(3)作用：

A:对程序进行说明，给人看。

B:可以对程序进行排错。

2：关键字:

(1)被java语言赋予特定含义的单词。

(2)特点：

所有的关键字全部小写。

3：标识符:

(1)就是给类,接口,方法,变量等起名字。

(2)组成规则：

A:由数字,字母,_以及$组成。

B:不能以数字开头。

C:不能是java中的关键字。

(3)常见的命名规则：

A:包全部小写

单级：com,cn,liuyi

多级：cn.itcast,com.baidu

B:类或者接口

一个单词：Student,Teacher

多个单词：HelloWorld,MakeName

C:方法或者变量

一个单词：main(),name,age

多个单词：studentName,showName()

D:常量全部大写

一个单词：MAX

多个单词：STUDENT_MAX_AGE

4：常量:

(1)在程序的执行过程中，其值是不发生改变的量。

(2)分类：

A:字面值常量

B:自定义常量(面向对象部分讲解)

(3)字面值常量的分类：

A:整数常量 12,23

B:浮点数常量 12.345

C:字符常量 'a','A','2'

D:布尔常量 true,false

E:字符串常量 "hello","world"

F:空常量 null(后面说)

5：进制转换相关:

(1)进制：是一种计数的方式。

x进制表示逢x进1。

(2)java中的整数的表现形式：

二进制：以0b开头，由0和1组成。

八进制：以0开头，由0-7组成。

十进制：由0-9组成。整数默认是十进制。

十六进制：以0x开头，由0-9,a-f组成。

(3)其他进制到十进制的转换：

系数*基数的权次幂的和。

(4)十进制到其他进制的转换：

除基取余,直到商为0,余数反转。

(5)x进制到y进制

x - 十进制 -- y进制

(6)二进制 -- 八进制或者十六进制

A:二进制 -- 十进制 -- 八进制或者十六进制

B:二进制 -- 三位组合 -- 八进制

二进制 -- 四位组合 -- 十六进制

(7)8421码

1 1 1 1 1 1 1 1

128 64 32 16 8 4 2 1

6：有符号数据表示法:

(1)在java中，我们的数据是有正负之分的。

(2)在计算机存储和运算的过程中，数据都是采用补码进行的。

(3)原码，反码，补码

正数：原码，反码，补码和二进制形式相同。

负数：原码和正数的二进制的数值部分相同，符号位是1。

反码和原码的区别是：符号位不变，数值为1变0，0变1。

补码：反码+1

(4)byte的范围：

byte占用1个字节：

0 1111111 - 127

(byte)128 -- -128。

1 0000000 -- 这里的1既可以看成符合位，又可以看成数值位。

-128

除了：1 0000000 这种特殊情况外，其他的是什么样子就是什么样子的。

7：变量:

(1)在程序执行的过程中，其值在某个范围内可以发生改变的量。

(2)格式：

A:数据类型变量名 = 初始化值;

int a = 10;

B:数据类型变量名;

变量名 = 初始化值;

int a;

a = 10;

(3)注意：

在使用一个变量的时候，必须先声明，赋值，最后才能使用。

8：数据类型:

(1)分类：

基本类型：4类8种。

引用类型：类，接口，数组。(后面讲)

(2)基本类型：

整数：占用的字节

byte 1

short 2

int 4

long 8

浮点数：

float 4

double 8

字符：

char 2

布尔：

boolean 1

(3)注意：

A:整数默认是int类型，浮点数默认是double类型。

B:如果一个数据想表示为long类型，要加L或者l。

如果一个数据想表示为float类型，要加F或者f。

9：数据类型转换:

(1)在运算的时候，要求数据的类型一致。

(2)分类：

boolean类型不参与。

A:隐式转换：(自动转换)

从小到大。

byte,short,char --> int --> long --> float --> double

B:显示转换：(强制转换)

从大到小。

格式：

目标数据类型变量 = (目标数据类型)(被转换的内容);

(3)long --> float为什么是这个样子的?

因为他们底层的存储方式不一样。

long : 2^63

float : 3.4*10^38

3.4*10^38 > 2*10^38 > 2*8^38 > 2*2^3^38 = 2*2^114 > 2^63

10：运算符:

A:算术运算符

+，-，*，/，%，++，--

+:正号,加法,字符串连接符

%:取得余数

++,--:

单独使用：在操作数据的前后效果一致。

参与操作使用：

在操作数据的前面，是先++或者--，然后参与操作。

在操作数据的后面，是先参与操作，后++或者--。

B:赋值运算符

=:把右边的内容赋值给左边

+=,-=,*=,/=,%=：把左边的和右边的操作后赋值给左边。

注意：

+=隐含了强制类型转换。

x+=y;等价与：x = (x的数据类型)(x + y);

11：面试题：

A:类型转换

byte b1 = 3;

byte b2 = 4;

byte b3 = b1 + b2;

byte b4 = 3 + 4;

B:强制转换数据溢出的问题：

byte b = (byte)130;

byte bb = (byte)300;

C:赋值运算符

short s = 1;

s = s + 1;

和

short s = 1;

s += 1;

哪个有问题。

第三部分：

1：运算符:

(1)算术运算符

+,-,*,/,%,++,--

+:正号,加法,字符串连接符

%:两数相除,得到余数

++,--:

单独使用：在操作数的前后，效果一致。

参与操作使用：

在操作数前，先++或者--，再参与操作。

在操作数后，先参与操作，再++或者--。

(2)赋值运算符

=,+=,-=,*=,/=,%=

=:把右边赋值给左边。

?=:把左边和右边操作后赋值给左边。

注意：赋值的左边不能是常量。

(3)比较运算符

==,!=,>,>=,<,<=

A:结果肯定是boolean类型。

B:不要把==写出=。

(4)逻辑运算符

&:有false则false

|:有true则true

^:相同为false，不同为true。通过情侣关系来理解。

!:非false则true,非true则false。偶数次不改变以前的真假。

&&:和&的结果一样,但是具有短路效果。左边有false,右边不执行。

||:和|的结果一样,但是具有短路效果。左边有true,右边不执行。

(5)位运算符:

要想操作，就必须把所有的数据转换为二进制。然后操作。

注意：

^：对同一个数据异或两次，该数本身不变。

数据交换：假设a,b是已经知道的int类型的变量

A:方式1(掌握开发用)

int temp = a;

a = b;

b = temp;

B:方式2(掌握面试用)

左边a,b,a

右边a^b

a = a ^ b;

b = a ^ b;

a = a ^ b;

C:知道就行

a = a + b;

b = a - b;

a = a - b;

D:知道就行

a = (a+b)-(b=a);

(6)三元运算符

格式：

比较表达式?值1:值2;

执行流程：

如果比较表达式是true,结果是值1;

如果比较表达式是false,结果是值2;

案例：

A:比较两个数是否相同

B:获取两个数中的最大值

C:获取三个数据中的最大值

D:做C题目的时候，还可以练习三元运算符的嵌套。

2：键盘录入:

(1)键盘录入数据，让我们的程序灵活性更高。

(2)步骤：

A:导包

import java.util.Scanner;

B:创建对象

Scanner sc = new Scanner(System.in);

C:调用方法

int i = sc.nextInt();

(3)案例：

把前面的案例通过键盘录入改进数据。

3：顺序结构:

(1)程序的流程控制语句：

A:顺序结构

从上往下依次执行

B:选择结构

if,switch

C:循环结构

for,while,do...while

4：选择结构之if语句:

(1)格式：

方式1：

if(比较表达式) {

语句体;

}

执行流程：

看比较表达式的返回值：

true:执行语句体;

false:不执行，可以继续向下执行。

方式2：

if(比较表达式) {

语句体1;

}else {

语句体2;

}

执行流程：

看比较表达式的返回值：

true:执行语句体1;

false:执行语句体2;

方式3：

if(比较表达式1) {

语句体1;

}else if(比较表达式2) {

语句体2;

}

else if(比较表达式3) {

语句体3;

}

...

else if(比较表达式n) {

语句体n;

}

执行流程：

看比较表达式1的返回值：

true:执行语句体1;

false:看比较表达式2的返回值：

true:执行语句体2;

false:...

可能所有的语句体都没有被执行。

方式4：

if(比较表达式1) {

语句体1;

}else if(比较表达式2) {

语句体2;

}

else if(比较表达式3) {

语句体3;

}

...

else if(比较表达式n) {

语句体n;

}else {

语句体n+1;

}

执行流程：

看比较表达式1的返回值：

true:执行语句体1;

false:看比较表达式2的返回值：

true:执行语句体2;

false:...

所有的都不匹配，执行else里面的语句体n+1。

肯定有一个被执行。

(2)if语句的格式注意事项：

A:比较表达式无论是简单还是复杂，结果肯定是boolean类型。

B:语句体如果是一条,可以省略大括号；如果是多条，就不能省略。

建议：无论一条还是多条，都不省略大括号。

C:不要随便加分号。

一般：有分号，就没有左大括号，有左大括号就没有分号。

D:每种if语句其实都是一个整体，有一条语句执行，其他的将不再执行。

(3)案例：

A:判断两个数据是否相等。

B:获取两个数据中的最大值。

C:判断三个数据中的最大值。(if语句的嵌套)

D:根据给定的月份,输出对应的季节。

E:根据给出的分数,输出对应的等级。

F:根据给定的x的值，确定y的值。

5：选择结构之switch语句:

(1)格式：

switch(表达式) {

case 值1:

语句1;

break;

case 值2:

语句2;

break;

case 值3:

语句3;

break;

...

default:

语句n;

//break;

}

解释：

A:表达式的取值：

byte,short,int,char

JDK5以后可以是枚举。

JDK7以后可以是字符串。

B:case后面值就是表达式要匹配的内容。

case后面的值是不能重复的。

C:如果所有的case都没有和表达式匹配的，就执行default所控制的内容。

D:break是结束的意思。

(2)执行流程：

A:计算表达式的值。

B:用这个值和case的值依次匹配。

C:要么匹配成功：就执行对应的匹配所控制的语句

要么匹配失败：就执行default的所控制的语句

(3)switch语句的问题：

A:case和default的顺序关系?

a:位置上没有关系。但是建议按照基本格式写。

b:执行上有关系,现执行case匹配，如果没有，才能执行default。

B:break可以省略吗?

可以。但是有可能是你不想要的结果。所以，建议不省略。

C:最后一个语句的break是可以省略的。

D:switch语句的结束条件：

a:遇到break。

b:执行到末尾。

(4)案例：

A:根据给出的数字1,2,...，输出对应的星期几。(byte,short,int)

B:根据给定的选项,输出对应的选择。(char)

C:根据给定的字符串，输出对应的字符串。(String)

6：选择结构的语句使用的时候，如果选择呢?

如果是有限个数的值，用switch。

其他全部用if语句。

如果是一种判断：第一种

如果是二种判断：第二种

如果是多种判断：第三种或者第四中。优先考虑第四种。

第四部分

1：for循环:

(1)格式：

for(初始化表达式; 控制条件表达式; 增量表达式) {

循环体语句;

}

执行流程：

A:先执行初始化表达式

B:执行控制条件表达式

C:看B的返回值：

true:执行循环体语句和增量表达式,回到B继续。

false:就结束for循环。

(2)for循环的注意事项：

A:注意格式问题。

B:分号和大括号的问题。

C:大括号建议不要省略。

(3)案例：

A:重复内容输出多次。

B:输出1-10或者10-1的数据。

C:求1-10的和。

D:求5的阶乘。

E:求1-100的偶数或者奇数和。

F:水仙花数。

G:统计水仙花数有多少个。

H:满足条件的五位数,以及统计个数。

I:有这样的数据：对3整除余2，对5整除余3，对7整除余2。

请编写程序输出1-1000之内这样的数据。

2：while和do...while循环:

(1)while:

基本格式：

while(条件表达式) {

语句;

}

扩展格式：

初始化表达式;

while(控制条件表达式) {

循环体语句;

增量表达式

}

执行流程：

A:先执行初始化表达式

B:执行控制条件表达式

C:看B的返回值：

true:执行循环体语句和增量表达式,回到B继续。

false:就结束while循环。

注意：

while循环和for循环是可以等价转换的。

区别：

增量如果还要继续使用，就用while循环。否则就用for循环。

使用场景：

A:是一个明确的范围，用for。

B:次数不明确，用while循环。

举例：吃葡萄。

案例：

珠穆朗玛峰的案例。

(2)do...while：

基本格式：

do {

语句;

}while(条件表达式);

扩展格式：

初始化表达式;

do {

循环体语句;

增量表达式

}while(控制条件表达式);

执行流程：

A:先执行初始化表达式

B:执行循环体语句和增量表达式

C:执行控制条件表达式

D:看C的返回值：

true:回到B继续。

false:就结束do...while循环循环。

和其他两种循环的区别：

do...while循环至少执行一次循环体。

3：循环嵌套:

(1)这两天作业的格式：

if语句

switch语句

for语句

while语句

for里面嵌套if判断

for里面嵌套for循环

(2)案例：

A:一个4行5列的矩形*。

*****

B:一个正三角形

***

****

*****

C:九九乘法表

for(int x=1; x<=9; x++) {

for(int y=1; y<=x; y++) {

System.out.print(y+"*"+x+"="+x*y+"\t");

}

System.out.println();

}

4：continue和break:

(1)作用：

用于控制循环语句跳转的。

(2)在哪里使用呢?

不能单独使用。

continue必须在循环中。

break可以在循环和switch语句中。

(3)区别：

continue：结束本次循环，进入下一次循环。

break：结束当前循环。

(4)带标号的跳转

可以退出多层循环。

5：函数:

(1)函数：完成特定功能的代码块。

(2)格式：

修饰符返回值类型函数名(数据类型变量1,数据类型变量2,...) {

函数体;

return 返回值;

}

修饰符：public static

返回值类型：功能结果对应的数据类型

函数名：就是函数的名称，为了方便调用

参数：

形式参数：用于接收实际参数的变量

实际参数：实际参与操作的数据

函数体：就是按照正常逻辑完成功能的代码

return 返回值：功能的结果，由return返回。

(3)如何写一个函数：

两个明确：

返回值类型：

参数列表：

(4)定义函数的注意事项：

A:函数之间是平级关系。

B:函数不能嵌套定义。

C:参数之间用逗号隔开。

(5)针对一个带有明确返回值的函数的调用：

A:单独调用，没有意义。

B:输出调用，但是不够好，因为我可能需要对结果进行进一步的操作。

讲课为了方便，我可能经常采用这种方式。

C:赋值调用，然后输出。推荐方案

a:名称不要写错，记住函数是有括号的。

b:人家要什么类型的参数，你就给什么类型的参数。

c:人家要几个参数，你就给几个参数。

d:人家返回什么类型的数据，你就应该用什么类型接收。

(6)案例：

A:求和案例

B:比较两个数据是否相等的案例

第五部分：

1：函数:

(1)函数：是完成特定功能的代码块。

(2)函数的格式：

省略...

(3)函数的特点：

A:函数只有被调用才执行。

B:函数间是平级的关系，不能嵌套定义。

(4)如何写一个函数：两个明确

A:返回值类型

B:参数列表

(5)函数调用

A:非void类型的函数

a:单独调用，没有意义。

b:输出调用，不够好。(上课方便就这样用了)

c:赋值调用，推荐方案。

B:void类型的函数

单独调用。

(6)案例：

A:获取两个数中的最大值。

B:判断两个数是否相等。

C:求和案例。

D:nn乘法表。

(7)函数重载

函数名相同，参数列表不同。(个数和类型)

与返回值类型无关。

2：数组(一维数组)

(1)数组：存储同一种类型的多个元素的容器。

(2)特点：

每一个元素都有编号，(索引)。方便我们获取数组中的元素的。

从0开始编号。数组的最大索引是长度-1。

(3)定义格式：

A:int[] arr = new int[3];

B:int arr[] = new int[3];

C:int[] arr = new int[]{1,2,3};

D:int[] arr = {1,2,3};

(4)常见操作：

数组的长度：数组名.length

A:遍历数组

public static void printArray(int[] arr) {
				for(int x=0; x<arr.length; x++) {
					System.out.println(arr[x]);
				}
			}
			10
			20
			30
			//改进版
			public static void printArray(int[] arr) {
				for(int x=0; x<arr.length; x++) {
					if(x==arr.length-1) {
						System.out.println(arr[x]);
					}else {
						System.out.print(arr[x]+", ");
					}
				}
			}
			10, 20, 30

B:获取最值
			最大值
			public static int getMax(int[] arr) {
				int max = arr[0];
				for(int x=1; x<arr.length; x++) {
					if(arr[x] > max) {
						max = arr[x];
					}
				}
				return max;
			}
			最小值
			public static int getMin(int[] arr) {
				int min = arr[0];
				for(int x=1; x<arr.length; x++) {
					if(arr[x] < min) {
						min = arr[x];
					}
				}
				return min;
			}
		C:倒序
			//方式1
			public static void change(int[] arr) {
				for(int start=0,end=arr.length-1; start<=end; start++,end--) {
					int temp = arr[start];
					arr[start] = arr[end];
					arr[end] = temp;
				}
			}
			//方式2
			public static void change(int[] arr) {
				for(int x=0; x<arr.length/2; x++) {
					int temp = arr[x];
					arr[x] = arr[arr.length-1-x];
					arr[arr.length-1-x] = temp;
				}
			}

D:查表法
			根据给定的数据，输出对应的星期。
			String[] strArray = {"星期一","星期二",...};
			Scanner sc = new Scanner(System.in);
			int week = sc.nextInt();
			System.out.println(strArray[week-1]);
		E:普通查找
			//方式1
			public static int getIndex(int[] arr,int value) {
				for(int x=0; x<arr.length; x++) {
					if(arr[x] == value) {
						return x;
					}
				}
				return -1;
			}
			//方式2
			public static int getIndex(int[] arr,int value) {
				int index = - 1;
					
				for(int x=0; x<arr.length; x++) {
					if(arr[x] == value) {
						index = x;
						break;
					}
				}
				return index;
			}