JAVA程序设计

1、JAVA与C#的区别：

基本语法区别

1.java的源文件名必须和类名一致

C#没有这个要求，但是建议一致

2.java的类继承关键字extends，接口为“implements”；C#都为“：”

3.java的包的概念可以理解为C#中的命名空间（我这么认为的），关键字为import

4.在java子类中用supper表示父类，C#用base

5.java中的final修饰类表示为封闭类（不能被继承），修饰方法时表示方法不能被重写，修饰变量的时候表示为常量

C#seal表示封闭类，readonly和const表示常量（注意之前的区别）

6.java中的重写不需要在重写的方法家virtual，在重写的方法中加上override，C#则必须加上。在java中子类重写父类的方法直接方法的声明 参数 返回值一致即可，不需要添加其他的东西。

7.java用包来对类和接口进行分类，C#用程序集和命名空间。

8.java的访问修饰符default、public、private、protected；C#的访问修饰符internal、public、private、protected。

二：源文件的声明规则

1.一个源文件只能有一个public类，可以有多个非public类，源文件名与public类的类名一致；

2.package放在源文件首行，import放在package和类定义之间；import语句和package语句对于源文件中的所有类都有效，同一源文件中不能给不同的类不同的包声明；

Java语言的特点：

• java语言的开发足够简单
• java是为数不多支持多线程编程的语言开发语言
• java支持自动的收集垃圾处理
• java是一门面向对象的开发语言

变量与常量：

标识符（变量名||常量名）：标识符以字母，下划线-，美元符$与数字组成，数字不能开头，不能是关键字与保留字。

保留字：

保留字您也不能做为关键字在程序中使用，英文它被系统占用并保留，将赋予特殊含义，如：byValue、cast、false、future、generic、inner、operator、outer、rest、true、var、goto、const、null

变量：

语法格式:<数据类型><名称><=值>

数据类型：java的数据类型很特殊，例如，不能将包含小数点的数字存储到只存储数值的变量中。

常量：

常量是不变化的量，如光速、圆周率、性别等。常量可分为字面常量或直接常量。

字面常量：5、true、13.57、'c'、'nfit'

直接常量：也称为符号常量，在使用之前必须先定义，如：

final double PI = 3.14;

final：表示不能更改该值。

java数据类型划分：

1、简单类型（基本类型）：

整型类型：byte、short、int、long

浮点类型：float、double

字符类型：char

布尔类型：boolean

2、对象类型（引用类型）：class（类型）、interface（接口）、数组、泛型

基本数据类型			占内存	取值范围	默认值
数 值 型	整 型	byte	1字节	-128~127	（byte）0
		short	2字节	-32768~32767	（short）0
		int	4字节	-2147483648~2147483647	0
		long	8字节	-9223372036854775808L~9223372036854775807L	0L
	浮 点 型	float	4字节	对于负数-3.402823E38~-1.401298E-45 对于正数1.401298E-45~3.402823E38	0.0F
		double	8字节	对于负数-1.79769313486232E308~-4.94065645841247E-324 对于正数4.94065645841247E-324~1.79769313486232E308	0.0
字符型		char	2字节	unicode字符，用单引号括起来	'u0000'
逻辑型		boolean	1字节	true,false	false

 数据类型选择：

• 在程序开发之中，用来描述整数的就使用int，用来描述小数就使用double；
• long这种数据类型一般会描述日期时间、内存大小、文件大小（字节）；
• 如果需要进行编码转换或者进行二进制数据传输，使用byte（-128~127）；
• char一般在描述中文的时候使用到（基本都会忽略）。
• boolean在描述程序逻辑的时候使用。

整型转换：

数据范围小的数据类型可以自动变为范围大的数据类型；

例子：

int a=1;    //int是整型比double浮点型小
double b=1.1;    //double浮点型比int整型大
System.out.println(a+","+b); //兼容数据类型小类型可以自动转换成大类型，最后输出的结果是：（2.1）double型

数据范围大的数据类型只有强制转换才可以变为数据范围小的数据类型。

double a=1.1;
int b=(int)a;    //double8个字节，int4个字节，大转小，强制转换
System.out.println(b);    //输出结果：1

boolean类型的数据：不能转换为其他任何基本数据类型。

更改数据类型：

int a;
double b=3.3;
int c=5;
a=b+(double)c;//将变量c 从int型转换成double型，使得数据更加精准

使用引用型变量：

