学习java第一周的总结

• 开发环境的配置

1. JDK的下载与安装

1. 下载途径:oracle官网、选择适合自己的版本
2. 配置环境变量：

变量名：JAVA_HOME

变量值：C:\Program Files (x86)\Java\jdk1.8.0_91        // 根据jdk实际安装路径配置

变量名：CLASSPATH

变量值：.;%JAVA_HOME%\lib\dt.jar;%JAVA_HOME%\lib\tools.jar;         //前面有个"."

变量名：Path

变量值：%JAVA_HOME%\bin;%JAVA_HOME%\jre\bin;

1. 环境变量配置时用到的DOS命令：

“盘符+分号”表示到这个盘

“cd+目录”表示到这个目录下

“dir”表示显示该目录下的文件列表

“cd..”表示倒退一个目录

“cd\”表示退回根目录

“cls”表示清除

“java -version”查看当前jdk版本号

“javac 文件名.java”编译

“java 文件名”运行

4）专业术语

1. JDK(Java SE Development Kit)java开发工具
2. JRE(Java Runtime Environment)java运行环境
3. JVM(Java Virtual Machine)java 虚拟机
4. API(Application Programming Interface)应用程序编程接口

二、进制问题

常见的进制问题主要有以下几种：

①二进制转十进制

方法：把二进制数按权展开（指数）、相加即得十进制数

②二进制转八进制

方法：将二进制数字从低位分为每3位一组，3位二进制数按权展开相加得到1位八进制数，不足时补0

③二进制转十六进制

方法为：与二进制转八进制方法很相似，八进制是取三合一，十六进制是取四合一，不足时补0

④十进制转二进制

方法为：十进制数除2取余法，即十进制数除2，余数为权位上的数，得到的商值继续除2，依此步骤继续向下运算直到商为0为止

三、Java的基本语法

一个Java程序可以认为是一系列对象的集合，而这些对象通过调用彼此的方法来协同工作。下面简要介绍下类、对象、方法和实例变量的概念。

• 对象：对象是类的一个实例，有状态和行为。例如，一条狗是一个对象，它的状态有：颜色、名字、品种；行为有：摇尾巴、叫、吃等。
• 类：类是一个模板，它描述一类对象的行为和状态。
• 方法：方法就是行为，一个类可以有很多方法。逻辑运算、数据修改以及所有动作都是在方法中完成的。
• 实例变量：每个对象都有独特的实例变量，对象的状态由这些实例变量的值决定。

public class HelloWorld { /* 第一个Java程序 * 它将打印字符串 Hello World */

 public static void main(String []args) {

System.out.println("Hello World"); // 打印 Hello World

 }

}

注意：

编写Java程序时，应注意以下几点：

1）大小写敏感：Java是大小写敏感的，这就意味着标识符Hello与hello是不同的。

类名：对于所有的类来说，类名的首字母应该大写。如果类名由若干单词组成，那么每个单词的首字母应该大写，例如 MyFirstJavaClass 。

2）方法名：所有的方法名都应该以小写字母开头。如果方法名含有若干单词，则后面的每个单词首字母大写。

3）源文件名：源文件名必须和类名相同。当保存文件的时候，你应该使用类名作为文件名保存（切记Java是大小写敏感的），文件名的后缀为.java。（如果文件名和类名不相同则会导致编译错误）。

4主方法入口：所有的Java 程序由public static void main(String []args)方法开始执行。

 

三、注释

1.单行注释 //

2.多行注释  / *

 *

 */

3.文档注释(只有java有)  /**

*

*/

4.Html注释 <!--  -->

5.css注释：跟Java一样

6.JavaScript注释：跟Java一样

四、标识符

1、定义：Java所有的组成部分都需要名字。类名、变量名以及方法名都被称为标识符。

2、命名规则：首字母必须是字母、$、下划线，后面部分可以是字母、$、下划线、数字

3、注意： 1）标识符是大小写敏感的

2）关键字是不能作标识符的

关键字: 关键字是指java语音里事先定义的，有特别意义的标识符，有时又叫保留字，还有特别意义的变量。Java的关键字对Java的编译器有特殊的意义，他们用来表示一种数据类型，或者表示程序的结构等，关键字不能用作变量名、方法名、类名、包名和参数。

