Java基础

一、初步认识

1995年5月，Sun Microsystems开发了一门编程语言Java

目标：曾经是创建能嵌入消费类电子设备的软件，构建一种既可移植又可跨平台的语言。（詹姆斯.高斯林Java之父）（编写一次，随处运行）

指令：一个特定的代码块，告诉计算机怎么做

算法：解决某些事情的方法和步骤（流程图）

程序：完成某些事情的特定的步骤

JDK(Java Development Kit),是用于开发Java应用程序的开发包。它提供了编译、运行Java程序所需的各种工具和资源。

bin目录:存放编译、运行Java程序的可执行文件。

Lib目录：存放Java的类库文件。

Demo目录：存放演示程序。

Jre目录：存放Java运行环境文件。

Java API帮助文档（JDK 文档）。

反编译工具有jd、Front End Plus。

二、数据类型和运算符

标识符的命名规则：字(字母)下(下划线)美($)人(￥)数(数字)骆驼（开头）。不能含有特殊符号，使用驼峰命名法。

注释：单行注释、多行注释和文档注释。（//、/* */、/** */）

    整数类型（byte{-128——127一个字节}，short{两个 字节}，int{四个字节，上亿}，long{八个字节}）

                 数值型：

  浮点类型（float，double{精确度较高}）

 

1.基本数据类型： 字符型 （char{0——65535}）

 

                 布尔型 （boolean {真假值}）

 

                

                类（class）

2.引用数据类型：接口（interface）

                数组（[]）

2.1数据类型的转换：

数据转换机制：1、自动转换2、强制转换

两个相同数据类型数据在运算时得到的结果和这两个数据的数据类型一致，如果两个数据类型不相同的数据进行运算时会先将两个数据类型都转换成相同数据类型(向高精度转)，低精度数据类型向高精度数据类型转换时自动转换，高精度数据类型向低精度数据类型转换时为强制类型转换，表达式前加（数据类型）为强转。

  Char->

int->long->float->double

Byte->short->

2.2Java中的运算符

赋值运算符：“+=”、“-=”、“*=”、“/=”、“%=”。

算术运算符：“+”、“-”、“*”、“/”、“%”、“++”、“--”。

++在前先运算后赋值       ++在后先赋值在运算

注意：1，除法运算符，如果两个操作数均是整数，结果也是整数，会舍弃小数部分；如果两个操作数中有一个是浮点数，将进行自动类型转换，结果也是浮点数，保留小数部分。

2，对于取模运算符，如果两个操作数均是整数，结果也是整数；如果两个操作数中有一个是浮点数，结果也是浮点数，保留小数部分。

3，自增运算符只有i++、++i两种使用方式，它们的相同点是都相当于i=i+1；不同点是i++是先进行表达式运算再加1，而++i是先加1再进行表达式运算。

关系运算符：“==”、“!=”、“>”、“<”、“>=”、“<=”.

==比较的是地址   .equals()比较值是String的方法

逻辑运算符：“&”、“|”、“^”(异或，相同为假，不同为真)、“！”、“&&”、“||”。

位运算符：“&”（按位于，两个操作数都为1，结果为1），“|”（按位或，两个操作数一个是1，结果为1）、“^”（按位异或，相同为0，不同为1）、“~”（按位非/取反，操作数为1，结果为0，反之）、“<<”（左移，右侧空位补0）、“>>”（右移，左侧空位补最高位，即符号位），“>>>”(无符号右移，左侧空位补0)。

条件运算符（三目运算符）：条件 ？ 表达式1 ： 表达式2

优先级和结合性

优先级	运算符	结合性
1	()、[]	从左向右
2	！、~、++、--	从右向左
3	*、/、%	从左向右
4	=、-	从左向右
5	<<、>>、>>>	从左向右
6	<、<=、>、>=、instanceof	从左向右
7	==、！=	从左向右
8	&	从左向右
9	^	从左向右
10	|	从左向右
11	&&	从左向右
12	||	从左向右
13	?:	从右向左
14	=、+=、-=、*=、/=、%=、&=、|=、^=、~=、<<=、>>=、>>>=	从右向左

 

三、流程控制

3.1流程控制结构

流程控制结构：顺序结构、选择结构、循环结构。

分支有三种：if  多重if   switch  (嵌套分支)

简单if

if(条件表达式){

代码块

}else{

代码块

}

多重if   条件

if(条件表达式){

代码块

}

else if(条件表达式){

代码块

}else{

代码块

}

1.7之前i的值只能是数值类型或者字符

1.7支持数值类型或者字符

int i=6;

switch(i){

case 1:

System.out.println();

break;

case 2:

System.out.println();

break;

case 3:

System.out.println();

break;

default://默认

System.out.println();

break;

}

3.2多重if和switch比较：

1.如果分支数量小于等于3多重if

2.如果判断条件是一个区间使用多重if

3.如果分支数量大于3并且条件对应的是数值、字符类型用switch