基本数据类类型存的是数值本身，而引用类型变量在内存放的是数据的引用，并不是数据的本身，引用类型变量是以间接方式去获取数据。
引用类型变量都属于对象类型，如：数组、类、字符串等都属于引用类型变量。所以，引用类型变量里面存放的是数据的地址。

变量的作用域：

int a=1;
//可以在这个位置引用变量a
//在这里不可以引用变量b
{
      //在这里可以引用变量a
      //在这里不可以引用变量b
      int b=2;
      //在这里可以引用变量a与变量b，因为变量b已经存在了
}
//在这里不可以引用变量b，因为已经超出了b的作用域范围
//在这里引用变量a还是可以的
      

注：一个变量在声明钱并不存在，只有被声明知才可以对它进行引用。在定义它的块结束前一直存在，其中包括该块内嵌套的所有块。变量b只能在最内层的块中存在。在最内层的大括号之后，b就不存在了。而变量a在大括号结束前一直都存在。

算术运算符：

运算符	描述	示例	结果
+	加	1+1	2
-	减	2-1	1
*	乘	1*1	1
/	除	10/2	5
%	余数	11%2	1

Math类方法：

方法	描述
abs(x)	返回x的绝对值
max(x,y)	返回x,y的较大值
min(x,y)	返回x,y的较小值
pow(x,y)	返回x的y次幂
random()	返回0和1之间的随机数
round(x)	返回最接近x的整数值
sqrt(x)	返回x的平方根

例子：

public class Demo1{
    public static void main(String[] args){
    //算术运算演示
    int a =11;
    int b =2;
    int c =4;
    System.out.println("a+b="+(a+b));//加
    //将a与b转换成double类型后相除
    System.out.println("double型除法a/b="+（double）a /（double）b);//加
   //算术类Math下的方法使用
    System.out.println("c的b次幂="+Math.pow(c,b));
    System.out.println("c开平方="+Math.sqrt(c));
   //调用Math类中sqrt方法并将变量c传递给它，sqrt方法计算该参数的平方根并返回它，返回的值被赋给变量c.
     }
}

运算符：

对各种类型的数据进行加工的过程称为运算，表示各种不同运算的符号称为运算符，参与运算的数据称为操作数，按操作数的数目来分，可有：

一元运算符：++（自增1），--（自减1），+（正号），-（负号）

二元运算符：+，-，>

三元运算符：？：（条件表达式）　　//数据类型 变量 = 布尔表达式？条件满足时赋值内容：条件不满足时赋值内容

基本的运算符按功能划分：

（1）算术运算符：=，-，*，/，%，++，--　　（2）关系运算符：>，<，>=，<=，==，！=

（3）逻辑运算符：！，&&，||　　（4）位运算>>，<<，>>>，&，|，~

（5）赋值运算符：及其扩展赋值运算符如：+=，-=，*=，/=　　（6）条件运算符：？：

 分支语句：

if语句：

案例：单if结构仅条件为true时执行脚本，否则跳过，没有大括号界定时仅执行后续的一个语句。

int mark=98;
if(mark>=60){//98大于60，结果为true,执行大括号中的代码
    System.out.println("分数是："+mark);
    System.out.println("及格");
}
    System.out.println("考试结束");
/*输出结果：
分数是98；
及格
考试结束*/

案例：当条件不成立时

int mark=59;
if(mark>=60){//59小于60则为false,跳过
System.out.println("分数是："+mark);
System.out.println("及格");
}
System.out.println("考试结束");
/*输出结果：
考试结束*/

案例：if后的大括号可以省去但只有后续的一句属于if。

int mark=59;//定义变量mark(分数)并赋初值59
if(mark>=60)//当mark的值大于等于60时执行下一句
System.out.println("分数是："+mark);//属于if
System.out.println("及格");//不属于if
System.out.println("考试结束");//不属于if
/*输出结果：
及格
考试结束*/

案例：如果if后的关系运算或逻辑运算结果为true时执行if后的语句，否则执行else后的语句。

itn mark =98;
if(mark>=60){//如果mark的值>=60则执行if后大括号中的语句，否则执行else后的语句
System.out.println("及格");
}else{
System.out.println("挂科");
}
/*输出结果：
及格*/

多重if案例：多重if用于实现多条件分支，从上到下判断条件，当为true时执行后续的代码块，都未找到合适的条件时执行else。

itn mark=78;
if(mark<60){//false不成立
System.out.println("挂科");
}else if(mark>60&&mark<=70){//false不成立
System.out.println("合格");
}else if(mark>70&&mark<=80){//true成立
System.out.println("良好");//执行
}esle{
System.out.println("优秀");
}
/*输出结果：
良好
注意：整个if代码块是互斥的，只有一个代码块会被选择执行，另外if可以多层嵌套在一起*/

 三目（元）运算：

