Java程序设计

最新推荐文章于 2023-09-15 21:21:52 发布
最新推荐文章于 2023-09-15 21:21:52 发布
阅读量1.1w 收藏 236
点赞数 34
分类专栏： 笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35629971/article/details/114240366
版权

JAVA程序设计

第一章：从0开始学习java

java是一种可以编写跨平台应用程序的面向对象程序设计语言。
本章我们要学习的内容有：

1.了解java语言的发展和运行机制

在正式学习java并安装配置开发环境之前，有必要了解一些有关Java的专业术语：
JDK（Java Development Kit ）：编写Java程序的程序员使用的软件
JRE（Java Runtime Environment）：运行Java程序的用户使用的软件
Server JRE （Java SE Runtime Environment）：服务端使用的 Java 运行环境
SDK（Software Development Kit）：软件开发工具包，在Java中用于描述1998年~2006年之间的JDK
DAO（Data Access Object）：数据访问接口，数据访问，顾名思义就是与数据库打交道
MVC（Model View Controller）：模型(model)－视图(view)－控制器(controller)的缩写，一种软件设计典范，用于组织代码用一种业务逻辑和数据显示分离的方法
JRE 与 Server JRE 区别, 以下是官网中的说明
Software Developers: JDK (Java SE Development Kit). For Java Developers. Includes a complete JRE plus tools for developing, debugging, and monitoring Java applications.
Administrators running applications on a server: Server JRE (Server Java Runtime Environment) For deploying Java applications on servers. Includes tools for JVM monitoring and tools commonly required for server applications, but does not include browser integration (the Java plug-in), auto-update, nor an installer.

首先要明确一下两个概念上的区别：JDK、SDK。
SDK——soft development kit，软件开发工具包。sdk是一个大的概念，比如开发安卓应用，你需要安卓开发工具包，叫 android sdk，比如你开发java程序，需要用到java sdk，所以一般使用sdk这个概念，你需要在前面加上限定词。
JDK——可以理解为 java sdk，它是编写java程序，使用到的工具包，为程序员提供一些已经封装好的 java 类库。

java语言比较特殊，其编写的程序需要经过编译步骤，但这个编译步骤不会产生特定平台的机器码，而是生成一种与平台无关的字节码（.class文件），这种字节码不是可执行的，要在java虚拟机中通过解释。JVM是java程序跨平台的关键，只要为不同的平台实现相应的虚拟机，编译后的java字节码就可以在该平台上运行。

java虚拟机执行字节码的过程由一个循环组成，它不停地加载程序，进行合法性和安全性检测，以及解释执行，直到系统执行完毕。（包括异常退出）。
在这里插入图片描述

2.搭建java开发环境
一个电脑上搭建java的环境

先下载JDK

首先我们需要下载java开发工具包JDK,我这里选择8下载.
下载链接：link

这里测试下jde——创建一个helloworld程序
从txt记事本中编写代码——改变后缀名为.java
在这里插入图片描述

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

打开cmd ______这里我存放代码的地方是D:\chapter1
依次输入 d: (打开D盘）
cd chapter1 (打开D:\chapter1文件夹）
输入命令 javac HelloWorld.java
如果没有其它信息出现，则代表没有错误
代码存放的地方出现.class文件
在这里插入图片描述
在这里插入图片描述
2.解释执行程序
在cmd输入
依次输入 d: (打开D盘）
cd chapter1 (打开D:\chapter1文件夹）
java HelloWorld
在这里插入图片描述

下载安装Eclipse

安装教程：link

验证下成功没，接下来创建一个hello world程序
1.打开java透视图
在这里插入图片描述
在这里插入图片描述
新建java项目
在这里插入图片描述
创建新的class
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
接下来
进行调试和运行
在这里插入图片描述
·在这里插入图片描述

调试程序
还有断点设置
下面是一段简单的代码：

public class HelloWorld {
    public static void main(String[] args) {
    	int sum=0;
    	for(int i=1;i<=5;i++) {
    		sum=sum+i;
    	}
        System.out.println(sum);
    }
}

在这里插入图片描述
设置断点
在这里插入图片描述
进行调试，进入调试界面
可以按ctrl+f6进行逐步调试
注意此时
sum值的变化

第二章 java的基本语法详解

本章我们要学习的内容有：
本章将对java语言的标识符、数据类型、变量、常量、运算符、表达式、控制语句和数组等基础知识进行学习。

本章学习目标：

  • 理解标识符
  • 熟悉java的基本数据结构
  • 掌握运算符
  • 熟练掌握各种流程控制语句
  • 了解注释结构

2.1标识符和关键字

2.1.1标识符

简单理解为名字
JAVA语言规定标识符由任意顺序的字母、下划线_ 、 美元符号 $ 、和数字组成
并且第一个字符不能是数字；

下面这些是非法的标识符
3max(数字首位）
room#（没有#这个）
class （class为关键字）

注意：

1. 标识符不能是关键字
2. java是严格区分大小写的
3. java语言中的字母不仅包通常的拉丁文字a、b、c \ 等还包含中文，日语以及其他国家的语言

2.1.2关键字

关键字是特定的一些单词，其对java编译器有着特殊的含义。JAVA的关键字可以分为5种

  1. 类类型（Class Type)

package, class, abstract, interface, implements, native, this, super, extends, new, import, instanceof, public, private, protected

  1. 数据类型（Data Type)

char, double, enum, float, int, long, short, boolean, void, byte

  1. 控制类型（Control Type）

break, case, continue, default, do, else, for, goto, if, return, switch, while, throw, throws,try, catch, synchronized, final, finally, transient, strictfp

  1. 储存类型（Storage Type)

register , static

  1. 其他类型（Other Type)

const , volatile

注意：
1. 所有的关键字都是由小写字母组成的
2. java语言中无sizeof关键字，因为java语言的数据类型长度和表示都是固定的
3. goto与const在java语言中没有含义

2.2基本数据类型

在这里插入图片描述

2.2.1 整数类型

整数类型用来储存整数数值，即没有小数部分的数值，可以是正数，也可以是负数。可以用十进制，八进制，十六进制表示
根据内存的大小不同，可分为byte，short，int，long共四种类型。

在这里插入图片描述
例子：定义int型变量，实例代码如下：

int x；   //定义int型变量x
int x，y=100； //定义int型变量x，y
int x=450，y=-462 //定义int型变量x，y赋给初值

定义上述变量时，要注意变量的取值范围。
对于long型值，若赋给的值大于int的最大值或者小于int的最小值，则需要在数字后加L或l，表示为长整数，
如long num=3117112897L

2.2.2 浮点类型

浮点类型表示有小数部分的数字。分为单精度浮点类型float和双精度浮点类型double，他们具有不同的取值范围。
在这里插入图片描述

在默认情况下，小数都被看作double，若使用float型小数，则需要在小数后面添加F或f。
可以使用后缀d或D来明确表示这是一个double类型数据，不加d不会出错，但声明float不加f，系统会认为变量是double类型而出错。

例子：

float x=100.23f；
double y1=32.12f；
double y2=123.45f；

2.2.3 字符类型

字符类型（char）用于储存单个字符，占用16位（二个字节）的内存空间。在定义字符型变量时，要以单引号表示，'s’表示一个字符，如“s"则表示一个字符串。


char c1='a';

同C与C++一样，Java也可以把字符作为整数对待。由于字符a在Unicode表中的排序位置是97，


char c1=97;

有些字符（如回车键）不能通过键盘录入字符串内，针对这种情况，Java提供了转义字符，以反斜杠\开头，将其后的字符转变成另外的含义。
例如：‘\n’（换行）, ‘\b’ （退格） ,’\t’（水平制表符）

注意：用双引号引用的文字，就是我们平时所说的字符串，它不是原始类型，而是一个·类（class）String，它被用来表示字符序列。

2.2.4 布尔类型

又称逻辑类型，通过关键字boolean来定义，只有true和false二个值，分别代表布尔逻辑中的”真“和”假“。布尔类型通常被用于在流程控制中作为判断条件。

例子：
boolean b1; //定义布尔型变量b1
boolean b2=true; //定义布尔型变量b2,并赋给初值true

注意：在java语言中，布尔值不能与整数类型进行转换，而C和C++允许.

2.3常量和变量

在程序运行过程中，其值不能被改变的量称为常量，值能被改变的称为变量。变量和常量的命名都必须使用合法的标识符。

2.3.1 常量

在程序中值一直不会变的量称为常量，常量在一个程序中只能被赋值一次。

在Java中声明一个常量除了要指定数据类型外，还需要通过final关键字进行限定，声明的语法如下：

final datatype CONSTNAME=VALUE

其中final是关键字，表示的定义的为常量，datatype 为数据类型，CONSTNAME为常量的明称，VALUE为常量的值

例子：

final double Pi=3.1415926; //声明double型的常量Pi

final boolean FLAG=true;   //声明boolean型的常量FLAG并赋值 boolean是布尔类型

注意：常量名通常使用大写字母，但并不是必需的，只是很多Java程序员已经习惯使用大写字母来表示常量，通过这种方式区别变量

2.3.2 变量

在Java中，使用变量之前需要先声明变量。变量声明通常包括3部分：变量类型、变量名和初始值，其中变量的初始值是可选的。

语法如下：

type identifier [=value][,identifier[=value] ···];

其中type是Java中的基本数据类型，或者类、接口复杂类型的名称，identifier是变量的名称，=value表示用具体的值对变量进行初始化，即把某个值赋给变量。

例子：

int age;  //声明int型变量
double d1=12.27;   //声明double型变量并赋值

2.3.3 变量作用域

变量的作用域是指程序代码能够访问该变量的区域，若超出该区域则在编译时会出现错误。

根据作用域的不同，可将变量分为以下几种：

1. 类成员变量
类成员变量在类中声明，它不属于任何一个方法，其作用域为整个类。
例子：

class ClasssVar{
int x=45;
int y;
}

在上述代码中，定义的二个变量x,y 均是类成员变量，其中第一个进行了初始化，而第二个没有进行初始化。

2.局部变量

在类的成员方法中定义的变量（在方法内部定义的变量）称为局部变量。局部变量只是在当前代码块中有效。
例子：

class LocalVart{
public static void main (String []args){
int x=45; //局部变量，作用域为整个main（）
if（x>5){
int y=0;    //局部变量，作用域为if语句块
System.out.printin(y);
}
System.out.printin(x);
}
}