Java中一些常见的关键字：

abstract	assert	boolean	break	byte
case	catch	char	class	const
continue	default	do	double	else
enum	extends	final	finally	float
for	goto	if	implements	import
instanceof	int	interface	long	native
new	package	private	protected	public
return	strictfp	short	static	super
switch	synchronized	this	throw	throws
transient	try	void	volatile	while
true	false	null

 

驼峰命名法是程序员间的一种默认的命名规范。

五：Java中的数据类型

1. 什么是变量?

变量就是申请内存来存储值。也就是说，当创建变量的时候，需要在内存中申请空间。内存管理系统根据变量的类型为变量分配存储空间，分配的空间只能用来储存该类型数据。

因此，通过定义不同类型的变量，可以在内存中储存整数、小数或者字符。

2、基本数据类型

1. 整数类型有三种
   1. Int数据类型：int数据类型是32位、有符号的以二进制补码表示的整数；

最小值是-2,147,483,648（-2^31）；

最大值是2,147,483,647（2^31 - 1）；

一般地整型变量默认为int类型；

型默认值是0；

1. 1. Long长整型

long数据类型是64位、有符号的以二进制补码表示的整数；

最小值是-9,223,372,036,854,775,808（-2^63）；

最大值是9,223,372,036,854,775,807（2^63 -1）；

这种类型主要使用在需要比较大整数的系统上；

默认值是0L；

例子： long a = 100000L，Long b = -200000L。

1. 1. Short短整型

       short数据类型是16位、有符号的以二进制补码表示的整数

最小值是-32768（-2^15）；

最大值是32767（2^15 - 1）；

Short数据类型也可以像byte那样节省空间。一个short变量是 int型变量所占空间的二分之一；

默认值是0；

例子：short s = 1000，short r = -20000。

1. 浮点类型

1. float 单精度浮点类型

  float数据类型是单精度、32位、符合IEEE 754标准的 浮点数；

float在储存大型浮点数组的时候可节省内存空间；

默认值是0.0f；

浮点数不能用来表示精确的值，如货币；

例子：float f1 = 234.5f。

b)double 双精度浮点类型

double数据类型是双精度、64位、符合IEEE 754标准的浮点数；

浮点数的默认类型为double类型；

double类型同样不能表示精确的值，如货币；

默认值是0.0d；

例子：double d1 = 123.4。

1. 字符字节类型

1. byte 字节类型

byte数据类型是8位、有符号的，以二进制补码表示的整数；

最小值是-128（-2^7）；

最大值是127（2^7-1）；

默认值是0；

byte类型用在大型数组中节约空间，主要代替整数，因为byte变量占用的空间只有int类型的四分之一；

例子：byte a = 100，byte b = -50

B) char字节类型

 char类型是一个单一的16位Unicode字符；

最小值是’\u0000’（即为0）；

最大值是’\uffff’（即为65,535）；

char数据类型可以储存任何字符；

例子：char letter = ‘A’。

1. 布尔类型

boolean数据类型表示一位的信息；

只有两个取值：true和false；

这种类型只作为一种标志来记录true/false情况；

默认值是false；

例子：boolean one = true。

1. 数据类型的转换

1. 自动转换

由低到高的转换 byte,short,char—> int —> long—> float —> double

注意：①不能对boolean类型进行类型转换。

②不能把对象类型转换成不相关类的对象。

③在把容量大的类型转换为容量小的类型时必须使用强制类型转换。

④转换过程中可能导致溢出或损失精度

例如：int i =128;   byte b = (byte)i;

因为byte类型时8位，最大值为127，所以当强制转换为int类型值128时候就会导致溢出。

⑤浮点数到整数的转换是通过舍弃小数得到，而不是四舍五入

例如：

(int)23.7 == 23; (int)-45.89f == -45

 

 

 

 

1. 强制转换

必须满足转换前的数据类型的位数要低于转换后的数据类型，例如: short数据类型的位数为16位，就可以自动转换位数为32的int类型，同样float数据类型的位数为32，可以自动转换为64位的double类型。