4.如果一个分支既可以使用多重if也可以使用switch并且分支大于3，使用switch

5.如果条件中有多个变量，非一个变量，用多重if

 

循环： while(循环条件){循环体}   do{循环体}while(循环条件);     for(循环变量声明并赋初值;条件判断;更新循环变量){循环体}    (嵌套循环)

只要不是{}结束的都加;。

循环有三种    while  do  while      for

循环中有死循环，循环中要避免死循环  但是可以利用死循环

while  使用步骤：1，先声明循环变量。2，编写while结果语法。3，在循环体中改变循环变量。

 

while 和 do while 区别：

 1，while先判断后执行   do while先执行后判断

 2，while循环可以一次都不执行  do while最少执行一次。

 3，循环变量均声明在循环的上方，均在循环体内改变。

 

 

 for循环和while循环在执行顺序上相同，但是for循环更灵活

 如果循环变量在循环下方不在被使用，最好使用for循环

  

 break 跳出代码块，所在循环     continue结束当前循环，和外部循环无关，继续下一次循环

  

 

两个关键字：break    continue    final

return结束整个方法

 

基本数据类型声明时建议初始化；每一种数据类型在开辟内存空间时都是固定位置

 

 

 

冒泡排序：降序排列

int temp=0;

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

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

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

temp=arr[j];

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

arr[j+1]=temp;

}

}

}

顺序排序:降序排列

int temp=0;

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

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

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

temp=arr[i];

arr[i]=arr[j];

arr[j]=temp;

}

}

}

}

四、数组

数组：在内存中开辟连续的内存空间，长度是固定的，角标不能越界。

二维数组实例：

Scanner input = new Scanner(System.in);

int[][] arr = new int[3][5];// 定义容器

int sum1=0;

int sum2=0;

int sum3=0;

//存储数据

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

System.out.println("************" + "第" + (j + 1) + "个班"

+ "************");

 

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

System.out.print("请输入第" + (i + 1) + "个同学的成绩：");

arr[j][i] = input.nextInt();

 

}

}

 

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

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

if(i==0){

sum1=arr[i][j]+sum1;

}

if(i==1){

sum2=arr[i][j]+sum2;

}

if(i==2){

sum3=arr[i][j]+sum3;

}

}

}

System.out.println("1班总成绩："+sum1);

System.out.println("2班总成绩："+sum2);

System.out.println("3班总成绩："+sum3);、

 

 

 

 

 

Arrays类及其常用方法

返回类型	方法	说明
boolean	Equals(array1,array2)	比较两个数组是否相等
void	Sort(array)	对数组array的元素进行升序排列
String	toString(array)	将一个数组array转换成一个字符串
void	Fill(array,val)	把数组array的所有元素都赋值为val
与array数据类型一致	copyOf(array,length)	把数组array复制成一个长度为length的新数组
int	binarySearch(array,val)	查询元素值val在数组array中的下标

 

五、类和对象

5.1类和对象

面向对象：它是一种编程思想，符合人类认识现实世界的思维方式。

面向对象的三大特征：封装、继承、多态。

面向对象的优点：

1，与人类的思维习惯一致。

2，封装使信息隐藏，提高了程序的可维护性和安全性。

3，一个类可以创建多个对象实例，体现了重用性。

 

类：是具有相同属性和方法的一组对象的集合。类定义了对象将会拥有的特征（属性）和行为（方法）。访问修饰符+class+类名{}

对象所拥有的特征在类中表示时，成为类的属性。

对象执行操作的行为称为类的方法。（分为有参和无参方法。）

对象：是用来描述客观事物的一个实体。

使用对象：对象名.属性 对象名.方法名()

对象：用来描述客观事物的一个具体实体，由一组属性和方法构成。

类：具有相同属性和方法的一组对象的集合。

类是对象的抽象，对象是类的具体

定义类的步骤：

（1）定义类名

（2）编写类的属性

（3）编写类的方法

类的访问修饰符：public、默认修饰符。

类成员的访问修饰符

	同一个类中	同一个包中	子类中	其他地方
private	可以使用	不可以使用	不可以使用	不可以使用
默认修饰符	可以使用	可以使用	不可以使用	不可以使用
protected	可以使用	可以使用	可以使用	不可以使用
public	可以使用	可以使用	可以使用	可以使用

 

class是一种自定义的数据类型（引用数据类型）

 

形参：创建work（）方法时定义的参数叫做形式参数。

实参：调用方法时传入的参数叫做实际参数。

方法有两种：一种无参   一种有参（方法声明时小括号内是无参）

 

初始值不同

Java会给成员变量一个初始值        

Java不会给局部变量赋予初始值

包命名规范：

包名由小写字母组成，不能以圆点开头或结尾

包名之前最好加上唯一的前缀，通常使用组织倒置的网络域名

包名后续部分依不同机构内部的规范不同而不同