在上述代码中，定义的两个变量均是局部变量，其中x的作用域是整个main()，而y的作用域仅仅局限于if语句块。

3.方法参数变量

声明为方法参数的变量的作用域是整个方法。

例子：

class FunctionParaVar{
  public static int getSum(int x){
  x=x+1;
  return x;
  }
  }

在上述代码中，定义了一个成员方法（getsum）（函数），方法中包含一个int类型的参数变量x，其作用域是整个getSum()方法。

4.异常处理参数变量
异常处理参数变量的作用域在异常处理代码块中，该变量是将异常处理参数传递给异常处理代码块，与方法参数变量的用法类似。
例子：

public class ExceptionParVar{
  public static void main(String []args){
  try{
			System.out.printin("exception");
			}
			catch(Exception e){//异常处理参数变量，作用域是异常处理代码块
			e.printStackTrace();
			}
  }}

在上述代码中，定义了一个异常处理代码块catch，其参数为Exception类型的变量e，作用域是整个catch代码块。

2.4 运算符

计算机的最基本用途之一就是执行数学运算，作为一门计算机语言，Java也提供了一套丰富的运算符来操纵变量。我们可以把运算符分成以下几组：

  • 算术运算符
  • 关系运算符
  • 位运算符
  • 逻辑运算符
  • 赋值运算符
  • 其他运算符

2.4.1赋值运算符

以“=”表示。它是一个二元运算符（对两个操作数作处理），其功能是将右边的赋给左方的操作数。例如：

int a=100;

2.4.2 算数运算符

算术运算符用在数学表达式中，它们的作用和在数学中的作用一样。

下表列出了所有的算术运算符。表格中的实例假设整数变量A的值为10，变量B的值为20：
在这里插入图片描述
下面的简单示例程序演示了算术运算符。复制并粘贴下面的 Java 程序并保存为 Test.java 文件，然后编译并运行这个程序：

public class Test {
 
  public static void main(String[] args) {
     int a = 10;
     int b = 20;
     int c = 25;
     int d = 25;
     System.out.println("a + b = " + (a + b) );
     System.out.println("a - b = " + (a - b) );
     System.out.println("a * b = " + (a * b) );
     System.out.println("b / a = " + (b / a) );
     System.out.println("b % a = " + (b % a) );
     System.out.println("c % a = " + (c % a) );
     System.out.println("a++   = " +  (a++) );
     System.out.println("a--   = " +  (a--) );
     // 查看  d++ 与 ++d 的不同
     System.out.println("d++   = " +  (d++) );
     System.out.println("++d   = " +  (++d) );
  }
}

以上实例编译运行结果如下：
a + b = 30
a - b = -10
a * b = 200
b / a = 2
b % a = 0
c % a = 5
a++ = 10
a-- = 11
d++ = 25
++d = 27

算数运算符优先级：
在这里插入图片描述

顺序运算符规则
高（）如果有多重括号，首先计算最里面的子表达式的值。若同一级有多对括号，则计算时从左至右
++，- -变量自增，变量自减
*,/,%若同时出现，计算时从左至右
低+，-若同时出现，计算时从左至右

关于++和- -运算符
就是自增和自减运算符。这两个运算符分为前缀式和后缀式。放在变量前面的++和- -,会先将变量的加1或者减1，然后再使此变量参与其他运算。放在变量后面的++和- - ，会先进行下面的其他运算，再将该变量加1或减1；

例子：

public class AutoInc {
	public static void main(String[] args) { 
		int i = 1; 
		int j = 1;
		System.out.println("i后缀递增的值= " + (i++)); //后缀递增
		System.out.println("j前缀递增的值= " + (++j)); //前缀递增
		System.out.println("最终i的值 =" + i);  
		System.out.println("最终j的值 =" + j); 
   }
}

i后缀递增的值= 1
j前缀递增的值= 2
最终i的值 =2
最终j的值 =2

2.4.3 关系运算符

关系运算符实际上就是“比较运算”，将二个值进行比较，判断比较的结果是否符合条件，如果符合，则表达式的结果为true，否则为false。

下表为Java支持的关系运算符

表格中的实例整数变量A的值为10，变量B的值为20：

运算符描述例子
==检查如果两个操作数的值是否相等，如果相等则条件为真。（A == B）为假。
!=检查如果两个操作数的值是否相等，如果值不相等则条件为真。(A != B) 为真。
>检查左操作数的值是否大于右操作数的值，如果是那么条件为真。（A> B）为假。
<检查左操作数的值是否小于右操作数的值，如果是那么条件为真。（A <B）为真。
>=检查左操作数的值是否大于或等于右操作数的值，如果是那么条件为真。（A> = B）为假。
<=检查左操作数的值是否小于或等于右操作数的值，如果是那么条件为真。（A <= B）为真。

实例

下面的简单示例程序演示了关系运算符。复制并粘贴下面的Java程序并保存为Test.java文件，然后编译并运行这个程序：

Test.java 文件代码：

public class Test {
 
  public static void main(String[] args) {
     int a = 10;
     int b = 20;
     System.out.println("a == b = " + (a == b) );
     System.out.println("a != b = " + (a != b) );
     System.out.println("a > b = " + (a > b) );
     System.out.println("a < b = " + (a < b) );
     System.out.println("b >= a = " + (b >= a) );
     System.out.println("b <= a = " + (b <= a) );
  }
}
以上实例编译运行结果如下：

a == b = false
a != b = true
a > b = false
a < b = true
b >= a = true
b <= a = false

2.4.4 逻辑运算符

有三种，分别是&&（逻辑与）、||（逻辑或）、！（逻辑非）、其中前两个是双目运算符，第三个是单目运算符。

下表列出了逻辑运算符的基本运算，假设布尔变量A为真，变量B为假

在这里插入图片描述

实例

下面的简单示例程序演示了逻辑运算符。复制并粘贴下面的Java程序并保存为Test.java文件，然后编译并运行这个程序：

public class Test {
  public static void main(String[] args) {
     boolean a = true;
     boolean b = false;
     System.out.println("a && b = " + (a&&b));
     System.out.println("a || b = " + (a||b) );
     System.out.println("!(a && b) = " + !(a && b));
  }
}
以上实例编译运行结果如下：

a && b = false
a || b = true
!(a && b) = true

2.4.5 位运算符

用来对二进制的位进行操作，其操作数的类型是整数类型以及字符型，运算结果是整数数据。

假设a = 60，b = 13;它们的二进制格式表示将如下：
A = 0011 1100
B = 0000 1101

A&B = 0000 1100
A | B = 0011 1101
A ^ B = 0011 0001
~A= 1100 0011

下表列出了位运算符的基本运算，假设整数变量 A 的值为 60 和变量 B 的值为 13：
A=60=00111100
B=13=00001101

操作符描述例子
＆如果相对应位都是1，则结果为1，否则为0（A＆B），得到12，即0000 1100
|如果相对应位都是 0，则结果为 0，否则为 1（A|B） 得到61，即 0011 1101
^如果相对应位值相同，则结果为0，否则为1（A ^ B）得到49，即 0011 0001
〜按位取反运算符翻转操作数的每一位，即0变成1，1变成0。（〜A）得到-61，即1100 0011
<<按位左移运算符。左操作数按位左移右操作数指定的位数。高位移除舍弃，低位的空位补0A << 2得到240，即 1111 0000
>>按位右移运算符。左操作数按位右移右操作数指定的位数。低位移除舍弃，高位补符号位（正数补0，负数补1）A >> 2得到15即 1111
>>>按位右移补零操作符。左操作数的值按右操作数指定的位数右移。低位移除舍弃，高位补0A>>>2得到15即0000 1111

实例

下面的简单示例程序演示了位运算符。复制并粘贴下面的Java程序并保存为Test.java文件，然后编译并运行这个程序：

Test.java 文件代码：

public class Test {
  public static void main(String[] args) {
     int a = 60; /* 60 = 0011 1100 */ 
     int b = 13; /* 13 = 0000 1101 */
     int c = 0;
     c = a & b;       /* 12 = 0000 1100 */
     System.out.println("a & b = " + c );
 
     c = a | b;       /* 61 = 0011 1101 */
     System.out.println("a | b = " + c );
 
     c = a ^ b;       /* 49 = 0011 0001 */
     System.out.println("a ^ b = " + c );
 
     c = ~a;          /*-61 = 1100 0011 */
     System.out.println("~a = " + c );
 
     c = a << 2;     /* 240 = 1111 0000 */
     System.out.println("a << 2 = " + c );
 
     c = a >> 2;     /* 15 = 1111 */
     System.out.println("a >> 2  = " + c );
  
     c = a >>> 2;     /* 15 = 0000 1111 */
     System.out.println("a >>> 2 = " + c );
  }
}

以上实例编译运行结果如下：
a & b = 12
a | b = 61
a ^ b = 49
~a = -61
a << 2 = 240
a >> 2 = 15
a >>> 2 = 15

2.4.6 条件运算符（?:）