• 变量类型

在Java语言中，所有的变量在使用前必须声明。声明变量的基本格式如下：

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

格式说明：type为Java数据类型。identifier是变量名。可以使用逗号隔开来声明多个同类型变量。

public class Variable{ static int allClicks=0; // 类变量

String str="hello world"; // 实例变量

public void method(){ int i =0; // 局部变量 } }

Java中主要有如下几种类型的变量

• 1. 1. 1. 局部变量
• 局部变量声明在方法、构造方法或者语句块中；
• 局部变量在方法、构造方法、或者语句块被执行的时候创建，当它们执行完成后，变量将会被销毁；
• 访问修饰符不能用于局部变量；
• 局部变量只在声明它的方法、构造方法或者语句块中可见；
• 局部变量是在栈上分配的。
• 局部变量没有默认值，所以局部变量被声明后，必须经过初始化，才可以使用。

 

• 1. 1. 1. 类变量（静态变量）
• 类变量也称为静态变量，在类中以static关键字声明，但必须在方法构造方法和语句块之外。
• 无论一个类创建了多少个对象，类只拥有类变量的一份拷贝。
• 静态变量除了被声明为常量外很少使用。常量是指声明为public/private，final和static类型的变量。常量初始化后不可改变。
• 静态变量储存在静态存储区。经常被声明为常量，很少单独使用static声明变量。
• 静态变量在第一次被访问时创建，在程序结束时销毁。
• 与实例变量具有相似的可见性。但为了对类的使用者可见，大多数静态变量声明为public类型。
• 默认值和实例变量相似。数值型变量默认值是0，布尔型默认值是false，引用类型默认值是null。变量的值可以在声明的时候指定，也可以在构造方法中指定。此外，静态变量还可以在静态语句块中初始化。
• 静态变量可以通过：ClassName.VariableName的方式访问。
• 类变量被声明为public static final类型时，类变量名称一般建议使用大写字母。如果静态变量不是public和final类型，其命名方式与实例变量以及局部变量的命名方式一致。

 

• 1. 1. 1. 成员变量（非静态变量）
• 成员变量声明在一个类中，但在方法、构造方法和语句块之外；
• 当一个对象被实例化之后，每个成员变量的值就跟着确定；
• 成员变量在对象创建的时候创建，在对象被销毁的时候销毁；
• 成员变量的值应该至少被一个方法、构造方法或者语句块引用，使得外部能够通过这些方式获取成员变量信息；
• 成员变量可以声明在使用前或者使用后；
• 访问修饰符可以修饰实例变量；
• 成员变量对于类中的方法、构造方法或者语句块是可见的。一般情况下应该把成员变量设为私有。通过使用访问修饰符可以使成员变量对子类可见；
• 成员变量具有默认值。数值型变量的默认值是0，布尔型变量的默认值是false，引用类型变量的默认值是null。变量的值可以在声明时指定，也可以在构造方法中指定；
• 成员变量可以直接通过变量名访问。但在静态方法以及其他类中，就应该使用完全限定名：ObejectReference.VariableName。

 

• 运算符

1、算数运算符   +   -   *  /  %  ++   --

    Int a=10;

Int b=12;

Int c=a+b;   int  d=a-b; int  e=a*b; int f=a/b;

%   是运算除法后求余数

Int  g= b%a;  

  g=2;

小的数取模于大的数结果等于小的数。

++a   先运算后赋值

a++  先赋值后运算

2、关系运算符

== 判断运算值是否相等  相等结果为真

!=  判断运算是否不相等  不相等结果为真

>  大于          < 小于        >=大于等于       <=小于等于

3、位运算符

Java定义了位运算符，应用于整数类型(int)，长整型(long)，短整型(short)，字符型(char)，和字节型(byte)等类型。

位运算符作用在所有的位上，并且按位运算。假设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

4、逻辑运算符

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

5、赋值运算符

6、条件运算符(三元运算符)

System.out.println(10<20？可以:不可以);

三元运算符可以看作是一个if   else  判断结构的语句简写。

7、INSTANCEOF

对象运算符instanceof用来测试一个指定对象是否是指定类（或它的子类）的实例，若是则返回true，否则返回false

String s = new String("sa");  

if(s instanceof Object){  

    System.out.println("String is object class");  

}  

8、运算符的优先运算等级

我们在数学运算中的优先等级一样。

    

八、函数

1、函数的定义

函数也叫方法，是具备特定功能的一段代码块

2、函数的作用

1. 提高程序的复用性和可读性
2. 解决了重复性代码的问题
3. 函数只有被调用后，才能执行。
4. 对于没有具体返回值的情况，返回值类型用关键字void表示，那么return语句可以省略不写
5. 注意：（容易犯错点）

a、函数中只能调用函数，不能写在函数内部。

b、定义函数的时候，函数的结果返回给调用者，交由调用者处理。

（输出语句不能调用void的函数）

1. 函数的格式：

修饰符返回值类型函数名(形式参数类型1  参数名1,形式参数类型2  参数名2,形式参数类型3  参数名3......)

 

{

 

函数体语句;

 

return  返回值;

 

}

1. 函数中各个名词的解释

  1）、修饰符：public 公共的static 静态的

    2)、返回值类型：就是函数所实现的功能结果的数据类型。