int j =(i = = 1)?5:6;

switch语句：

int i = 2;
/*switch表达式后见面的数据类型只能是byte,short,char,int四种整形类型，枚举类型和java.lang.Stirng类型（从java 7才允许），不能是boolean类型*/
switch(i){
case 1://如果i的值为1
System.out.println("i等于1");
break;//跳出switch,如果不加则会贯穿到下一个case语句
case 2:
System.out.println("i等于2");
break;
case3:
System.out.println("i等于3")';
break;
default:
System.out.println("i不等于1,2,3");
}
//输出结果:i等于2

 while循环：

int i = 1;//定义循环变量i
while(i<=3)//当i<=3时成立执行循环体
{
    System.out.println("while 循环 i =" +i);
    i = i + 1;//将循环变量增大1
}
/*输出结果：
while 循环 i = 1
while 循环 i = 2
while 循环 i = 3
*/

do while循环：

do{
    System.out.println("do while 循环 j="+j);
    j++;//循环变量j自增1
}while（j<=3）;//当j<=3成立时循环继续，注意以分号结束

 while && do while 语法格式：

//while循环：
while(expression)
{
    body of loop
    }

/*expression:表达式
body of loop:循环体*/

//do while循环：
do{
    body of loop
}while(expression);

for循环：

/*int k=1为初始化循环，只执行1次，多个表达式时用逗号隔开，K<=3为循环条件，执行多次，只有这个表示式为真时才继续执行，
k++为修改循环变量，执行多次，当一次循环结束后会执行该表达式，多顶时用逗号隔开*/

for(int i=1; i<+=3; i++){
    System.out.println("for 循环 i="+i);
}

/*输出结果：
for 循环 i = 1
for 循环 i = 2
for 循环 i = 3*/

for循环语法格式：

//声明并初始化i  表达式为true时执行该循环  递增i
for(int i = 1; i<=3; i++)
{
    System.out.println("for循环 i="+i)
}

break&&continue的区别:

/*break语句是结束这次循环，不再执行该循环块，而continue语句的作用是中断当前的这次循环，继续后面的循环。*/

//break示例：

public static void main(String[] agrs)
{
    for(int i = 0; i<10;i++)
    if(i==3)
    {
    break;
    }
    System.out.println("i");
}
//输出结果：0、1、2

//continue示例：

public static void main(String[] agrs)
{
    for(int i = 0; i<10;i++)
    if(i==3)
    {
    continue;
    }
    System.out.println("i");
}
//输出结果：0、1、2、4、5、6、7、8、9

一维数组的定义：

数据类型  数组名称 [ ];

例子：

int [ ] a={1,2,3}; 第一钟方式，长度为3（因为我们初始化了3个值）

int [ ] b=new int [4]; 第二种方式，长度为4

int [ ] c=new int [4] {1,2,3,4}; 这两种形式的结合，数组长度必须和元素个数匹配

int [ ] d=new int [ ] {1,2,3,4,5,6,7} 初始化了元素，长度可以省略 

二维数组的定义：

类型 [ ] [ ] 数组名称;

多维数组的使用：

学生	第一次测试成绩	第二次测试成绩
Student1	75	80
Student2	80	90
Student3	70	60
Student4	85	95
Student5	90	100

int testScoreTable[ ] [ ] = new int [5][2];
//使用一维数组先前使用的技术来填充此数组。
//初始化第0列的所有数组元素
testScoreTable [0][0]=75;
testScoreTable [1][0]=80;
testScoreTable [2][0]=70;
testScoreTable [3][0]=85;
testScoreTable [4][0]=90;
//初始化第1列的所有数组元素
testScoreTable [0][1]=80;
testScoreTable [1][1]=90;
testScoreTable [2][1]=60;
testScoreTable [3][1]=95;
testScoreTable [4][1]=100;

 Scanner实现键盘输入：

import java.util.Scanner;    //导入Scanner类
public class Demo1{
public static void main(String[] args){
    //定义扫描盘，数据源为键盘
Scanner input=new Scanner(System.in);
System.out.print("姓名：");    //向控制台输出
String name=input.nextLine();    //输入字符将字符串赋值给name变量
System.out.print("身高：");
int height=input.nextInt();    //输入Int型
System.out.print("体重：");
double weight=input.nextDouble();    //输入double类型
System.out.println("姓名："+name+"，身高："+height+"cm,体重："+weight+"kg");
    }
}

