java基础学习

 

第一章:开发简单java应用程序
1.java语言创始人 james Gosling
2.程序:指为了让计算机执行某些操作或解决某个问题而编写的一系列有序指令的集合.
3.java主要用于开发两类程序,桌面应用程序和interNET应用程序
4.开发一个java应用程序步骤:编写源程序，编译和运行，源程序以.java为后缀名，编译后生成的文件以.class为
后缀名
5.java的两种主要技术:javaSE(java platform Standard
Edition) –java平台标准版，javaEE(java platform en
Terprise edition) –java平台企业版
6.eclipse ,http://java.sun.com/javase/6/download/jsp
7.public class helloAccp{ //程序框架
Public static void main(string [] args) { //main方法框架
System.out,println(“”); //填写代码
}
}8.java程序注释有几种?
单行 //
多行 /* */
javaDoc注释/** */
=========☆★★java语言dos中的编译☆★☆★
首先要配置jdk环境,之后在右键我的电脑----选择高级----选择环境变量----打开系统环境变量----找到path属性
把jdk的物理路径复制到path的最前面(一般是D:/Program files/ jdk1.6.01/bin;注意必须加上/bin和;
然后用记事本编辑一段代码 切换到doc--输入cmd - cd.. 表示退回到上一级 cd 命令符 javac HelloWorld.java
java HelloWorld -----

======================================================================================
第二章 变量、数据类型和运算符
1.变量定义：a 是一个数据存储空间表示
B．是存储数据的一个基本单位
C. 不同变量，相互独立
2.java与c#使用变量步骤: a 声名变量， b对变量初始化
C调用变量
3.java与c#命名规则不同点 a java可以以$符号开头，但是c#不可以 b.c#是区分大小写的
相同点:变量必须以字母、下划线_开头，不能使用两者间的关键字，变量名也不能包含任何特殊字符
Eg：

合法变量名 非法变量名
_myCar *mycar
$myCar Variable%
Score1 9variable,a+b

Graph1_1 My Variable t1-2
4.java与c#命名方法
Camel(骆驼)命名法:第一个单词小写,其他单词首字母大写eg：myName,yourAge
Pascalcase 命名法:每个单词除第一个字母大写外,其他字母都使用小写
5.java中常用的数据类型int、double、char、String boolean 、c#中布尔类型是bool ,c#中string是小写的
6.数据类型转换
A自动数据类型转换条件(隐式转换):若一个操作数为double型,则整个表达式提升为double类型
两种类型兼容(int 、double)
目标类型大于源类型 eg就像水桶里的水可以倒入水缸里，小传大，编译自动运行eg1： byte value1 =10; byte value2=20; logC; C=value1 + value2 ;console.WriteLine(c) 分析这里log 型>byte型.当byte两者相加时,就不会出现数据丢失
相反: 显示转换 （大转到小）,编译运行时，会出现数据丢失
7．数据类型分为a 基本数据类型 (布尔,数值类型)-[定点类型【char,byte,short,int,long】[浮点类型] 【float，double】 b 引用数据(类，枚举，接口，数组)
8.java与c#表达式，运算符
1.算术运算符 + - * / % 2.关系运算符>< >=,<= == !=(不等于) 3.逻辑运算符&& ，|| !(非) 4.赋值运算符: = +=等
9.运算符优先级:括号(),[ ],一元运算符++,-- ！ 算术运算符，关系运算符，逻辑运算符条件运算符
10.控制流语句
If{ 语句块 }，if.....else if ....elseif
Switch ...case break , while ,do...while,for ,foreach
11.java中使用关系运算符可以用来比较大小，高低，多少等，比较后的结果是boolean类型，boolean初始值是 false
12.在java中，当条件判断为等值判断情况时,可以使用switch结构代替多重if结构，在使用switch结构时，不要
忘记每个case最后面写上’break‘
13while循环,是现判断，后执行，do.....while 是现执行，后判断，for循环用在循环次数已经确定的情况下，现执行初始化部分,在进行条件判断，然后执行循环体，最后进行迭代部分计算，while,do ...while 用在循环次数不确定的情况下
14.在循环中,结束和终止循环的执行，可以是break和continue .break是跳出整个循环，continue是跳出当前循环，继续下一个循环
15在使用eclipse进行调试时，步骤:设置断点，启动调试,单步执行f6，跟踪程序，观察变量

- ------- ------------- ------------------面向对象程序设计----------------------
对象是存在的具体实际，具有明确定义的状态(属性)和行为(方法)，对象表示现实世界中的实体
类是具有相同属性和共同行为的一组对象的集合，对象或者实体所拥有的特征在类中表示时称为类的属性，对象执行的操作称为类的方法。
对象的行为和属性被共同封装在类中。不可分割
java是一名面向对象的编程语言，(oop)
如何定义类 eg：public class 类名{
//定义属性部分
属性1类型 属性1 名字
属性2类型 属性2 名字
。。。。。。。。
属性n 类型 属性 n名字
//定义方法部分
方法1;
方法2;
方法n;
如何创建和使用对象
类名 对象名 = new 类名();
对象名.属性 //引用对象的属性 center.name =”北京中心”
对象名.方法名 //引用对象的方法 center.toString();
使用类的步骤,定义类，创建类对象，访问对象属性和方法
面向对象优点; a面向对象程序设计能够让我们使用类来模拟现实世界实体的特征和行为
B．对象的行为和属性被封装在类中，外界通过调用类的方法来获得。
C 可以通过类的模板，创建n个类的对象
引用数据类型，有方法，String s = new String(“accp“)
等价与 String s = “accp”
如何定义类的方法 （类的方法必须包括以下3部分 a方法的名称，方法返回值的类型，方法的主体）
语法:public 返回值类型 方法名(){
//方法主体
}
通常，在{}中编写方法的主体部分，另外在编写类的方法时要注意以下几点: （由一对大括号括起来的是方法体，它包含一段程序代码，执行时完成一定的工作, ?其次方法名主要调用方法时用，命名方法向命名变量，类一样，要遵循一定的规则，具体如下 必须以字母，下划线”_” 或$开头;
可以包括数字，但是不能以数字开头;方法就像个”黑匣子”
完成某个功能，并且可能执行完成返回一个结果。在方法的主体内，如果方法具有返回类型，则必须使用关键字return返回值。语法: 对象名.方法名

在编写方法时，一些常见的错误eg:
Public class Student{
Public int showInfo(){
int age =18;
int height =1.78;
return age, height;
}
} 点评，return 方法最多返回一个值，本题最佳答案是只能去掉其中的一个age或者height
public class AutoLion{
变量1类型 变量1;
变量2类型 变量2; — 类的属性(成员变量)
变量3类型 变量3;
Public 方法1(){
变量4类型 变量4; — 局部变量，方法1
}
Public 方法2(){
变量5类型 变量 5; - 局部变量，方法2
}
}
在类中定义的变量称为成员变量(变量1，变量2，变量3),在方法中定义的变量称为局部变量(变量4，变量5)
成员变量eg如上面的AutoLion类方法可以直接使用该类定义的成员bianl 。如果别的类的方法要访问它，必须首先创建该类的对象，然后才能通过点运算符来引用。
局部变量:它的作用仅仅定义在该变量方法中，因此只有在这个方法中能够使用它。
成员变量vs局部变量
作用域不同
初始值不同:对于成员变量，如果在类中没有给它赋初始值，java会给它一个默认值，但是java不会给局部变量赋初始值，因此在使用一个局部变量之前必须给它赋值，（即先声名后赋值）
常见错误2
Public class Test{
int score1 =88;
int score2 =98;
public void calcAvg(){
int avg =(score1+score2)/2;
}
Public void showAvg(){
System.out,println(“平均分是：“+avg);
点评:这段代码在编译是会报错。因为在showAvg（）中使用了在calcAvg中定义的变量avg,这就超出了avg的作用域了（前提是编写一个main方法来调用Student类的showAvg（）方法
常见错误3
Public class variableDomain1{
Public static void main (String[] args){
For(int i =0,a=0; i<4;i++) {
a++;
}
System.out.println(a);
}
}
点评: 这段代码运行时，又会报错，编译器会报错”无法解析a” 原因是a在for 循环块中定义的变量，因此只能在for
循环中使用，一旦退出循环。就不能在使用a 了，另外,在
While ,do..while ,if ,switch中定义的变量，作用域也仅仅是在这些控制流语句块内
在java中，如果eclipse导入了包,一些语句不能省略eg
import java.util。*;---------------------------------
public class HelloAccp2{
public static void main(String[] args) {
Scanner input = new Scanner(System.in);--------------
System.out.println(“成绩”)
Int score = input.nextInt();---------

12.创建包.包名要小写。导入包 inport 包名.类名;
13. ==================== 面向对象程序设计[oop]补充================================
类的定义格式:
[类修饰词列表] class 类名 [extends 父类名] [implements 接口名称列表]
{
类体
}
注: [] 表示被括起来的内容是可选的，即在类定义中可以不包括该选项
类修饰词列表可以包括0个或1个或多个类修辞词，类修饰词用来说明类的属性，包括public abstract、
final 和strictfp等 类修此词public 表示上面定义的的类可以被java的所有软件包使用。反过来，若
在类修饰表中不含public关键字，则上面定义的类只能在当前的软件包中使用，
2.另外在同一个java源问件中可以包含多个类，但不能包含两个或者2个以上的具有public修饰词的类
3. 在类体部分可以定义类的构造方法和类的两类成员要素（成员域field和成员方法method）


|||||成员域格式: [域修饰词列表] 类型 变量名或带初始化的变量名列表||||| eg: int m_radius =0 ,这里带初始化
的变量名实际上包含了赋值运算符即，等号的左侧是变量名，等号的右侧是一个表达式，该表达式的值将称为
等号左侧的变量的值
4[]中的内容是可选项， 类型可以是基本的或者是引用的，
5.另外如果含有多个变量名，则在相邻的变量名或带初始化的变量名之间用逗号隔开
6域修饰词通常包括(public、 protected 、private 、static、final、等，要注意的是public private
protected 这三个关键字不能同时存在，他们表示当前定义的成员域的访问控制属性，即当前定义的成员域的应用
范围
|||||| 类的成员方法简称方法 格式: [方法修饰词列表] 返回类型 方法名(方法的参数列表)
{
方法体

} ||||||
注释同上: [] 表示可选 返回类型可以是基本的或（引用的），方法名是一个合法的标识符，方法的参数列表可以包含
一个或0个或多个任何参数
在参数列表中，每个参数的格式是: 类型 参数变量名
eg : public int mb_method() {
方法体
}
public static void main(String[]args){
方法体
}
上面的这两个方法: 其中，关键字public 和static是方法修饰词 int ,void是返回类型，第一个成员方法不含任何参数
，第二个成员方法含有一个参数（args）args的类型是字符串(String)数组的类型
=================☆☆面向对象的java实现----封装----------☆☆☆==================
封装:就是将属性私有化,提供公有的方法访问私有属性
封装的实现（做法）:修改属性的可见性来限制对属性的访问，并为每一个属性创建一对取值(getter)和setter方法,
用于对这些属性的访问
封装作用:通过封装，可以实现对属性的数据访问限制，同时增强了程序的可维护性 -------祥列见(使用java实现面向对象编程p9页)
-------□°≯★★★何谓构造方法---------------★★★☆------------------------------
构造方法负责对象成员的初始化工作，为实列变量赋予合适的初始值（其实构造方法就是函数)
构造方法必须满足以下语法规则:
※ 方法名与类名相同
※没有返回类型
eg package s2java.sg.ch01 ; //声明包
public class AccpTeacher{ //I定义AccpTeacher类
private Sring name; // 姓名
/*
* 构造方法:为name 属性赋予默认值
*/
public AccpTeacher(){ //定义方法
name ="无名氏";
}
public String getName(){
return this.name;
}
}
eg1 使用new关键字实例化对象的过程实际上就是调用构造方法的过程
package s2java.sg.ch01;
public class AccpTeacherTest{
public static void main(String[] args){
AccpTeacher teacher = new AccpTeacher();
System.out.println("教员名称:"+teacher.getName());
}
}
===============▲▲▲带参数的构造方法=============================★★★
带参数的构造方法可以在构造方法中传递参数
eg
package s2java.sg.ch01;
public class AccpTeacher1{
private String name;
private int age;
private String education; //学历
private String position; //职位
/*
*带参数的构造方法
*/
public Accpteacher1(String name,int age ,String education,String position)
{
this.name =name;
this.age= age;
this.education =education;
this.position= position;
}
public String introduction(){
return "大家好!"我是"+name +",我今年"+age+"岁,学历"+education+",目前职位是"+position;

注:在使用带参数的构方法实例化对象时，传递的值和构造方法的参数应当在个数、次序和数据类型上互相匹配
eg2: package s2java.sg.ch01;
public class AccpTeacher1{
public static void main(String[]args){
AccpTeacher1 teacher = new AccpTeacher1("李芳",23，"本科","质询师");
System.out.println(teacher.introduction());
}
}
===========★★★★★ 方法重载☆☆☆☆☆===============================================
在java中,如果两个方法名称相同，但参数项不同，【返回类型不同】那么认为一个方法是另一个方法的重载方法，而此过程称为
方法重载,
eg
我们常常用到的System.out.println("我是中国人"); 中的println()方法
另在举一个典型的列子:
package s2java.sg.ch01;
public class AccpTeacer2{
private String name; //教员姓名
private String school ="北京中心";
public AccpTeacher2(Strng name){ //这里只有一个参数
this.name= name;
}
public AccpTeacher2(String name ,String school){ //这里定义了两个参数
this.name = name;
this.school = school;
}
public String introduction(){
return "大家好！"我是"+school+"的"+name;
}
}

测试类
package s2java.sg.ch01;
public class AccpTeacher2{
public static void main(String[]args){
AccpTeacher 2 teacher = new AccpTeacher2("李芳");
System.out.println(teacher.introduction());
AccpTeacher2 teacher1 = nw AccpTeacher2("张欣"，"北京中心");
System.out.println(teacher1.introduction());
}
}
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
继承:（如果两个类不在同一个继承树的分支上，就不会存在继承关系eg：兔子和老虎
继承特点:在继承关系中,父类更通用,（抽象）子类更具体，子类除了具有父类的一般特征外,还具有自己特殊的
特征和行为，另外在继承关系中，父类和子类要满足is-a的关系
继承优点(作用):可以有效实现代码的复用
方法重写(override)：子类和父类的方法具有相同名称，参数列表，返回类型，注！！！【在子类的构造方法中，通过
super关键字调用父类的构造方法 继承关键字（extends）

多态(polymorphism) 多态是具有表现多种形态的能力的特征，（同一个实现接口，使用不同的实例而执行不同的操作）
举一个列子:
package s2java.sg.ch02
public class HQ3{
/*
*对教员进行评估，评估内容：自我介绍、授课
*/
public void judge(AccpTeacher t){
t.introduction();
t.giveLesson();
}
/*
*使用main方法进行单元测试
*/
public static void main(String [] args){
HQ3 hq = new HQ3();
hq.judge(new AccpJavaTeacher2("黎明","北京中心"));
hq.judge(new AccpDotNetTeacher2("张明","上海中心");
hq.judge(new AccpDBTeacher("李兰","杭州中心"));
}
}
使用多态的优点(作用):不仅能减少编码的工作量,也能大大提高程序的可维护性和可扩展性
多态的实现步骤：（结合上面的代码）或者参考javaoop p40
子类重写父类的方法
把父类类型作为参数类型，该父类及子类对象作为参数传入
运行时.根据实际创建的对象类型动态决定使用哪个方法
================☆★☆★★面向对象的java实现--接口=========================★☆☆★☆
1.生活中的接口:(声卡，网卡，显卡）它们可以插在任意一个PCI插糟上，根本不用担心哪个PCI插糟是专门用来
插入那种卡的-------声卡，网卡，显卡它们内部结构各不相同，类似于java接口的具体实现
2 java接口注意事项：A java接口不能被实例化 B java接口中声明的成员自动设置为public【接口修饰词public表示
上面定义的接口具有公共的封装访问控制属性，可以被java的各个软件包使用】，另外接口一半不能具有private 、
protected等 C java接口不能出现方法体实现 D 如果要实现某个java接口,就必须实现其中定义的所有方法
eg：
案例: 为Accp各中心开发一个小的系统,包含类型为教员、中心、打印机，具体要求如下:
(1) 教员以及中心都具有方法: 输出详细信息(detail)
2 中心具有属性：打印机(printer),能够通过中心的打印机打印教员或者中心的详细信息
3
系统要具备良好的可扩展性和可维护性
-------------解题思路: 本题符合多态的条件:同一个实现接口,使用不同的实例而执行不同的操作
在本案中，教员类和中心类都需要实现各自的detail（输出详细信息）方法、detail显然是两个类都要实现同一个接口
，而教员和中心显然是两个不同的实例，通过执行各自的detail方法，实现不同的操作---由此
a 定义一个java接口 introduceable，在其中定义detail方法，但没有具体实现
b 教员类和中心类分别实现这个java接口,对detail方法具有各自不同的具体实现
c 在中心类的打印（print）方法中，接受java接口作为参数
-----------源代码如下--------
//定义一个java接口
package s2java.sg.ch03;
public interface introduceable{
public String detail();
} // 这里就是a的步骤，没有实现方法体
//教员类的实现代码
package s2java.sg.ch03;
public class AccpTeacher2 implements Introduceable{ //implements是实现接口的关键字
//输出教员的详细信息
public String detail(){
return "本人是Accp教员"
}
}
//打印机类的实现代码
package s2java.sg.ch03;
public class Printer{
public void print(String content){
System.out.println("开始打印");
System.out.println(content);
}
}
//中心类的实现代码
package s2java.sg.ch03;
public class AccpSchool2 implements Introduceable{
private Printer printer = new Printer();
//输出中心的详细信息
public String detail(){
return "这里是ACCP中心"
}
//使用中心打印机打印信息
public void print(Introduceable intro){
printer.print(intro.detail());
}
//测试
public static void main(String [] args){
AccpSchool2 school = new AccpSchool2();
school.print(new AccpTeacher2());
school.print(school);
}
}
控制台输出如下
开始打印:
本人是Accp教员
开始打印:
这里是ACCP中心

面向接口编程意味着:开发系统时，主题构架使用接口,接口构成系统的骨架，这样就可以通过更换实现接口的类来更换
系统的实现（面向接口可以实现接口和实现的分离）
=====================采用面向接口编程的方式实现分为3步骤
a 抽象出java接口
b 实现java接口
c 使用java接口
==============☆★1=-★★常量 ======================
常量: 是一种标识符，它的值在运行期间是恒定不变的
常量标识符在程序中只能被引用，而不能被重新赋值
eg
public final class Math{
//圆周率PI
public static final double PI=3.14159263512456;
//将angdeg角度转换为径度
public static double toRadians(double angdeg){
return angdeg/180.0*PI;
}
}
使用常量的优点:可以增强程序的可读性以及可维护性
在java中，在变量声明中加入final关键字代表常量，加入static 关键字代表类变量，一般情况下:我们把static和
final结合起来声明一个常量

另外如下两段代码是等价的
public interface AccpSchoolType{
String Accp ="Accp加盟中心";
String Benet="Benet直营重新";
}

public interface AccpSchoolType{
public static final String Accp ="Accp加盟中心"
public static final String Accp ="Benbet加盟中心"
}
=========☆★☆★☆☆使用异常处理程序错误============================☆★★≡☆★☆☆☆★
生活中的异常----小 王上下班，碰到堵车，等
程序中的异常: 指在程序的运行过程中,所发生的不正常的事件,会中断正在运行的程序(理解: 程序正在运行------
异常-------------------程序被中断---------处理异常 ------程序继续执行，直到执行完）

2.何谓异常处理:java编程语言使用异常处理机制为程序提供了错误(errorhanding)的能力，在java中，是通过5个关键字
try, catch (捕获),finally,throw (抛出).throws 下面分别解释下:
try :当某段代码在运行时可能产生异常的话，应该把这段代码放到try语句块中去

catch： 在catch语句中捕获异常，catch语句块的参数类似于方法的声明，包含一个异常类型和一个异常对象，异常类型
一般是java.lang.Exception类或者子类

finally：无论是否产生异常，finally所指定的代码都要被执行。通常在finally语句块中可以进行资源的清楚工作，
如关闭打开文件

throws：总是出现在方法的声明中，用来表明该方法可能抛出的各种异常

throw: 总是出现在方法体中，用来抛出一个异常

---try-catch块 语句分为三种情形: a 如果try中所有语句正常执行完毕，那么catch块中的所有语句都将被忽略

b. 如果try语句块在执行过程中碰到异常，并且这个异常与catch中声明的异常类型相匹配
那么在try块中其余剩下的代码都将被忽略,而相应的catch块将被执行

c.如果try语句块在执行过程中，碰到异常，而抛出的异常在catch块里面没有被声明
那么方法立刻退出
eg:实例
package s2java.sg.ch04;
import java.util.Scanner;
public class AccpException{
system.out.println("请输入课程代号（1~3之间的数字）:");
Scanner input = new Scanner(System.in);
try{
int courseCode = input.nextInt();
switch (courseCode){
case 1:
System.out.println("C#编程");
break;
case 2:
System.out.println("java编程");
break;
case 3:
System.out.println("sql基础");
}
}catch(Exception ex){
System.out.println("输入不为数字！");
ex.printStackTrace();
}
System.out.println("欢迎提出建议！");
}
}
本案中，如果在控制台输入2，try语句块代码将正常执行，因此catch语句块中代码被忽略

如果在控制台输入的是"A" 则在try语句块中的代码:int courseCode = inout.nextInt();将抛出InputMismatch
Exception类型的异常，由于抛出的这个异常是Exception的子类，所以程序将跳入catch语句块中

如果try语句块在执行过程中碰到异常，而抛出的异常在catch块里面没有被声明，那么方法立刻退出
在本案中，如果输入的是"A",抛出的是InputMismatchException类型的异常，由于这种类型的异常在catch块里面
没有被声明，程序将会中断运行不输出"欢迎提出建议！'

try-catch-finally块
还是举上面的列子;
如果try块中所有语句正常执行完毕，那么finally块就会被执行
在上面的这个案例中，如果我们在控制台输入的是2，则try块中的语句将被执行，finally块中的语句也被执行

如果try 块在执行过程中碰到异常，无论这种异常能否被catch块捕获到，都将执行finally块中的代码
（--------警察抓小偷，工资照常发——------）

多重catch块
一段代码可能会引发多种类型异常，这时会在try语句块后面跟随多个catch，
运行时，系统从上到下分别对每个catch语句块处理的异常类型进行检测，并执行第一个与异常类型匹配的catch语句
执行其中的一条语句后，其后的catch语句块将被忽略
注意:在多重catch块中,catch块的排列顺序必须是从特殊到一般,最后一个一般是Exception
======================================================================================================
抛出异常:在java语言中,使用throw关键字来抛出异常，抛出异常的原因在于:当前环境无法解决参数问题,因此通过抛出异常
把问题交割条用者去解决，接着在调用的地方捕获异常
案例:
//抛出异常
package s2java.sg.ch04;
public class AccpTeacher{
private String id;
public void setId(String PId){
//判断教员编号的长度是否为7
if（PId.length（）==7）{
id=PId;
}else{
throw new IllegalArgumentException("参数长度为7");
//Ill---这是一个异常类,这里抛出了异常
}
}
}
//捕获异常
package s2java.sg.ch04;
public classAccpTeacherTest{
public static void main(Sting[] args){
AccpTeacher teacher = new AccpTeacher();
try{
teacher.setId("088");
}catch(IllegaArgumentExpetion ex){ //这里捕获到了异常
System.out.println(ex.getMessage());
}
}
}
因此在本案中，从控制台输出的结果是:参数长度为7