    3）、方法名：自己定义，符合标识符命名规则就行；驼峰命名规则 :单个单词首字母小写，多个单词后面的单词首字母大写。

    4）、参数列表：即形式参数列表，用于接收实际参数。

    5）、参数类型：参数的数据类型

    6）、参数名：即变量名

    7）、函数体语句：就是函数要完成的功能

    8）、return:用来结束函数

9）、返回值：即这个函数的功能的结果 ，由return带回调用地方。

注意：void 表示不确定返回值类型，不能理解为没有返回值，只是返回值的类型不确定而已；

此外，返回值类型为void时，由于其返回值类型不能确定，故不能定义形式参数变量来接收；

当返回值类型为void时，return可以不写；但是当返回值类型为其他如int  String等时就必须写，否则编译会出错。

九、数组

1、数组的定义

数组是指一组数据的集合，数组中的每个数据称为元素。在Java中，数组也是Java对象。数组中的元素可以是任意类型(包括基本类型和引用类型),但同一个数组里只能存放类型相同的元素。

2、数组的作用

自动给数组中的元素从0开始进行编号，方便操作

3、如何创建一个数组

声明一个数组类型的引用变量，简称为数组变量；

用new语句构造数组的实例。new语句为数组分配内存，并且为数组中的每个元素赋予默认值；
     初始化，即为数组的每个元素设置合适的初始值。

格式1：元素数据类型[] 命名=new 元素数据类型[数组元素长度(元素的个数)];

格式2：元素类型[] 数组名=new 元素类型[]{元素1，元素2，....};//常规的数组初始化方式

    元素类型[] 数组名={元素1，元素2，....};//静态初始化方式

两个格式的使用时机不同：格式1需要一个容器，但是不明确容器中具体的数组。

                    格式2需要一个容器，直接存储数据。

1. 数组中常见的两个异常：

1）java.lang.ArrayIndexOutOfBoundsException数组越界异常：Java在数组元素引用要进行越界检查以确保安全性，如果越界，就会抛出数组越界异常

2）NullPointerException空指针异常：当应用变量没有具体指向的时候，会发生空指针异常

1. 数组中常见的操作

对数组最常见的操作就是赋值和取值。

核心思想：对角标操作

数组中最大的角标就是数组长度-1。

数组长度：数组名.length

案例：求数组元素的最大值（最小值）

获取最大值{12,20,1,35,199,57}

思路：（1）、需要进行比较，并定义变量记录每次比较较大的值。

      （2）、对数组中的元素进行遍历，和变量种方法的值进行比较，如果遍历元素中的值大于变量的值，就用该变量记住该大值。