条件运算符也被称为三元运算符。该运算符有3个操作数，并且需要判断布尔表达式的值。该运算符的主要是决定哪个值应该赋值给变量。

<布尔表达式>?value1:value2

如果布尔运算的结果为true，就返回value1的值；如果为false，则返回value2的值。
使用条件运算符的实例如下：

public class Test {
   public static void main(String[] args){
      int a , b;
      a = 10;
      b = (a == 1) ? 20 : 30;// 如果 a 等于 1 成立，则设置 b 为 20，否则为 30
      System.out.println( "Value of b is : " +  b );
 
      
      b = (a == 10) ? 20 : 30;// 如果 a 等于 10 成立，则设置 b 为 20，否则为 30
      System.out.println( "Value of b is : " + b );
   }
}

以上实例编译运行结果如下：
Value of b is : 30
Value of b is : 20

2.4.7 运算符的优先性与结合性

结合性是指对于同优先级的符号，按结合性决定他们是从左到右计算还是从右到左计算。
绝大部分的运算符都是从左向右计算的，只有
赋值运算符（如“=”，“+=”等）、
一元运算符（如“++” ！- -）
和三元运算符（即条件运算符?:）是从右向左的。

如果不清楚时候，加括号来保证计算顺序。

2.5 数据类型转换

两种方式：隐式类型转换（自动转换）和显式类型转换（强制转换）

隐式类型转换（自动转换）—————
从低级类型到高级类型的转换，系统将自动执行。

byte<short<int<long<float<double

实例：代码如下：

int a=3;
double b=a;

此时如果输出b的值，结果为3.0

整形、浮点、字符型数据可以混合运算。不同类型的数据先转换为同一类型，在进行计算。

显式类型转换

当把高级的变为低级的，必须使用显式类型转换

语法规则：

(type) variableName;

实例：

int a=3;
double b=5.0;
a=(int)b;

此时输出a的值，结果就是5.

2.6 流程控制语句

2.6.1 分支语句

分为if和if-else语句

  1. if语句

语句格式为：

if(条件表达式){
语句块
}

实例：
通过键盘输入一个整数，判断该整数是否大于18

 import java.until.Scanner.      //导入包 
  public class IFTest{
  public static void main(String[] Argus){
  System.out.printin(“请输入你的年龄：”);
  Scanner sc=new Scanner(System.in);
  int age=sc.nextlnt(); //接受键盘输入的数据
   if(age>=18){
  System.out.println(“你已经是成年人了！”);
  }
  }
  }

2.if-else语句
语法：

if(条件表达式){
语句块1;
}else {
语句块2;
}

实例：

package ch3;
import java.util.Scanner;  //导入包
public class IfElseTest {
	public static void main(String[] args){
		System.out.println("请输入你的年龄：");
		Scanner sc = new Scanner(System.in); 
		int age = sc.nextInt();  //接收键盘输入的数据
		if (age>=18){
			System.out.println("成年人");
		}else{
			System.out.println("未成年人");
		}
	}
}

3. if-else嵌套语句

语法：