String转换成基本数据类型：

Sring是一种非常常用的引用数据类型，他的转换可以通过包装类型实现，语法格式如下：

（1）转换成Int型

int/Integer num = Integer.parseInt(String str);

（2）转换成long型

Long/long num = Log.parseLong(String str);

（3）转换成short型

short/Short num = Short.parseShort(String str);

（4）转换成float型

floar/Floar num = Float.parseFloat(String str);

（5）转换成double型

double/Double num = Double.parseDouble("String str");

总结：数据类型 变量名 = 数据类型.parse(解析)要转换的数据类型

Sting str1="5",str2="true";
//将字符串类型的5转换成数字的5
int i=Integer.parseInt(Str1);
//将字符串类型的5转换成长整型的5
long j=Long.parseLong(Str1);
//将字符串类型的5转换成双精度数字的5
double d=Double.parseDouble(Str1);
//将字符串类型的true转换成布尔类型的true
boolean b=Boolean.parseBoolean(Str2);
//如果b为真则输出b+j+d的和，否则输出0.0
System.out.println(b?(i+j+d):0);
//输出结果：15.0

包装器类型：

java是一个面相度地下的编程语言，基本类型并不具备有对象的性质，为了人基本类型也有对象的特征，就出现了包装类型（如果我们在使用集合类型Collection时就一定哟啊使用包装类型而非基本类型），它相当于将基本类型“包装起来”，使得它具有了对象的性质，并且为其添加了属性和方法，丰富了基本类型的操作，8种基本数据类型对应的包装类型分别是：

基本类型	包装器类型
boolean	Boolean
cahr	Character
int	Integer
byte	Byte
short	Short
long	Long
float	Float
double	Double

 基本类型与包装类型可以相互转换，如下示例：

Character ch = new Character('x');
char c = ch;
char c = 'c';
Character ch = new Character(c);

基本类型与包装器类型存在一些区别：

1、声明方式不同，基本类型不用new关键字，而包装类型需要使用new关键字来在堆中分配存储空间；

2、存储方式及位置不同，基本类型是直接将变量值存储在堆栈中，而包装类型是将对象放在堆中，然后通过引用来使用：

3、初始值不同，基本类型的初始值如int为0，boolean为fasle,而包装类型的初始值为null

4、使用方式不同，基本类型直接赋值直接使用，而包装类型在集合如Collection、Map 时会使用到。

2、Java面向对象程序设计

面向对象的三个基本特征：封装、继承、多态

面向对象的三个优点：可复用、可维护、可扩展

面向对象的基本概念：

对象：S145是一个班级集体，肖商富是S145班的具体一个人，肖商富就是一个具体对象，李木炜、张健文，都可以看做是一个对象。

类：人是一个类，但人性别又分男、女，男可以看作是一个类，女可以看作一个类。

类与对象间的关系：

类是抽象的，是概念，是类型，是一类事物的统称，对象是具体的，特指的，是独一无二的，类是对象的类型，对象是类的实例。

 类的定义：

package 包名：

【访问修饰符】class  类名  extends  父类  implements 接口名{

成员变量；

构造方法；

成员方法；

}

package 用于定义包的关键字，类似文件夹，class是定义类的关键字。extends表示继承。implements表示实现接口。类的访问修饰符只有public 或默认，默认就是空的，作用范围是包级，public 是公有的意思表示访问不受限。

属性的定义：

[public | protected | ptivate] [static] [final] [transient] [volatile] type variableName;

static ：静态变量（类变量）；相当于实例变量：final：常量； transient：暂时性变量，用于对象存档；volatile：贡献变量，用于并发线程的共享

方法的定义：

[public | protected | private]  [static] [final | abstract] [native] [synchronized]
返回值类型 方法名（[参数列表]）{//方法声明
语句 //方法体
} 

类成员访问修饰符：

访问修饰符	访问级别	同类	同包不同类（不含子类）	同包子类	不同包不同类（不含子类）	不同包子类
public	公开	√	√	√	√	√
protected	受保护	√	√	√	×	√
没有	默认	√	√	√	×	×
private	私有		×	×	×	×

static：类方法，可以通过类名直接调用。  abstract：抽象方法，没有方法体。final：方法不能被重写。native：集成其他语言的代码。synchronized：控制多个并发线程的访问

类的封装：

package studnet;

public class hello {

    private String name;//姓名
    
    private int age;//年龄
    
    private char sex;//性别