使用包的注意事项：

一个类同时引用了两个来自不同包的同名类

必须通过完成类名来区分

每个包都是独立的，顶层包不会包含子包的类

package和import的顺序是固定的

package必须位于第一行（忽略注释行）

只允许有一个package语句

其次是import导入包，package创建包

接着是类的声明

 

 

protected只能修饰类成员（属性和方法），同包中可以访问。

父类：是由多个类提取相同属性和方法组成。

this这个类当前对象      super父类当前对象

 

 

成员变量：类中的属性，可以在类中任意位置进行调用，this（非静态方法）

成员变量的作用域在整个类内部都是可见的

 

局部变量：声明位置的大括号内，形参也是局部变量

局部变量的作用域仅限于定义它的方法或局部代码块

 

注意：

在同一个方法中，不允许有同名局部变量

在不同的方法中，可以有同名局部变量

在同一个类中，成员变量和局部变量同名时，局部变量具有更高的优先级

构造方法：

1，与类名相同

2，无返回值类型

作用：创建对象时执行一些初始化操作。

方法重载：

1，同一个类中

2，方法名相同

3，参数个数和类型不同

4，与返回值、访问修饰符无关

 

封装：将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问。

 

原则：1，把尽可能多的东西藏起来，对外提供便捷的接口

2，把所以的属性藏起来

private

步骤：1，修改属性的可见性

2，创建公有的setter/getter方法.

3,在getter/setter方法中加入属性控制语句

好处：

1.便于使用者正确使用系统，防止错误修改属性

2.有助于系统之间的松耦合，提高系统独立性

3.提高软件的可重用性

4.降低了构建大型系统的风险

类变量（静态变量）：

被static修饰的变量

在内存中只有一个拷贝

类内部，可在任何方法内直接访问静态变量

其他类中，可以直接通过类名访问

实例变量：

没有被static修饰的变量

每创建一个实例，就会为实例变量分配一次内存，实例变量可以在内存中有多个拷贝，互不影响。

 

继承：

将多个类中相同的属性和方法，提取出来组建一个新类

那么这个新类就是原来类的父类 原来的类继承此类

子类继承父类公有的属性和方法

方法重写  ： 方法名 参数列表相同  访问修饰符不能严于父类   

子类返回值类型必须和父类一致或者是父类返回值类型的子类  发生在有继承关系的子类和父类之间

 

方法重载 ：方法名相同  参数列表不同   与访问修饰符和返回值类型无关 发生在相同一个类中。

多态：如果子类重写父类方法 ，父类引用指向子类对象那么 调用父类方式时 执行子类重写方法

 

Object类是所有类的父类   其中提供equals方法均比较两个对象是否相同（地址）

String 类 重写equals方法  比较的是值（内容）

 

使用多态注意事项：1.必须父类有方法被子类继承  2.子类重写继承父类的方法 3.父类引用指向子类对象  （创建对象时，参数传递  形参声明成父类对象  实参传递子类对象）

 

多态好处：1.使程序满足面向对象（跟现实接轨） 2.简化程序代码 3.提高程序可维护性和可读性

六、抽象类和接口

abstract 抽象关键字  （父类一般都是抽象的）

抽象类不能实例化（new 构造方法）但是抽象类有构造方法

抽象方法 没有方法体  必须在抽象类中  子类继承抽象类时必须重写抽象父类的抽象方法 可以有普通方法和抽象方法

 

普通类可以被实例化，不能有抽象方法。

 

抽象类与抽象方法的使用

抽象类中可以没有抽象方法，但包含了抽象方法的类必须被定义为抽象类

 

抽象类vs接口：

相同点：1，接口和抽象类均代表系统的抽象层。

 2，接口和抽象类均不能被实现。

 3，接口和抽象类中均可以包含抽象方法。

 

不同点：

1，接口中只能包含常量 抽象类中可以包含普通属性

2，接口中没有构造方法因为接口不是类 抽象类中包含构造方法

3，接口中只能包含抽象方法 抽象类可以不包含抽象方法

4，一个类只能继承一个抽象类 但是可以实现多个接口

5，抽象类可以继承抽象类也可以实现接口，但是接口只能继承接口。

使用原则：（了解）

接口做系统与外界交互的窗口

接口本身一旦制定，就不允许修改。

 

七、异常

try作用:存放可能出现异常的代码块。

catch作用：当try代码块出现异常

catch直接捕获，try块内出现异常位置下方代码块不执行。

直接执行catch代码块 catch执行完毕后，跳出trycatch代码块，程序继续执行

 

e.printStachTrace()根据异常输出堆栈信息

 

排列catch语句的顺序：先子类后父类

发生异常时按顺序逐个匹配

只执行第一个与异常类型匹配的catch语句

 

 

throws和throw单独使用 内部出现异常

throws作用：声明某个方法可能抛出的各种异常，交于调用位置处理

 

throw作用：生成并，抛出异常