if(条件表达式1){
if(条件表达式2){
语句块1；
}else{
语句块2；
}else{
. If(条件表达式3){
语句块3；
}else{
语句块4；
}
}

实例：

通过键盘输入两个整数，比较他们的大小：

package ch3;
import java.util.Scanner;  //导入包
public class IfElseNestTest {
	public static void main(String[] args){
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入x1:");
		int x1 = sc.nextInt();
		System.out.println("请输入x2:");
		int x2 = sc.nextInt();
		 if(x1>x2){
             System.out.println("结果是:" + "x1 > x2");
         }else{
            if(x1<x2){
               System.out.println("结果是:" + "x1 < x2");
            }else{
               System.out.println("结果是：" + "x1 = x2");
            }
          }
	}
}

4.switch语句
多分支
语法：

switch (表达式){
case 值1:
语句块1；
break；
case 值2：
语句块2；
break；
…
default ：
语句块n+1；
}

使用switch语句时候，注意：

1. switch后面括号中表达式必须为整形（byte short int）或字符型（char）类型的常量表达式，而不能用浮点型或long类型，也不能为一个字符串。
2. default子句是可选的
3. break语句在执行完一个case分支后，使程序跳出switch语句，即终止switch语句的执行。但在特殊情况下，多个不同的case值要执行一组相同的操作，此时同一组中前面的case分支可以去掉break语句。
4. 一个switch语句可以代替多个if—else语句组成的分支语句，且switch语句从思路上显得更清晰。

例子：

package ch3;

public class SwitchTest {
	public static void main(String[] args){
		   int x=6;
	       int y=9;
		   char op='+'; //运算符
	       switch(op){
	        //根据运算符，执行相应的运算
			case '+':    //输出x+y
				System.out.println("x+y="+ (x+y));
				break;
			case '-':    //输出x-y
				System.out.println("x-y="+ (x-y));
				break;
			case '*':    //输出x*y
				System.out.println("x*y="+ (x*y));
				break;
			case '/':    //输出x /y
				System.out.println("x/y="+ (x/y));
				break;
			default:
				System.out.println("输入的运算符不合适！");				
			}
		}
}

2.6.2 循环语句

Java 循环结构 - for, while 及 do…while

1.while 循环

while是最基本的循环，它的结构为：

while( 布尔表达式 )
{
//循环内容
}
只要布尔表达式为 true，循环就会一直执行下去。

例子：利用while计算1-100的整数之和

package ch3;

public class WhileTest {
	public static void main(String[] args){
	    int sum=0;
	    int i=1;
	    //如果 i<=100，则执行循环体，否则结束循环
		while(i<=100){  
			sum = sum + i;
			//改变循环变量的值，防止死循环
			i = i +1;  
		}
		System.out.println("sum = " + sum);
	}
}

2.do while 语句

对于 while 语句而言，如果不满足条件，则不能进入循环。但有时候我们需要即使不满足条件，也至少执行一次。

do…while 循环和 while 循环相似，不同的是，do…while 循环至少会执行一次。

do {
//代码语句
}
while(布尔表达式);

注意：布尔表达式在循环体的后面，所以语句块在检测布尔表达式之前已经执行了。 如果布尔表达式的值为 true，则语句块一直执行，直到布尔表达式的值为 false。

例子:利用do-while语句计算5的阶乘，并输出计算结果

package ch3;

public class DoWhileTest {
	public static void main(String[] args){
	    int result=1;
	    int i=1;
	    do{  
			result = result * i;
			//改变循环变量的值，防止死循环
			i = i +1;  
		} while(i<=5) ;
		System.out.println("result = " + result);
	}
}

3. for语句

虽然所有循环结构都可以用 while 或者 do…while表示，但 Java 提供了另一种语句 —— for 循环，使一些循环结构变得更加简单。

for循环执行的次数是在执行前就确定的。语法格式如下：

for(初始化; 布尔表达式; 更新) {
//代码语句
}

for 语句的3个表达式之间用；分开，他们的具体含义如下。

  1. 表达式1：初始化表达式，通常用于给循环变量赋初值。
  2. 表达式2：条件表达式，它是一个布尔表达式，只有值为true时候才会继续执行for语句中的语句块
  3. 表达式3：更新表达式，用于改变循环变量的值，避免死循环。

例子：利用for循环计算1-100之间能被3整除的数之和，并输出计算结果

package ch3;

public class ForTest {
	public static void main(String[] args){
	    int sum=0;
	    int i=1;       
	    for(i=1;i<=100;i++)	{
          if (i%3==0){ //判断 i 能否整除3
			  sum = sum + i;  
          }
		}
	    //打印计算结果
		System.out.println("sum = " + sum);  
	}
}

Java 增强 for 循环

Java5 引入了一种主要用于数组的增强型 for 循环。

Java 增强 for 循环语法格式如下:

for(声明语句 : 表达式)
{
//代码句子
}

声明语句：声明新的局部变量，该变量的类型必须和数组元素的类型匹配。其作用域限定在循环语句块，其值与此时数组元素的值相等。

表达式：表达式是要访问的数组名，或者是返回值为数组的方法。

实例

public class Test {
   public static void main(String args[]){
      int [] numbers = {10, 20, 30, 40, 50};
 
      for(int x : numbers ){
         System.out.print( x );
         System.out.print(",");
      }
      System.out.print("\n");
      String [] names ={"James", "Larry", "Tom", "Lacy"};
      for( String name : names ) {
         System.out.print( name );
         System.out.print(",");
      }
   }
}

以上实例编译运行结果如下：

10,20,30,40,50,
James,Larry,Tom,Lacy,

<增强for循环是JDK1.5以后出来的一个高级for循环，专门用来遍历数组和集合的。它的内部原理其实是个Iterator迭代器，所以在遍历的过程中，不能对集合中的元素进行增删操作。

2.6.3 跳转语句—break与continue语句

break 关键字

break 主要用在循环语句或者 switch 语句中，用来跳出整个语句块。

break 跳出最里层的循环，并且继续执行该循环下面的语句。

语法
break 的用法很简单，就是循环结构中的一条语句：

break;

例子：利用for循环语句计算1-100的整数之和，当和大于500时候，使用break跳出循环。

package ch3;

public class BreakTest {
	public static void main(String[] args){
		int sum=0;
	    for(int i=1;i<=100;i++){
          sum = sum + i;
          if(sum>500)   	  
             break;
		}
	    System.out.println("sum = " + sum);
	}
}

continue 关键字

continue 适用于任何循环控制结构中。作用是让程序立刻跳转到下一次循环的迭代。

在 for 循环中，continue 语句使程序立即跳转到更新语句。

在 while 或者 do…while 循环中，程序立即跳转到布尔表达式的判断语句。

语法
continue 就是循环体中一条简单的语句：

continue;

实例：输出1-10所有不能被3整除的自然数。

package ch3;

public class ContinueTest {
	public static void main(String[] args){
	    for(int i=1;i<=10;i++)
	    {
          if(i%3==0)
          {
        	  	continue; //结束本轮次循环
          }
          System.out.println("i = " + i);  
		}
	}
}

2.8数组

2.8.1 一维数组

在这里插入图片描述

、
在这里插入图片描述

在这里插入图片描述

例子：在数组中存放4位同学的成绩，计算这四位同学的总成绩和平均成绩。

package ch3;

public class Array1Test {
	public static void main(String[] args){
		double score[]={76.5,88.0,92.5,65};
		double sum =0;
	    for(int i=0;i<score.length;i++){
	    	sum = sum + score[i];  
		}
	    System.out.println("总 成 绩 为：" + sum);
	    System.out.println("平均成绩为：" + sum/score.length);
	}
}

注意：在java中，数组是一种引用类型，它拥有方法和属性，例如，length就是它的一个属性，利用该属性可以获得数组的长度。

2.8.2 多维数组

；；；

在这里插入图片描述

在这里插入图片描述

注意：以二维数组为例子，可用length()方法测定二维数组的长度，即元素的个数。只不过使用’数组名[i].length"得到的是该行的列数。
下面举例说明：

int [][] arr1={{3,-9},{8,0},{11,9}};

则arr1.length的返回值为3，表示数组arr1有三行。而arr[1].length的返回值为2，表示arr1[1]对应的行有2个元素（2列）

举例：声明一个二维数组，输出该数组中的各元素的值

package ch3;

public class Array2Test {
	public static void main(String[] args){
	    int i=0;
	    int j=0;
	    int ss[][] = {{1,2,3},{4,5,6},{7,8,9}};
	    for(i=0;i<ss.length;i++){
	      for (j=0;j<ss[i].length;j++){
	    	     System.out.print("ss["+i+"]["+j+"]="+ss[i][j]+" ");
	      }
	      System.out.println();
		}
	}
}

代码和课后习题代码地址：link

第三章 面向对象程序准备

3.1 面向对象程序设计的概述

面向对象的理解

1、什么是面向对象（ Object Oriented Programming，简称OOP）
面向对象是一种解决问题的思想，是一种看问题的角度。
其实编程就是把现实世界的语言，翻译成计算机能看懂的语言来执行的过程。
无论是面向对象，还面向过程（C语言），其实就是翻译的方式不同而已。

对比一下面向过程与面向对象：
在这里插入图片描述

例子：把大象放进冰箱里

面向过程——一步一步来
在这里插入图片描述

面向对象——把个体抽象出来——类class
在这里插入图片描述
冰箱放东西的操作抽象出来 ——放东西的方法（可以反复地重复地使用这个类）
在这里插入图片描述
再在主函数里调用这个类

在这里插入图片描述
这样做的好处就是减少了我们的代码量，让代码的复用性更强了！！

在这里插入图片描述

3.2 类与对象

类的定义

在实际编程过程中，我们应该把具有一类特征的事物抽象成一个类，每个具体的事物就是一个类的对象。
在这里插入图片描述

static修饰的属性可以通过：类名，属性名名称获取到属性的值

在这里插入图片描述
举个例子：
demo1:
在这里插入图片描述
demo2:
在这里插入图片描述

demo3:
在这里插入图片描述
因为是public，因此我在demo1中访问demo2和demo3
在这里插入图片描述
打印出来了，没报错，所以public时候类之间可以访问
如果修饰符是空白默认呢？

这时候把demo2，demo3的public删除
再运行发现报错

成员变量

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

类的对象

类和对象的关系
类(class) — 是对某一类事物的描述
对象(object) — 是实际存在的某类事物的个体，也称为实例(instance)
类是创建对象的模板，对象是类的实例。
在这里插入图片描述
创建对象的语法格式
在这里插入图片描述
例如：

Employee employee = new Employee ("1000001") //创建一个对象employee 他的初始值为1000001；

声明对象的目的就是使用它，对象的使用包括使用其成员变量和成员方法，运算符“.”可以实现对成员变量的访问和成员方法的使用。

成员变量和成员方法的使用

1.使用成员变量
一旦定义了成员变量，就能进行初始化和其他操作
在同一个类中使用成员变量
例：

class Camera{
int numOfPhotos; //照片数目
public void incrementPhotos()
{
numOfPhotos++; // 增加照片数目，调用成员变量numOfPhotos
}
}

从另一个类中使用成员变量。通过创建且类的对象，然后使用.操作符指向该变量
例：

class Robot{
 Cmera camera = new Camera(); //从上一个类camera中创建一个对象
 public void takePhotos()
 {
 camera.numOfPhotos++; //使用camera对象的成员变量numOfPhotos
 }
 }

2.调用成员方法
调用成员方法必须在方法名后跟括号和分号，如Camera类的一个对象camera使用自己的方法计算照片的数目。

camera. incrementPhotos();//调用camera对象的成员函数

调用同类的成员函数
例：

class Camera
{
int numOfPhotos; //照片数目
public void incrementPhotos()
{
numOfPhotos++; // 增加照片数目，调用成员变量numOfPhotos
}
public void clickButton(){
incrementPhotos(); //调用同类的成员函数incrementPhotos()
}
}

调用不同类的成员函数。通过创建类的对象，然后用.操作符指向该函数，例：

class Robot{
 Cmera camera = new Camera(); //从上一个类camera中创建一个对象
 public void takePhotos()
 {
 camera.clickButton();//使用camera对象的成员函数clickButton()
 }
 }

方法中的参数传递

1.传值调用
java中所有原始数据类型的参数是传值的，这意味着参数的原始值不能被调用的方法改变。
例：

class SimpleValue{
		    public static void main(String [] args)	{
			    int x = 5;
		        System.out.println("方法调用前 x = "   +  x);
            change(x);
		        System.out.println("change方法调用后 x = "   +  x);		
}
		    public static void change(int x){
			    x = 4;
		    }
	    }

运行的结果
在这里插入图片描述
程序分析：
调用change方法后不会改变main()方法中传递过来的变量x的值，因此最后的输出结果仍然为5。
由此可见，在传值调用里，参数值的一份副本传给了被调用方法，把它放在一个独立的内存单元。
因此，当被调用的方法改变参数的值时，不会反映到调用方法
在这里插入图片描述
2.引用调用
对象的引用变量并不是对象本身，它们只是对象的句柄。就好像一个人可以有多个名称，一个对象可以有多个句柄
例：

package text;

class ReferenceValue{
    int x ;
    public static void main(String [] args)	{
	    ReferenceValue obj = new ReferenceValue();
	    obj.x = 5;
    System.out.println("chang方法调用前的x =  "   + obj.x);
	    change(obj);
	    System.out.println("chang方法调用后的x =  "   + obj.x);
    }
    public static void change(ReferenceValue obj){
	     obj.x=4;
    }
}

运行结果
在这里插入图片描述
程序分析：
在main（）方法中首先生成obj对象，并将其成员变量x赋值为5，接下来调用类内定义的方法change。
在调用change方法时把main（）方法的obj的值赋给change中的obj，使其指向同一内容
change方法结束，change中的obj变量被释放，但堆内存的对象仍然被main()方法中的obj引用，所以在main()方法中的obj所引用的对象的内容被改变。

注意: java中基本类型数据传递是传值调用，对象的参数传递是引用调用！！！

下面程序演示了一个类对象的创建及使用方式

import java.io.*;

class Employee { // 定义父类: 职员类
	 String employeeName; // 职员姓名
	int employeeNo; // 职员的编号
	double employeeSalary; // 职员的薪水

	public void setEmployeeName(String name) {// 设置职员的姓名
		employeeName = name;
	}

	public void setEmployeeNo(int no) {// 设置职员的编号
		employeeNo = no;
	}

	public void setEmployeeSalary(double salary) { // 设置职员的薪水
		employeeSalary = salary;
	}

	public String getEmployeeName() { // 获取职员姓名
		return employeeName;
	}

	public int getEmployeeNo() { // 获取职员的编号
		return employeeNo;
	}

	public double getEmployeeSalary() { // 获取职员工资
		return employeeSalary;
	}

	public String toString() { // 输出员工的基本信息
		String s;
		s = "编号: " + employeeNo + "  姓名： " + employeeName + "  工资： " + employeeSalary;
		return s;
	}
}

public class test_employee // 主程序，测试employee对象
{
	public static void main(String args[]) { // Employee的第一个对象employee1
		Employee employee1; // 声明Employee的对象employee，也称employee为引用变量
		employee1 = new Employee(); // 为对象employee分配内存
		// 调用类的成员函数为该对象赋值
		employee1.setEmployeeName("王一");
		employee1.setEmployeeNo(100001);
		employee1.setEmployeeSalary(2100);
		System.out.println(employee1.toString()); // 输出该对象的数值

		// Employee的第二个对象employee2，并为对象employee分配内存
		Employee employee2 = new Employee(); // 构建Employee类的第二个对象
		System.out.println(employee2.toString()); // 输出系统默认的成员变量初始值

		 // Employee的第三个对象employee3，并为对象employee分配内存
	    Employee employee3 = new Employee(); //构建Employee类的第二个对象
	    employee3.employeeName = "王华" + ""; // 直接给类的成员变量赋值
	    System.out.println(employee3.toString()); // 输出成员变量初始值

	}
}

运行结果
在这里插入图片描述
如果用私有的private
例如：
private string employeeName;
这样的话上面在test_employee类中就不能直接调用employeeName
可以用set和get得到 即obj.setEmployeeName…

public void setEmployeeName(String name) {// 设置职员的姓名
		employeeName = name;
	}

public String getEmployeeName() { // 获取职员姓名
		return employeeName;
	}

3.3 类的构造方法

当创建一个对象时，需要初始化类成员变量的数值。如何确保类的每一个对象都能获取类成员变量的初值？——

构造方法来实现。构造方法包括初始化类的成员变量的代码，当创建类的对象时，它自动执行。

构造方法的定义：
格式如下：

[访问说明符] 类名 [参数列表]
{
}

例如：

public Employee(String name){//带参数的构造方法
employeeName=name;
System.out.println("带有姓名参数的构造方法被调用！");
}

构造方法的规则如下：

  • 具有与类相同的名称
  • 不含返回值类型,不能定义为void，在方法名前面不声明方法类型
  • 不能在方法中用return语句返回一个值
  • 一般访问权限为public

java默认构造函数
如果没定义，系统会为这个类产生一个默认的构造函数，这个构造函数是空的

class Customer()
{}
class Customer{
public Customer(){}
}

在这里插入图片描述
在这里插入图片描述

第三个不可以,void不能在参数里，第四个不行，这样写不能够调用无参的构造函数，第五个如果要无参构造，不能有返回值。

对象数组（类似学生类）

如下，我们以学生类来进行举例学习一下

我先把类Student定义好

package text;

public class Student {
	//定义成员变量
	private int sNO; //表示学号
	private String sName; //表示姓名
	private String sSex; //性别
	private  int sAge; //年龄
	private int sJava; //表示java课程成绩
	
	
	//创建带参数的构造函数
	public Student(int sNO,String sName,String sSex,int sAge,int sJava)
	{
		this.sNO= sNO;
		this.sName=sName;
		this.sSex=sSex;
		this.sAge=sAge;
		this.sJava=sJava;
		
	}

//get函数
	public int getsNO() {
		return sNO;
	}


	public String getsName() {
		return sName;
	}


	public String getsSex() {
		return sSex;
	}


	public int getsAge() {
		return sAge;
	}


	public int getsJava() {
		return sJava;
	}
	
	//主函数
	

}

下面才是重点
在这里插入图片描述

package text;

public class Testmain {

	public static void main(String[] args) {
		int  arr[]= {1,2,3,4,56}; //基本数据类型组成的数组
		//还可以用对象来构造数组
		Student[] stuarr = new Student[5]; //定义了一个学生类型的数组
		//也就是说这个数组里面的每一个元素都是Student类的对象
		

	}

}

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
下面举个课本上的题目：
定义一个表示学生信息的类Student，要求如下：

（1）类Student的成员变量：

nO 表示学号；name表示姓名；sex表示性别；age表示年龄；java：表示Java课程成绩。

（2）类Student带参数的构造方法：

在构造方法中通过参数完成对成员变量的赋值操作。

（3）类Student的方法成员：

getNo（）： 获得学号； getName（）：获得姓名； getSex（）：获得性别； getAge（）获得年龄； getJava（）：获得Java 课程成绩

（4）根据类Student的定义，创建五个该类的对象，输出每个学生的信息，计算并输出这五个学生Java语言成绩的平均值，以及计算并输出他们Java语言成绩的最大值和最小值。

package text;

public class Student {
	//定义成员变量
	private int sNO; //表示学号
	private String sName; //表示姓名
	private String sSex; //性别
	private  int sAge; //年龄
	private int sJava; //表示java课程成绩
	
	
	//创建带参数的构造函数
	public Student(int sNO,String sName,String sSex,int sAge,int sJava)
	{
		this.sNO= sNO;
		this.sName=sName;
		this.sSex=sSex;
		this.sAge=sAge;
		this.sJava=sJava;
		
	}

//get函数
	public int getsNO() {
		return sNO;
	}


	public String getsName() {
		return sName;
	}


	public String getsSex() {
		return sSex;
	}


	public int getsAge() {
		return sAge;
	}


	public int getsJava() {
		return sJava;
	}
	
	




//计算成绩平均数
public  static double Javascoreaverage(Student stu[])
{
	int sum;
	sum=0;
	double average;
	int i;
	for(i=0;i<stu.length;i++)
	{
		sum=sum+stu[i].getsJava();
	}
	average=sum/stu.length;
	return average;
}

//求成绩最大值和最小值
public static void GetMaxMin(Student stu[])
{
	int i;
	int max,min;
	max=0;
	min=stu[0].getsJava();
	for(i=0;i<stu.length;i++)
	{
		if(stu[i].getsJava()>max)
		{
			max=stu[i].getsJava();
		}
		if(stu[i].getsJava()<min)
		{
			min=stu[i].getsJava();
		}
	}
	System.out.println("Java最大值为："+max);
	System.out.println("Java最小值为："+min);
}

//输出信息
public static void display(Student stu[])
{
	int i;
	for(i=0;i<stu.length;i++)
	{
		System.out.println("第"+(i+1)+"个：");
		System.out.println("学号:"+stu[i].getsNO()+" "+"姓名："+stu[i].getsName()+" "+"性别："+stu[i].getsSex()+" "+"年龄："+stu[i].getsAge()+" "+"Java成绩："+stu[i].getsJava());
	}
}

//主函数
public static void main(String [] args)
{
	Student stu[] = new Student[5]; //建立对象数组
	
	Student s1 = new Student(1,"chen","nan",20,90);
	Student s2 = new Student(2,"ren","nan",21,89);
	Student s3 = new Student(3,"xie","nan",22,82);
	Student s4 = new Student(4,"liu","nan",23,89);
	Student s5 = new Student(5,"zen","nv",20,98);
	
	stu[0]=s1;
	stu[1]=s2;
	stu[2]=s3;
	stu[3]=s4;
	stu[4]=s5;
	


	Student.display(stu);
	System.out.println("Java值的平均值为:"+Student.Javascoreaverage(stu));
	Student.GetMaxMin(stu);
	
	
}
}

截图：
在这里插入图片描述

我这里输出信息比较纯，以后想到更好的办法在改改,这里新建一个函数来做

3.7重载

在java中，允许同一个类中有二个或二个以上相同的名字的方法，只要它们的参数声明不同即可。——重载

3.7.1 方法重载

对方法重载——二个同名方法
如输出方法：
在这里插入图片描述

3.7.2 构造方法的重载

先看下面的例子：
在这里插入图片描述
在这里插入图片描述

3.8 static、final修饰符详解

static

static是静态修饰符，可以修饰类的属性，也可以修饰类的方法。被static修饰的属性不属于任何一个类的具体对象，是公共的储存单元。任何对象访问它时候，取得的都是相同的数值。
在这里插入图片描述

1.静态属性

class StaticTest{
static int i =47;
}

接下声明两个StaticTest对象，但他们同样拥有static.i的一个储存空间，既这两个对象共享同样的i；

StatocTest st1 =new StaticTest();
StatocTest st2 =new StaticTest();

此时st1.i 和st2.i所拥有相同的数值47，因为它们引用的是同样的内存区域。

静态成员变量static可以直接对象引用 st1.i ，也可以使用类引用，如·staticTest.i。而这在非静态成员变量是不行的；

  1. 静态代码块
Half-up
关注
  • 34
    点赞
  • 踩
  • 236
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
Java程序设计PPT.rar
08-04
初学者
JAVA语言程序设计基础入门技术教程
张晨光老师的播客
01-02 2731
class 类名{ //块定义的开始//一个类只能有一个静态的main方法{方法块定义的开始​ } //方法块定义的结束} //块定义的结束;当行注释： //多行注释： /*这个是注释 */文档注释：/** 注释 */静态特征：属性动态行为：方法[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-SjWHDvAz-1672666155084)(E:\政通路\课堂笔记\S2\J2SE Base\assets\1576549049804.png)]
《Java语言程序设计》
m0_46612024的博客
02-22 2141
《Java语言程序设计》
JAVA//JAVA基本程序设计架构
weixin_43918519的博客
04-26 1111
java applet是在网页中运行的java程序。 1. JAVA整形 JAVA的整形范围和运行的机器无关，这就导致JAVA可移植性较好。 长整型后加上L/l；十六进制有前缀0x或0X；八进制前缀为0； 从JAVA7开始，可在数值前面加上0b/0B表示二进制数；还可以为数字添加下划线，便于阅读，编译器会自动去掉这些下划线。 由上面展示的整型可以看出，JAVA没有无符号类型。 2. 浮点类型 默认情况下浮点数值被认为是double类型，可在后面加上后缀f/F注明他是float，也可以加上D/d注明他是
Java 语言程序设计（学习笔记超详细版）
m0_63216005的博客
09-15 703
JAVA 语言程序设计（学后笔记）
java程序设计
04-19
《Java程序设计:一种跨学科的方法》由计算机著名专家Robert Sedgewick编写。本书根据学习编程的四个阶段（基本元素、函数、面向对象程序设计、算法和数据结构）来组织。基本元素包括变量、赋值语句、数据的内置类型、控制流(条件和循环)、数组和输入输出、包括图和声音。函数包括库函数和递归函数，将程序划分成可以独立调试、维护和复用的程序段。然后介绍如何使用、创建和设计数据类型。最后介绍了经典的排序和搜索算法，同时也介绍了基本的数据结构（包括堆栈、队列和符号表)及它们的应用，强调了使用科学方法来理解实现的性能特性。本书示例丰富，涉及了Java在各种学科之中的应用，具有很高的参考价值。, 本书适用于高等院校计算机及相关专业的研究生和本科生，以及从事编程工作的专业人员。
JAVA语言程序设计
lssffy的博客
06-22 6389
计算机、程序和JAVA概述 一、计算机概述和编程语言 一）、Java语言的发展 60年代->提出对象与实例的概念，并引入了类。 1960年代由Simula 67语言引入面向对象的基本概念。Simula这一语言是Ole-Johan Dahl 和Kristen Nygaard在挪威奥斯陆计算机中心为模拟环境而设计的。 麻省理工PDP-1系统 1963年，Ivan Sutherland的Sketchpad应用 80年代：面向对象成为主导思想，事件处理式成为面向对象的内容 C++的广泛应用 适应了GU
Java程序设计基础
qq_41854911的博客
12-22 2526
文章目录Java标识符和关键字标识符关键字Java注释：单行、多行和文档注释1）单行注释2）多行注释3）文档注释Javadoc（文档注释）详解Javadoc标签Javadoc命令DOS命令生成API帮助文档MyEclipse生成API帮助文档文档注释的格式Java常量：Java常量的定义和分类常量值整型常量值实型常量值布尔型常量值字符型和字符串常量值定义常量Java变量的声明和初始化声明变量变量赋值Java变量的作用域：静态变量、全局变量和局部变量成员变量局部变量1）方法局部变量2）方法参数变量3）代码块局
Java实现简单程序设计
MrLuo8的博客
11-07 2225
桂 林 理 工 大 学 实 验 报 告 班级 软件工程18-2班 学号 3182052051219姓名 罗猛 同组实验者 无 实验名称 简单程序设计 日期 2020年 05 月27 日 一、实验目的： 1、熟悉Java应用程序编写、编译与运行流程。 2、熟悉Java程序基本结构，能够编写最简单的Java程序。 3、掌握一种Java的标准输入输出处理方法。 4、学会编写包含选择与循环结构的简单Java程序。 二、实验环境： Eclipse 三、实验内容： 1、编
JAVA程序设计教程
09-07
目录 引言 ...................................................................................................................................... I 第一章程序和程序设计 .......................................................................................................1 §1.1 什么是程序 ?............................................................................................................1 1.1.1 算法.................................................................................................................2 1.1.2 实体.................................................................................................................3 1.1.3 程序.................................................................................................................3 1.1.4 程序设计 .........................................................................................................4 §1.2 程序设计方法与语言 ..............................................................................................5 1.2.1 早期的程序设计 .............................................................................................5 1.2.2 结构化程序设计 .............................................................................................5 1.2.3 面向对象程序设计 .........................................................................................6 §1.3 一个完整的 Java程序.............................................................................................6 1.3.1 Java程序的结构 ..............................................................................................8 1.3.2 Java程序的退化结构 ......................................................................................9 1.3.3 Java程序的运行 ............................................................................................10 1.3.4 Java程序的调试 ............................................................................................11 §1.4 面向对象程序的构造 ............................................................................................11 内容小结.........................................................................................................................12 思考与练习.....................................................................................................................12 上机实习题.....................................................................................................................12 小课题：抽象与抽象层次.............................................................................................13 小课题：程序设计语言的历史.....................................................................................13 第二章基本数据类型 .........................................................................................................14 §2.1 数据类型概述 ........................................................................................................14 2.1.1 什么是类型？ ...............................................................................................14 2.1.2 类型的作用 ...................................................................................................14 2.1.3 Java语言的类型 ............................................................................................15 §2.2 程序中的单词 ........................................................................................................15 2.2.1 单词分类 .......................................................................................................15 2.2.2 保留字...........................................................................................................15 2.2.3 标识符...........................................................................................................16 2.2.4 程序中的空白 ...............................................................................................16 §2.3 变量与赋值 ............................................................................................................17 2.3.1 确定数据类型 ...............................................................................................17 2.3.2 变量的要素 ...................................................................................................17 2.3.3 赋值运算 .......................................................................................................18 2.3.4 程序的输出 ...................................................................................................18 §2.4 Java语言的简单类型 .............................................................................................18 2.4.1 字符类型 .......................................................................................................19 2.4.2 整数类型 .......................................................................................................19 2.4.3 浮点数类型和双精度浮点数类型 ...............................................................20 2.4.4 布尔类型 .......................................................................................................20 2.4.5 字符串类型 ...................................................................................................21 2.4.6 符号常量 .......................................................................................................21 §2.5 表达式....................................................................................................................22 - i - 2.5.1 表达式...........................................................................................................22 2.5.2 算术运算 .......................................................................................................22 2.5.3 关系运算 .......................................................................................................23 2.5.4 逻辑运算 .......................................................................................................23 2.5.5 类型转换 .......................................................................................................24 2.5.6 一个小小应用程序 .......................................................................................24 §2.6 编写简单应用程序 ................................................................................................25 2.6.1 最简单的程序 ...............................................................................................25 2.6.2 引入变量的程序 ...........................................................................................26 2.6.3 程序的输入 ...................................................................................................26 2.6.4 完整的程序 ...................................................................................................27 内容小结.........................................................................................................................28 思考与练习.....................................................................................................................28 上机实习题.....................................................................................................................29 小课题：构造性思维方法.............................................................................................29 第三章基本控制结构 .........................................................................................................30 §3.1 简单语句 ................................................................................................................30 §3.2 结构化控制结构 ....................................................................................................30 3.2.1 程序的控制结构 ...........................................................................................30 3.2.2 结构化程序设计工具 ...................................................................................31 3.2.3 盒图与伪码 ...................................................................................................31 §3.3 选择结构 ..............................................................................................................33 3.3.1 不带 else的 if语句 ......................................................................................33 3.3.2 带 else的 if语句 ..........................................................................................35 3.3.3 嵌套 if语句 ..................................................................................................36 3.3.4 垂悬 else问题 ..............................................................................................38 §3.4 循环结构 ..............................................................................................................39 3.4.1 while语句......................................................................................................39 3.4.2 break语句和 continue语句 ..........................................................................42 3.4.3 do_while语句................................................................................................44 3.4.4 for语句..........................................................................................................46 §3.5 原始算法与精美算法 ............................................................................................47 3.5.1 求解问题的精美算法 ...................................................................................47 3.5.2 求解问题的原始算法 ...................................................................................48 §3.6 一个应用程序例子 ................................................................................................48 内容小结.........................................................................................................................50 思考与练习.....................................................................................................................51 上机实习题.....................................................................................................................52 第四章方法.........................................................................................................................53 §4.1 例程机制 ................................................................................................................53 4.1.1 分而治之与软件重用 ...................................................................................53 4.1.2 Java语言的方法 ............................................................................................54 4.1.3 两个例子 .......................................................................................................54 §4.2 方法的声明与调用 ................................................................................................56 4.2.1 方法的声明 ...................................................................................................56 4.2.2 方法的调用 ...................................................................................................57 4.2.3 方法的接口与实现 .......................................................................................58 §4.3 方法的参数 ............................................................................................................59 4.3.1 参数设计 .......................................................................................................59 4.3.2 按值调用 .......................................................................................................61 §4.4 标识符的作用域 ....................................................................................................61 - ii - 4.4.1 作用域规则 ...................................................................................................62 4.4.2 标识符命名冲突 ...........................................................................................63 §4.5 使用 Java API ........................................................................................................63 4.5.1 数值运算 .......................................................................................................63 4.5.2 伪随机数 .......................................................................................................64 §4.6 递归程序设计 ........................................................................................................65 4.6.1 简单递归程序 ...............................................................................................65 4.6.2 梵塔问题 .......................................................................................................66 内容小结.........................................................................................................................67 思考与练习.....................................................................................................................68 上机实习题.....................................................................................................................69 小课题：计算机辅助教学.............................................................................................69 第五章类与对象 .................................................................................................................70 §5.1 声明一个类 ............................................................................................................70 5.1.1 类的声明 .......................................................................................................70 5.1.2 类成员的访问控制 .......................................................................................71 5.1.3 类作用域 .......................................................................................................72 §5.2 创建对象实例 ........................................................................................................73 5.2.1 对象的声明与使用 .......................................................................................73 5.2.2 对象的初始化 ...............................................................................................74 5.2.3 静态成员 .......................................................................................................76 5.2.4 对象的参数传递方式 ...................................................................................78 §5.3 变量和对象实例的生存期 ....................................................................................79 5.3.1变量的生存期 ................................................................................................80 5.3.2对象实例的生存期 ........................................................................................80 §5.4 字符串类 String.....................................................................................................82 5.4.1 使用 String类型的对象 ...............................................................................82 5.4.2 类 String的主要方法 ...................................................................................82 5.4.3 使用字符串对象的例子 ...............................................................................84 §5.5 关于类和对象的进一步讨论 ................................................................................86 5.5.1 基本数据类型的包装类 ...............................................................................86 5.5.2 抽象数据类型 ...............................................................................................87 5.5.3 设计良好的类接口 .......................................................................................88 5.5.4 再论对象 .......................................................................................................88 5.5.5 再论 Java语言的类......................................................................................89 内容小结.........................................................................................................................90 思考与练习.....................................................................................................................90 上机练习题.....................................................................................................................92 小课题：命令行交互方式.............................................................................................92 第六章复合数据类型 .........................................................................................................93 §6.1 使用数组变量 ........................................................................................................93 6.1.1 数组变量的声明 ...........................................................................................93 6.1.2 访问数组元素 ...............................................................................................94 6.1.3 数组作为参数传递 .......................................................................................95 §6.2 数组应用举例 ........................................................................................................96 6.2.1 学生成绩管理 ...............................................................................................96 6.2.2 完整的程序 ...................................................................................................96 6.2.3 冒泡排序法 ...................................................................................................99 §6.3 使用二维数组变量 ..............................................................................................100 6.3.1 什么是二维数组？ .....................................................................................100 6.3.2 使用二维数组 .............................................................................................101 - iii - 6.3.3 二维数组应用举例 .....................................................................................101 §6.4 一个扑克牌游戏程序 ..........................................................................................102 6.4.1 分析问题 .....................................................................................................102 6.4.2 建模.............................................................................................................103 6.4.3 完整的程序 .................................................................................................103 §6.5 高级数据结构的构造 ..........................................................................................106 §6.6 对象实例的复制与比较 ......................................................................................108 6.6.1 对象实例的复制 .........................................................................................108 6.6.2 对象实例的比较 .........................................................................................112 内容小结.......................................................................................................................113 思考与练习...................................................................................................................113 上机实习题...................................................................................................................115 第七章继承与多态 ...........................................................................................................116 §7.1 继承的基本概念 ..................................................................................................116 7.1.1 IS-A关系..................................................................................................116 7.1.2 继承机制 .....................................................................................................116 7.1.3 继承的作用 .................................................................................................117 7.1.4 继承与软件重用 .........................................................................................118 §7.2 Java语言的继承机制 ...........................................................................................118 7.2.1 继承的语法 .................................................................................................118 7.2.2 继承与成员访问控制 .................................................................................120 7.2.3 继承成员的调整 .........................................................................................121 7.2.4 子类对象实例的存储组织 .........................................................................122 7.2.5 继承与对象初始化及收尾 .........................................................................124 7.2.6 继承与子类型 .............................................................................................125 §7.3 多态性的基本概念 ..............................................................................................126 7.3.1 程序的多态性 .............................................................................................126 7.3.2 表示独立性 .................................................................................................127 §7.4 方法重载 ..............................................................................................................127 7.4.1 方法重载的途径 .........................................................................................128 7.4.2 方法重载的二义性 .....................................................................................130 7.4.3 构造方法的重载 .........................................................................................133 §7.5 动态绑定 ..............................................................................................................133 §7.6 对继承和多态的进一步讨论 ..............................................................................135 7.6.1 单继承与多继承 .........................................................................................135 7.6.2 最终类与抽象类 .........................................................................................136 7.6.3 类属机制 .....................................................................................................139 7.6.4 类层次设计 .................................................................................................140 内容小结.......................................................................................................................141 思考与练习...................................................................................................................142 上机实习题...................................................................................................................146 小课题：为 Java语言引入类属机制 ..........................................................................147 第八章接口与程序包 .......................................................................................................148 §8.1 接口......................................................................................................................148 8.1.1 接口的作用 .................................................................................................148 8.1.2 接口的声明 .................................................................................................149 8.1.3 接口与类 .....................................................................................................150 8.1.4 接口的继承 .................................................................................................154 8.1.5 接口与多态性 .............................................................................................155 §8.2 程序包..................................................................................................................157 8.2.1 Java程序的组织 ..........................................................................................157 - iv - 8.2.2 程序包的定义 .............................................................................................158 8.2.3 程序包的引入 .............................................................................................159 8.2.4 包级访问控制 .............................................................................................161 8.2.5 Java的系统程序包 ......................................................................................163 §8.3 嵌套类..................................................................................................................164 8.3.1 嵌套类的种类 .............................................................................................164 8.3.2 内部类.........................................................................................................165 8.3.3 回调机制 .....................................................................................................168 8.3.4 静态类.........................................................................................................171 内容小结.......................................................................................................................171 思考与练习...................................................................................................................172 上机实习题...................................................................................................................177 第九章异常处理与断言 ...................................................................................................178 §9.1 异常处理的基本概念 ..........................................................................................178 9.1.1 异常处理 .....................................................................................................178 9.1.2 异常处理的模式 .........................................................................................179 §9.2 Java语言的异常处理机制 ...................................................................................180 9.2.1 异常的分类 .................................................................................................180 9.2.2 Java标准异常简介 ......................................................................................181 9.2.3 异常的捕获与处理 .....................................................................................182 9.2.4 异常的匹配 .................................................................................................184 9.2.5 异常处理与收尾 .........................................................................................184 9.2.6 异常处理与构造方法 .................................................................................186 9.2.7 异常的转发 .................................................................................................187 9.2.8 异常声明与方法重载 .................................................................................188 9.2.9 异常处理与继承机制 .................................................................................188 §9.3 程序断言机制 ......................................................................................................191 9.3.1 程序断言 .....................................................................................................191 9.3.2 程序断言的用法 .........................................................................................192 9.3.3 在 Java语言中实现部分断言....................................................................193 内容小结.......................................................................................................................195 思考与练习...................................................................................................................195 上机实习题...................................................................................................................197 第十章输入／输出流 .......................................................................................................198 §10.1输入／输出基本概念 ........................................................................................198 10.1.1 外部设备与文件 .......................................................................................198 10.1.2 文件的基本概念 .......................................................................................198 10.1.3 输入／输出流 ...........................................................................................199 §10.2 Java流系统概述 .................................................................................................199 10.2.1 面向字节的输入流类 ...............................................................................200 10.2.2 面向字节的输出流类 ...............................................................................201 10.2.3 面向字符的输入流类 ...............................................................................203 10.2.4 面向字符的输出流类 ...............................................................................204 10.2.5 Java API定义的流对象 ............................................................................205 §10.3文件流................................................................................................................206 10.3.1 文件及文件目录的操作 ...........................................................................206 10.3.2 文件内容的顺序读写 ...............................................................................208 10.3.3 文件内容的随机读写 ...............................................................................209 §10.4过滤器流 ............................................................................................................210 10.4.1 装饰模式 ...................................................................................................210 10.4.2 数据转换流 ...............................................................................................211 - v - 10.4.3 带行号的输入流 .......................................................................................212 10.4.4 设计自己的过滤器流 ...............................................................................213 §10.5对象串行化 ........................................................................................................215 10.5.1 对象串行化的作用 ...................................................................................215 10.5.2 对象串行化的基本方法 ...........................................................................216 10.5.3 串行化自己的对象 ...................................................................................217 §10.6其它类型的流简介 ............................................................................................219 10.6.1 管道流 .......................................................................................................219 10.6.2 连接流 .......................................................................................................220 内容小结.......................................................................................................................221 思考与练习...................................................................................................................222 上机实习题...................................................................................................................222 小课题：设计词法分析程序.......................................................................................223 第十一章对象容器...........................................................................................................224 §11.1 对象容器的基本概念 ........................................................................................224 §11.2 Java对象容器概述 .............................................................................................225 11.2.1 Java对象容器接口及其骨架类 ................................................................225 11.2.2 Java的对象容器类 ....................................................................................226 11.2.3支持对象容器的辅助工具 ........................................................................228 §11.3 迭代器................................................................................................................229 11.3.1迭代器设计模式 ........................................................................................229 11.3.2迭代器的基本用法 ....................................................................................230 11.3.3列表专用迭代器 ........................................................................................230 11.3.4旧版本的枚举接口 ....................................................................................232 §11.4 类集容器 ............................................................................................................232 11.4.1类集容器接口 ............................................................................................232 11.4.2列表容器 ....................................................................................................235 11.4.3集合容器 ....................................................................................................238 §11.5 映射容器 ............................................................................................................240 11.5.1映射容器接口 ............................................................................................240 11.5.2映射容器类 ................................................................................................245 §11.6 对象容器操纵工具 ............................................................................................247 11.6.1数组操纵工具 ...........................................................................................247 11.6.2容器操纵工具 ...........................................................................................249 内容小结.......................................................................................................................251 思考与练习...................................................................................................................252 上机实习题...................................................................................................................253 小课题：对象容器的性能比较...................................................................................253 第十二章图形用户界面...................................................................................................255 §12.1用户界面设计概述 ............................................................................................255 12.1.1 用户界面设计原则 ...................................................................................255 12.1.2 用户界面设计内容 ...................................................................................256 §12.2 Java程序的用户界面设计 .................................................................................257 12.2.1 Java程序的用户界面 ................................................................................257 12.2.2 GUI系统的组成........................................................................................257 12.2.3 AWT和 Swing组件 ..................................................................................258 §12.3 Swing概述 .........................................................................................................258 12.3.1 Swing组件 ................................................................................................258 12.3.2 Swing的 M-UI设计模式 .........................................................................259 12.3.3 Swing的事件处理模式.............................................................................260 12.3.4 一个简单的 GUI程序..............................................................................262 - vi - 12.3.5 类 JComponent简介.................................................................................265 §12.4 Swing顶层容器 .................................................................................................268 12.4.1 画框的使用 ...............................................................................................268 12.4.2 对话框的使用 ...........................................................................................269 §12.5 Swing中间容器 .................................................................................................272 12.5.1 分隔窗格的使用 .......................................................................................272 12.5.2 滚动窗格的使用 .......................................................................................273 12.5.3 带标签窗格的使用 ...................................................................................278 12.5.4 工具条的使用 ...........................................................................................280 §12.6 Swing原子控件 .................................................................................................281 12.6.1 标签的使用 ...............................................................................................281 12.6.2 按钮的使用 ...............................................................................................283 12.6.3 检查框的使用 ...........................................................................................286 12.6.4 广播按钮的使用 .......................................................................................289 12.6.5 组合框的使用 ...........................................................................................290 12.6.6 列表的使用 ...............................................................................................294 12.6.7 文本控件的使用 .......................................................................................300 12.6.8 表格的使用 ...............................................................................................307 12.6.9 菜单的使用 ...............................................................................................311 §12.7 Swing的布局管理 .............................................................................................316 12.7.1 布局管理器概述 .......................................................................................316 12.7.2 顺序布局管理器 .......................................................................................317 12.7.3 边界布局管理器 .......................................................................................318 12.7.4 网格布局管理器 .......................................................................................318 12.7.5 网格包布局管理器 ...................................................................................319 12.7.6 盒式布局管理器 .......................................................................................321 12.7.7 卡片布局管理器 .......................................................................................322 12.7.8 组件的绝对定位 .......................................................................................323 12.7.9 边框的使用 ...............................................................................................324 §12.8编写小应用程序 ................................................................................................328 12.8.1 Applet的特点 ............................................................................................328 12.8.2 Applet的编程模式 ....................................................................................328 12.8.3 Applet的编程举例 ....................................................................................330 内容小结.......................................................................................................................332 思考与练习...................................................................................................................332 上机实习题...................................................................................................................333 第十三章数据库编程初步...............................................................................................334 §13.1关系数据库与 SQL简介 ..................................................................................334 13.1.1 关系数据库的基本概念 ...........................................................................334 13.1.2 创建关系数据库举例 ...............................................................................334 13.1.3 SQL简介 ...................................................................................................337 §13.2 JDBC结构与原理..............................................................................................341 13.2.1 数据库应用的多层结构 ...........................................................................341 13.2.2 JDBC的结构.............................................................................................342 13.2.3 建立使用 JDBC的运行环境 ...................................................................343 §13.3 JDBC应用入门..................................................................................................344 13.3.1 使用 JDBC的编程模式 ...........................................................................344 13.3.2 Java与 SQL间的数据类型映射 ..............................................................347 13.3.3 使用数据表的元信息 ...............................................................................349 13.3.4 封装与数据库访问有关的操作 ...............................................................350 §13.4数据库应用程序举例 ........................................................................................353 - vii - 13.4.1 需求分析 ...................................................................................................353 13.4.2 系统设计 ...................................................................................................354 13.4.3 编码实现 ...................................................................................................356 内容小结.......................................................................................................................367 思考与练习...................................................................................................................368 上机实习题...................................................................................................................369 第十四章多线程编程.......................................................................................................370 §14.1线程的基本概念 ................................................................................................370 14.1.1 什么是线程？ ...........................................................................................370 14.1.2 Java程序中的线程 ....................................................................................370 §14.2线程生存期与线程调度 ....................................................................................371 14.2.1 创建线程 ...................................................................................................371 14.2.2 Java程序的主线程 ....................................................................................373 14.2.3 线程的生存期 ...........................................................................................373 14.2.4 使用 yield()方法 .......................................................................................374 14.2.5 优先级与线程调度 ...................................................................................375 14.2.6 线程组 .......................................................................................................377 14.2.7 守护线程 ...................................................................................................378 §14.3资源共享与线程同步 ........................................................................................379 14.3.1 线程安全性 ...............................................................................................379 14.3.2 同步代码段与锁 .......................................................................................380 14.3.3 设计线程安全的应用程序 .......................................................................382 §14.4其他线程通信方式 ............................................................................................383 14.4.1 使用 sleep()方法.......................................................................................383 14.4.2 使用 join()方法.........................................................................................383 14.4.3 使用 wait()/notify()/notifyAll()方法.........................................................384 14.4.4 使用 I/O操作 ...........................................................................................386 14.4.5 不主张使用的方法 ...................................................................................386 §14.5使用定时器 ........................................................................................................387 14.5.1 通用定时器 ...............................................................................................387 14.5.2 Swing专用定时器.....................................................................................389 §14.6高级多线程设计 ................................................................................................389 14.6.1 并发模型 ...................................................................................................389 14.6.2 互斥问题 ...................................................................................................391 14.6.3 生产者∕消费者问题 ...............................................................................393 内容小结.......................................................................................................................396 思考与练习...................................................................................................................396 上机实习题...................................................................................................................397 小课题：资源池与线程池...........................................................................................397 第十五章网络通信编程...................................................................................................399 §15.1网络通信的基本概念 ........................................................................................399 15.1.1 通信协议 ...................................................................................................399 15.1.2 TCP与 UDP ..............................................................................................401 15.1.3 端口...........................................................................................................401 15.1.4 Java对网络通信的支持 ............................................................................402 §15.2基于 URL的通信..............................................................................................403 15.2.1 使用 URL对象.........................................................................................403 15.2.2 使用 URL连接.........................................................................................405 §15.3基于 TCP的通信 ..............................................................................................407 15.3.1 指定主机 ...................................................................................................407 15.3.2 基于 socket的 C/S编程...........................................................................408 - viii - 15.3.3 多线程服务程序 .......................................................................................411 §15.4典型的因特网应用 ............................................................................................413 15.4.1 一个简单的端口扫描程序 .......................................................................413 15.4.2 一个简单的 HTTP服务程序...................................................................414 15.4.3 一个简单的 Telnet客户程序...................................................................415 15.4.4 一个简单的 SMTP客户程序 ..................................................................417 §15.5基于 UDP的通信..............................................................................................418 15.5.1 单播通信 ...................................................................................................418 15.5.2 多播通信 ...................................................................................................422 内容小结.......................................................................................................................424 思考与练习...................................................................................................................424 上机实习题...................................................................................................................425 第十六章结束语...............................................................................................................426 §16.1设计原则 ............................................................................................................426 16.1.1 设计原则与设计模式 ...............................................................................426 16.1.2 B. Meyer的设计原则................................................................................426 16.1.3 R. Martin的设计原则 ...............................................................................427 §16.2设计模式 ............................................................................................................428 16.2.1 什么是模式 ...............................................................................................428 16.2.2 GoF设计模式 ............................................................................................429 16.2.4 POSA设计模式.........................................................................................431 16.2.5 反模式 .......................................................................................................431 §16.3分布式对象技术 ................................................................................................432 16.3.1 进程内通信与进程间通信 .......................................................................432 16.3.2 实现网络通信的途径 ...............................................................................432 16.3.3 分布式对象系统 .......................................................................................432 内容小结.......................................................................................................................433 思考与练习...................................................................................................................433 上机实习题...................................................................................................................434
java基础程序设计
11-02
非常适合自学的，零基础学习，全面的java自学资料，程序设计。
Java程序设计PPT
11-22
Java程序设计版PPT.包含了所有的PPT。非常适合初学者
Java程序设计PPT详解
08-20
《Java程序设计》通过对Java编程语言的全面介绍，引导读者快速地掌握Java编程语言的核心内容并学会灵活运用所学的语言知识及面向对象的编程思想。《Java程序设计》共分12章，内容包括Java语言概述、面向对象编程初步...
java程序设计例题全集
04-21
这是我大学期间java程序设计课程所写的所有java程序，值得大家借鉴！
吉林大学Java程序设计实验报告.docx
09-01
吉林大学Java程序设计实验报告.docx
Java程序设计--Java入门（一）
会思想的苇草i的博客
03-15 9315
Java是一种广泛使用的面向对象编程语言，具有跨平台、可移植性和安全性等特点。本文将介绍Java的概述，包括其历史、特点和应用领域。我们将给出一个简单的热门程序HelloWorld的示例，并解释其中的代码逻辑。此外，我们还将指导读者如何下载、安装和配置Java开发环境，特别是使用IDEA进行Java开发。我们将介绍IDEA的基本功能和常用操作，以帮助读者快速上手。通过本文的学习，读者将能够对Java有一个整体的认识，同时掌握HelloWorld程序的编写和IDEA的基本使用方法。
java中设计思想及设计原则及设计模式解析
踩踩踩从踩的博客
12-05 2777
前言 在java开发过程中，或者各种语言在编程过程中，对基础知识的累计，这其中就会包含java的设计思想及设计原则及设计模式；我们想对当前的架构以及某些功能逻辑进行优化，及繁简，更加适合当前业务的开发，如何让人一看就能懂得代码，以及各种热门框架 包括spring mybatis 等等热门框架，我们想对其中进行研究，以及或者自己写一个比较好得框架，这一定是离不开得。除了java基础知识，优化， 这就是 研究设计原则和设计模式得意义对于开发，深层次得了解，有着更大的意义，废话不多说 从设计思想开始说起。 .
java程序设计基础
最新发布
02-29
Java程序设计基础是指学习和掌握Java编程语言的基本概念、语法和技巧。下面是一些Java程序设计基础的内容： 1. Java语言特点：Java是一种面向对象的编程语言，具有简单、可移植、安全、高性能等特点。 2. 基本语法：Java的基本语法包括变量、数据类型、运算符、控制流程（条件语句、循环语句）、数组等。 3. 面向对象编程：Java是一种面向对象的编程语言，具有封装、继承、多态等特性。学习面向对象编程的概念和原则是Java程序设计的基础。 4. 类和对象：Java中的类是对象的模板，对象是类的实例。学习如何定义类、创建对象、访问对象的属性和方法等是Java程序设计的基础。 5. 方法和函数：Java中的方法用于封装可重用的代码块，函数是方法的一种殊形式。学习如何定义和调用方法、传参数等是Java程序设计的基础。 6. 异常处理：Java提供了异常处理机制，用于处理程序运行过程中可能出现的异常情况。学习如何捕获和处理异常是Java程序设计的基础。 7. 输入输出：Java提供了丰富的输入输出类和方法，用于处理文件、网络等输入输出操作。学习如何读写文件、网络编程等是Java程序设计的基础。 8. 集合框架：Java提供了一套集合框架，用于存储和操作数据集合。学习如何使用集合框架进行数据操作是Java程序设计的基础。 9. 多线程编程：Java支持多线程编程，可以同时执行多个任务。学习如何创建和管理线程、线程同步等是Java程序设计的基础。 10. GUI编程：Java提供了Swing和JavaFX等图形用户界面库，用于开发图形界面应用程序。学习如何使用GUI库进行界面设计和事件处理是Java程序设计的基础。 以上是Java程序设计基础的一些内容，希望对你有所帮助。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值