    public String getName() {//读取姓名
        return name;
    }

    public void setName(String name) {//赋值姓名
        this.name = name;
    }

    public int getAge() {//读取年龄
        return age;
    }

    public void setAge(int age) {//读取年龄
        this.age = age;
    }

    public char getSex() {//读取性别
        return sex;
    }

    public void setSex(char sex) {//读取性别
        this.sex = sex;
    }
    
    
}

继承、多态：

calss /*类名*/ extends 父（基、超）类名称
super();

java重写基类中继承过来的方法，没有关键字只需在原方法体上改动就行

接口与抽象类

抽象类与接口的区别：

• 抽象类：abstract  接口：interface   （定义抽象类与定义接口的关键字）
• 子类继承抽象类与实现接口的关键字不一样： extends   implements
• 抽象类中可以有未实现的方法（抽象方法）也可以有已经实现的方法，而接口必须包含的是未实现的方法
• 子类必须全部重写父类或接口中未实现的方法（除法子类也是抽象类，可以不实现抽象方法，但接口中的方法必须要实现）

 　  相同点：抽象类与接口都不能被实例化；抽象类（类）只能单一继承，而接口可以多重继承

接口实际上是一个特殊的抽象类  接口中所有的方法都是公开抽象方法。 具体类实现接口必须重写接口中的所有方法  一个具体类只能extends一个抽象类，可以implements多个接口  

final:

• 类前：标记该类不能有子类；
• 方法前：标记该方法不能被重写；
• 变量前：标记该标识符为常量；

 java异常处理：

关键字：try(尝试)　　catch(抓住)　　finally(最后)　　

try注意事项：

• try   只有一个
• Finally   只有一个，或0个
• Catch   可以有0个（必须有一个Finally）,可以有多个

注：try只有一个，Catch可以有多个，也可以不要Catch，Finally只有一个，也可以不要Finally(Catch&&Finally至少得有一个和try组合)

异常处理语句组合：

try......Catch   ||   try......Finally   ||   try......Catch......Finally   ||   try......Catch......Catch     

引发异常格式：

throw   new  异常类（异常信息）

自定义异常类格式：

• 声明异常格式

class 自定义的异常类名：Exception{}

• 引发异常格式

 throw (自定义的异常类名);

异常机制是在程序出现错误时，程序该如何处理，它提供了程序退出的安全通道。不要应用异常处理机制来对付突然出现在程序中的所有错误。因为异常发生时，它会确认是什么异常类型，这通常要花费一定的时间，尽可能以编程的方式判断可能发生的错误或事件。

异常处理格式：

Try

{

 //程序代码块；

 //尽力执行该代码块，并捕捉可能发生的异常

}

catch（Exception e）

{

 //异常处理代码块；若异常不被处理，程序将会中止。

//一个try,可对应多个catch,异常处理机制会搜寻参数与异常类型相符的，进入那个catch从句。必须正确排列捕获异常的catch子句,范围小的Exception放在前面的catch。即如果Exception之间存在继承关系，就应把子类的Exception放在前面的catch子句中。

//若当前处理不了该异常，那么把它再抛出。也可在此再抛出异常，实现对错误的封装；

//没有表达式的throw(throw;)，将会再次抛出被catch捕捉到的异常。

//使用不带参数的catch子句，则可以捕获任意类型的异常

}

finally

{

 //存在于异常处理的标准事件流之外。

//用来清理资源或还原相关设置信息等其他操作

//是否发生异常，均要执行的代码块；

}

 

throw用于引发异常，可引发预定义异常和自定义异常。

如果方法遇到一个不知道如何处理的意外情况（abnormal condition），那么它应该抛出异常。throw语句无条件地把控制转移到别处，若有try{}catch{},它将转移到能处理这个异常的第一条catch子句。

 

在做异常处理的时候，最好能在应用程序所有的入口处（事件处理函数，主函数，线程入口）使用try-catch。但是不要在程序构造函数入口处添加try-catch，因为此处产生异常，它自己并没有能力来处理，因为它还没有构造完毕，只能再向外层抛出异常。要避免使用了try-catch但没有处理异常的情况，否则就相当于给异常放行。

 程序调试

• 设置断点
• 单步执行
• 观察变量

 输入输出流：

1）、：输入流：将文件或键盘中的信息调入内存

2）、：输出流：将内存中的信息保存到文件或者输出到外设（显示器、磁盘）

输入流：InputStream

输出流：OutputStream

字符流：Reader/Writer

2、文件对象

File对象:泛指文件或目录对象