      （3）、遍历结束，该变量的值就是最大值。

7、内存空间的划分

每一块内存，内存数据的处理方式不一样，都有自身的处理方式和处理特点：

内存区域划分

a、寄存器：给cpu用的，cpu处理

b、本地方法区：

c、方法区：

d、栈内存：

存储局部变量。（凡是定义在方法里面的变量，就叫局部变量）

而且变量所属的作用域一旦结束，该变量会自动释放。生命周期短。

e、堆内存

存储内容：存储的数组和对象（数组其实就是一个对象）

用new创建的，都放在堆内存里面。

堆会自动释放吗？

不会，因为如果能自动释放，和栈就没什么区别了！

垃圾回收机制GC

原理：随机随时去回收。

堆的特点：

1）、每一个实体都有个首地址。

2）、堆内存中的每一个变量都有默认的初始化值，根据类型的不同，初始化的值也不同，比如：

int---->0,float---->0.0f;char---->''boolean---->fasle

3）、垃圾回收机制GC：面试题：为什么会有GC？

十、流程控制语句

1. 条件控制语句

a.if结构

if(布尔表达式)

{

   //如果布尔表达式为true执行的代码

}

• 1
• 2
• 3
• 4

b.if…else结构

if(布尔表达式){

   //如果布尔表达式的值为true执行的代码

}else{

   //如果布尔表达式的值为false执行的代码

}

c.if…else if…else结构

if(布尔表达式1){

   //如果布尔表达式1的值为true执行的代码

}else if(布尔表达式2){

   //如果布尔表达式2的值为true执行的代码

}else{

   //如果布尔表达式1、2的值都为false执行的代码

}

e.switch语句

switch(expr){

    case value1:

        statements1;

        break;

    …

    case valueN:

        statementsN;

        break;

    //可以有任意数量的case语句

    default:

        statements;

        break;

}

注意：

1. 变量expr
   switch语句中，变量expr的类型必须是能够与int类型兼容（能自动转换成int类型）的基本类型，包括byte、short、char和int类型。
2. 常量valueN
   • valueN必须是与int类型兼容的基本类型
   • valueN必须是常量
   • 同一个switch的各valueN表达式的值不能相同
3. 当变量expr与某个常量valueN匹配时就会执行相应的case子句，遇到break语句时就退出整个switch语句，否则依次执行switch中所有后续的case子句和default子句不再检查常量valueN的值。
4. default
   • 每个switch语句中最多只能有一个default子句，也可以没有default子句
   • 当expr的值不与任何valueN的值匹配时就执行default子句
   • default子句可以位于switch语句中的任何位置，通常写在最后

 

2、循环控制语句

a. for循环

for(循环初值; 循环条件; 步长)

{

  //循环体

}

 

b. while循环

while (循环条件)

{

  //循环体

}

 

c. do while循环

do

{

  //循环体

} while (循环条件);

十一、冒泡排序与选择排序

冒泡排序的思想是:使用数组中从第一个元素开始，相邻的两个元素进行比较，把大的或小的放在后一个位置，然后依次往后进行比较，一次比较完，最后一个就是这个数组中最大或最小的数，然后又从第一个元素开始，相邻元素进行比较，结果会把剩下的元素中最大的或最小的数放在倒数第二个位置上，依此类推，就可以把数组按照从小到大或从到小进行排序。

选择排序的思想是:使用数组中的第一个元素，与数组中它后面的元素进行比较，把最大的或最小的放在第一位，一圈比完后，拿第二个元素跟后面的元素比，把最大的或最小的放在第二位；依此类推，就可以把数组按照从小到大或从到小进行排序。

 

import java.util.Arrays;

 

public class Sort {

 

public static void main(String[] args) {

 

int[] arr={12,45,89,2,10,9};

 

maopaoSort(arr);

 

selectSort(arr);

 

}

 

/*

 

 * 冒泡排序

 

 */

 

public static void maopaoSort(int[] arr) {

 

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

 

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

 

if(arr[j]>arr[j+1]){

 

int temp=arr[j];

 

arr[j]=arr[j+1];

 

arr[j+1]=temp;

 

}

 

}

 

}

 

System.out.println("冒泡排序:"+Arrays.toString(arr));

 

}

 

/*

 

 * 选择排序

 

 */

 

public static void selectSort(int[] arr) {

 

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

 

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

 

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

 

int temp=arr[i];

 

arr[i]=arr[j];

 

arr[j]=temp;

 

}

 

}

 

}

 

System.out.println("选择排序:"+Arrays.toString(arr));

 

}

 

}