Java逻辑课程总结10班

第一篇：Java逻辑课程总结10班

第一章

 开发java程序的步骤：编写源程序，编译源程序，运行（用记事本编写源程序，以.java为后缀名→javac，生成.class文件→java 输出结果）

 源文件：.java  生成后:.class  程序的入口为：main方法，一个程序只能有一个入口，但一个项目中可以添加多个入口

 C#的入口呢？

 基本的输出：System.out.println(“Hello world！”);

 注意：n t 的用法

以及print 与 println的区别

前者没有换行，后者有

相当于print(“n”); Java技术平台：JavaSe JavaEE  程序注释

多行注释/*注释内容*/ 单行注释

//注释内容 文档注释： /** 注释的内容 */(对应的C#注释又是如何的呢？) 代码规范

改缩进的要缩进，改换行的要换行 public 命名的类名，必须和源文件名相同 第二章

 变量的理解：

电脑是使用内存来记忆计算时所使用的数据 通过地址来找到对应数据的量，试想，每次申请的时候，地址都会发生变化，这样对开发是不是很不方便。所以我们用变量名，来代替实际的内存地址

例如，我们去住酒店

内存就像酒店

那变量的数据类型就像酒店里的房间类型，变量的名称 就相当于房间的名称

变量的值，就相当于房间里面住的客人

那我们通过变量名，就可以直接找到它所对应的值，就相当于，我们找到对应的房间名称，就可以找到该房间对应的客人 一样。

 变量命名规则：

首字母，以字母，’_’或者’$’开始，其余部分可以包含任意多的数字、字母、下划线或者$，但不能包含其他特殊符号

当然变量名不能包含java关键字（如int，main 等） 变量的数据类型：char 单个字符 如’男’

int 整数

如一天24小时

double 小数

1.3

String

字符串

“Hello World”

 变量的声明及使用

 第一步：声明变量，即“根据数据类型在内存申请空间” double money; 第二步：赋值，即“将数据存储至对应的内存空间” money=1000.0; 第三步：使用变量，即“取出数据使用 ”

System.out.println(money); 当然，第一步和第二步，可以一起，如double money=1000.0; 声明变量的同时，给其赋值  例题 







 public class TestType { public static void main(String[ ] args){ double score = 98.5;

String name = “张三”;char sex = '男';

System.out.println(“本次考试成绩最高分： ” + score);//+ 连接输出信息 System.out.println(“最高分得主： ” + name);System.out.println(“性别： ” + sex);} } 赋值运算符（=）语法：

变量名 = 表达式;（a =(b + 3)+(b – 1);） 意思是，将等号右边的值给等号左边的变量

 如：学员王浩的Java成绩是80分，学员张萌的Java成绩与王浩的相同，输出张萌的成绩

 int wangScore = 80;

//王浩成绩  int zhangScore;

//张萌成绩  zhangScore = wangScore;

 System.out.println(“张萌成绩是" +zhangScore);算术运算符(+-* / %) /：对于int类型的，若结果带有小数，则直接忽略小数点及后面的数 如 5/3=1（而不是1.。。）

 %:取模 就是取余数

如5%3=2 输入 导入import java.util.Scanner; Scanner input = new Scanner(System.in);//相当于，我们要接受键盘输入之前，先把键盘给准备好，接着，接收键盘输入  如： int a = input.netxInt();i++;i=i+1;

 i+=3;i=i+3; ++放在前面，是先执行++，后执行别相应的别的操作，++放后面相反

 如int a = i++;等价与int a=I;i++;两步  int a = ++I;则等价于 i=i+1;a=I; 一定要会转换

数据类型转换 ：①自动类型转换

②强制数据类型转换  对应的规则：如果一个操作数为double型，则整个表达式可提升为double型

如

3.2+3 它将自动提升到double类型；

 满足自动转换的条件(两种数据类型要兼容，目标类型大于原类

型)大杯子装小杯子  double 装int  ② 强制类型转换

（类型名）表达式

如int b =(int)9.8; 精度将会丢失，b=9，而不会是四舍五入

第三章

 掌握新数据类型 boolean 类型（true 或 false） 关系运算符（>,>=,<,<=,==,!=）注意 ==与=的区别，用在if条件中的是==  逻辑运算符（&& ,||,!）

 注意&&，||属于短路判断 假 条件  基本if选择结构

 语法结构： 真 if(条件){

代码块 //代码块 }  注意点：如果没有{}，则只有一条语句属于if语句  建议，即使只有一条语句，也不要省略{}  条件1 &&条件2 仅仅两个条件同时为真时，结果才为真

 条件1 || 条件2

只要两个条件中一个为真，结果为真 !条件

条件为真时，结果为假

 条件为假时，结果为真（即，反一反）

 运算符优先级：优先级顺序：！>算术运算符>比较运算符>&&>||  注意，当分不清优先级时，用()是明智之举

 if-else选择结构  语法结构： 假 条件 if(条件){

真 //代码块1

}else { 代码块2 代码块1 //代码块2

}

第四章

 重if选择结构

 语法结构： if(条件 1){

//代码块1

} else if(条件2){

//代码块2

} else {

//代码块3

} 注意：当连续判断时，条件的顺序不能乱，必须从小到大或者从大到小  嵌套if选择结构 if（条件1){ if（条件2){ 代码块1 } else { 代码块2 } } else { 代码块3 }

 switch选择结构 switch(表达式){

case 常量 1: 语句;break;

case 常量 2: 语句;break;…

default: 语句;}  注意点：区别于多重选择结构，它只能用于不连续的选择结构

 switch 后的表达式，一定得是int 或者char，其他类型不行  case 后，记得加上break  与c#有什么不同点呢？？

 hasNextInt()方法，可以判断用户从键盘输入的字符是否是合法的数字

第二篇：JAVA课程总结

DAY01

JavaSE第一天课程安排

##### 目标：开发第一个JAVA小程序，了解掌握相关概念

#####

内容：

1、了解计算机相关概念

2、下载安装Java开发环境

3、开发第一个Java程序

4、开发环境设置优化

5、掌握Java程序的开发运行流程

6、掌握Java相关概念

7、练习

#####----------------计算机相关概念----------------

1、计算机

1、机器

2、软件

3、数据输入----> 数据处理----> 数据输出-----（重要不紧急）

2、软件----

A、系统软件-----操作系统---windows linux B、应用软件-----QQ、CF、计算器（数据）软件的功能： 数据输入----> 数据处理----> 数据输出 数据-----123、文件、文件夹----泛称

3、计算机操作

物理操作 软件操作 GUI/CUI GUI-----图形用户接口-----Graphics User Interface(常用)CUI-----命令行用户接口---Command User Interface(了解)A、如何启动CUI

1、开始----> 附件-----> 命令提示符

2、开始----> 搜索CMD

3、win7----> shift 右击----> 打开命令行

B、DOS命令----CUI和GUI有对应关系

按规律记忆

电脑上数据分两类： 切换盘符：盘符号: 进入文件夹： cd 文件夹名

cd 路径名（进入多级）

返回上一级:cd..返回根目录:cd

1、文件

增

-----notepad/write/edit 查

-----type 文件名---查看内容 改

-----notepad/write/edit

删

-----del 文件名称

2、文件夹---dir

增----md XXX 查----dir--查看文件夹下所有文件

改----修改名称 ren 删----rd 要求：

1、简单调用----记住一个 help

2、调用 time date 等命令

3、命令如何使用--命令 /? DOS启动程序

1、DOS下进入程序所在路径

2、敲入程序名称

3、回车

需求：任意目录下启动程序，notepad可以，QQ不可以 edit cd cd..cd help 命令 /?----------不重要紧急

4、键盘使用------------重要不紧急

快捷键: 全选： ctrl + A

撤销： ctrl + Z 复制： ctrl + C 粘贴： ctrl + V 保存： ctrl + S------剪切： ctrl + X eclipse: ctrl + D----删除一整行

5、计算机语言

6、软件开发

使用计算机语言开发程序 学习计算机语言：语法

总结：了解-----

紧急-----常见的DOS命令

----------------下载安装Java开发环境----------

1、Java简介

A、詹姆斯 格斯林 B、开源----开放源代码 C、ONE体系

Open Net Environment----开放的网络环境

JavaSE-----桌面应用程序开发----核心----就业机会不多 JavaEE-----企业的分布式系统开发1）----（N从右向左数的位数）

4、负数的转换----（不不）

-10 0000 0000 概念：原反补

正数：源码反码补码都一样

负数：原码----标志位是1，计数位和正数一样

反码----计数位取反，1变0,0变1

补码----反码基础之上 +1 101 0111 1111 1111 1111 1111 1111 1111 1111----2^311 = 127 short-----2个字节16bit----最小值：-2^15=-32768 最大值：2^15* / %

++--（重点）DAY03 一.算数运算符：

1.+ 2.-

3.* 4./

/ 3 : 3 10 / 0 : 运行时异常；

10.0 / 0 :Infinity(无穷)不是异常

5.%

% 3 : 1 10 % 0 : 运行时异常

10.0 % 0 : NaN(Not A Number)不是异常-10 %-3 :-1 10 % 3 :1-10 % 3:-1 10 %-3:1 6.++: 7.--: 如果表达式中，只做++或--一件事情，那么前++/--和后++/--效果一样的； 但如果表达式中做多件事情：

前++/--:先自增/自减，然后再参与表达式的其它运算； 后++/--:先参与表达式的运算，然后在自增/自减；

二.赋值运算符

1.=：执行顺序，从右至左，并且最后返回变量； 2.+=： 3.-=： 4.*=： 5./=： 6.%=：

特点：带隐式强制转换；

byte b1 = 10;b1 = b1 + 20;//编译错误

b1 += 20;//OK的-->b1 =(byte)(b1 + 20);三.关系运算符：

1.==：判断是否相等 2.!=：判断是否不等；

3.<:左操作数是否小于右操作数； 4.>:左操作数是否大于右操作数；

5.<=:左操作数是否小于或者等于右操作数； 6.>=:左操作数是否大于或者等于右操作数；

四.逻辑运算符：

&&、||和&、|的区别：

1.逻辑&&和||具有短路行为，一旦确定整个表达式的结果，那么将不再执行剩余表达式； 1.&&(语意：并且):两边都为true，结果为：true； 2.||(语意：或者)：有一边为true，结果为true;3.!(语意：不是)：!true：false；!false:true 位运算符：

4.&(并且):结果同&& 5.|(或者):结果同|| DAY04 一.运算符：

1.位运算符：

1).<<(左移)： 2).>>(有符号右移):

3).>>>(无符号右移)4).&(按位与):两位都是1，结果为1； 5).|(按位或):有1位为1，结果为1；

6).^(按位异或):两位相同结果为0，否则为1； 7).~(取反):1变0，0变1 2.位运算符的考点：

1).高效的计算某数 * 2 : << 2).高效的计算某数 / 2 : >> 3).&、|同&&、||的区别： 逻辑与&&、||：具有短路行为；

4).将两个变量的值交换：三次异或；

3.三目运算符： 条件表达式 ？ 表达式1 ： 表达式2；

二.键盘录入：

步骤：

1.import java.util.Scanner;2.Scanner sc = new Scanner(System.in);3.int : int num = sc.nextInt();

double : double d = sc.nextDouble();

String : String s = sc.next();三.选择结构：

1.if语句：

1)格式1：

if(条件表达式){ } 注意：如果if体内只有一条语句，可以省略大括号，但不建议；

2)格式2：

if(条件表达式){ //为true，执行这里

}else{ } //为false，执行这里

3)格式3：

if(条件表达式){ }else if(条件表达式2){ }else if(条件表达式3){ }else{ } 2.switch语句：

1).格式：

switch(表达式）{

} case 值1: //代码 break;case 值2：

//代码 break;default: //代码 break;2).注意事项：

1.“表达式”可以产生的值：byte,short,int,char,枚举(JDK5以后),String(JDK7以后)2.case语句后跟“常量表达式”，不能是“变量”；而且不能出现相同的常量值；

3.break;语句“不是必须的”。如果不写，如果一旦case相应的值成功，但内部没有break语句，那么将会无条件(不再进行case匹配)的继续向下执行其它case中的语句，直到遇到break;语句

或者到达switch语句结束。4.多个case之间，没有顺序关系；

5.default语句“不是必须的”。可以不写，它就相当于多重if语句中最后的else。6.default语句和case语句“没有顺序关系”。

DAY05 一.while循环：

while(条件表达式){ } 二.do_while循环：

do{ }while(条件表达式);三.for循环：

for(定义循环变量表达式

;

条件表达式

;增量表达式){ } 说明：

1.三个表达式都不是必须的；但分号必须要写； 2.执行顺序：

1).定义循环变量表达式； 2).条件表达式;3).进入循环； 4).增量表达式； 5).条件表达式；

6).进入循环 7).增量表达式......四.三种循环的区别：

1.只有do_while循环是先无条件的进入循环体执行一次，然后再判断；

while和for循环都先判断，后进入循环体； 2.一般对于有明显的遍历范围的，建议首选for循环。

对于没有明显遍历范围的，一般使用while。

对于循环体中的内容，如果需要先执行一次，再判断，那么可以使用do_while DAY06 一.方法：

1.方法的作用：代码复用； 2.方法定义的格式：

修饰符 返回值类型 方法名([形参列表]){ } 修饰符：目前只需要写：public static 返回值类型：可以是任何的Java类型(基本数据类型、引用数据类型)。

如果没有返回值，这里要写void

方法名：自定义标识符；

形参列表：可以没有，但是一定写一对小括号。

如果有，每个形参是由：数据类型 形参名

多个形参，中间用逗号隔开；

3.方法内，可以写什么？

1).定义变量；

2).if语句，switch语句； 3).各种循环语句；

总之：除了不能定义方法，其它都可以； 4.方法的注意事项：

1).方法不调用不执行;2).方法与方法是平级关系，不能嵌套定义;3).方法定义的时候参数之间用逗号隔开;4).方法调用的时候不用在传递数据类型;5).如果方法有明确的返回值，一定要有return带回一个值;5.方法的重载：

1).在一个类中，可以定义多个同名的方法，但形参列表不能完全相同； 2).方法重载，跟返回值类型无关；跟形参名无关；

二.数组：

1.一维数组：

1).定义的格式：

1.动态初始化：数据类型[] 数组名 = new 数据类型[数组长度];2.静态初始化：

数据类型[] 数组名 = new 数据类型[]{值1，值2，值3，.....，值n};

数据类型[] 数组名 = {值1，值2，值3.....值n};2).数组是“引用数据类型”，变量存储的是“引用(地址)”；

3).当new(实例化)一个数组对象时，其“值”的空间是在堆中分配的，对于各种数据类型，都会分配一个

默认值：

整数：0 小数：0.0 字符：'u0000' 布尔：false String：null 其它引用类型：null 4).数组的访问方式：使用：数组名[索引] DAY07 一.二维数组：

1.定义的格式：

数据类型[][] 数组名 = new 数据类型[第一维的长度][第二维的长度];左边也可以写成：

数据类型 数组名[][] 数据类型[] 数组名[] 数据类型[][] 数组名 = new 数据类型[][]{{值1，值2},{值3，值4},{值5，值6，值7}};数据类型[][] 数组名 = {{值1，值2},{值3，值4},{值5，值6，值7}};二.方法的值传递和引用传递： 1.当一个方法接收的是一个“基本数据类型”时，调用方法传递实参时，是将“值”复制到方法内；

在方法内，如修改其值，修改的只是“副本”，原值不会被改变；

2.当一个方法接收的是一个“引用数据类型”是，调用方法传递实参时，是将“引用”复制到方法内；

在方法内，是可以通过这个引用修改“堆”空间的内容，即使方法结束，修改会影响到原堆中的值；

DAY08

一.类：是一组相关的“属性”和“行为”的集合；

对象：是该类事物的具体体现； 二.类和对象的关系：

1.现实：

类 对象 猫 波斯猫

折耳猫 加菲猫

---------

狗 金毛

藏獒 沙皮

2.代码：

类 对象

Cat c1 = new Cat();c1.name = “波斯猫”;class Cat{

}

String name;int age;c1.age = 2;

----Cat c2 = new Cat();c2.name = “折耳猫”;c2.age = 3;----------------------------class Dog{

}

Dog d1 = new Dog();d1.name = “金毛”;String name;int age;d1.age = 2;

----Dog d2 = new Dog();d2.name = “藏獒”;d2.age = 3;

三.类的定义：

1.使用关键字：class(注意小写)2.一个java源文件中：

1).如果定义多个类，但只有一个是public的；而且源文件名必须与这个public的类名一致； 2).如果定义多个类，可以没有public类；源文件名没有一致性要求；

3).main()方法不是必须放在public类中；

3.类中可以定义什么：

1).成员变量：

A.可以是基本数据类型，也可以是任何引用数据类型； B.可以显示初始化；

class Student{

} String name = “张三”;int age = 20;C.可以隐式初始化；

整型：0 浮点：0.0 字符：'u0000' 布尔：false 引用类型：null 2).成员方法： A.可以有参数，可以没参数；

可以有返回值，可以没有返回值；

B.方法的“形参”可以是任何Java类型(基本数据类型、引用数据类型)C.方法的“返回值”可以是任何Java类型(基本数据类型、引用数据类型)D.一个类中可以定义多个同名的方法，但形参列表不完全相同，叫：方法的重载；

3).内部类(后面讲)；

4.成员变量和局部变量的区别：

1).成员变量： A.定义在“类体”中；可以是任何数据类型；

B.会被自动初始化；

class Student{

} String name;void show(){ } System.out.println(“我叫：” + num);

//打印：我叫：null C.当实例化对象后，被存储在“堆”中；

D.当“对象”不被使用(没有任何引用)，并被垃圾回收器回收时被清理；

2).局部变量：

A.定义在某个方法、或其它代码块中； B.必须显示初始化，否则不能访问其值；

class Student{

void show(){ String name;System.out.println(“我叫：” + name);

//编译错误。局部变量必须显示初始化才能访问其值；

} } name = “张三”;//OK。可以被赋值。

C.当方法或其它代码块被执行时，基本数据类型的“值”和引用数据类型的“引用”都是存储在“栈”中； D.当方法或代码块执行完毕时，会被立即清理；

四.对象的使用：

1.创建对象使用new关键字；会在堆中分配内存空间； 格式：

类名

变量名 = new 类名();2.一个类可以创建多个对象；

3.每个“对象”的“成员变量”在“堆”中都有一份独立的空间；

每个“对象”的“成员方法”被存储在“方法区”中，多个对象只有一个“方法空间”； 4.对象的“引用(地址)”被存储在“栈”中；

五.方法的形参：

1.可以是“基本数据类型”：

1).调用时，必须传递此类型的“值”； 2).调用时，是将值复制一份到方法内部； 3).在方法内，使用形参接收此值的副本； 4).在方法内，如果更改此值，对原值没有影响；

int a = 10;show(a);System.out.println(a);//10---public void show(int n){//n = 10 } n = 20;//对原来的a的值是没有影响的；

2.可以是“引用数据类型”：

1).调用时，必须传递此类型的“引用”；

2).调用时，是将“引用(地址)”复制一份到方法内部； 3).在方法内，使用形参接收此“引用”的副本；

4).在方法内，如果通过此引用更改堆中的值，对原堆中的值将会产生影响；

int[] arr = {14,324,435};//arr = 0x2233 show(arr);//show(0x2233)System.out.println(arr[0]);//1000

----public void show(int[] array){//array = 0x2233 } array[0] = 1000;六.匿名对象：

1.匿名对象：没有名字的对象：new Student();2.匿名对象的两种使用情况：

1).对象调用方法仅仅一次的时候:new Student().show();2).作为实际参数传递:printStudent(new Student());七.封装：

1.直接对外部暴露成员变量是很不安全的，这时可以将成员变量“私有化”，对外提供公有的 get和set方法； 2.封装的好处：

1)隐藏实现细节，提供公共的访问方式 2)提高了代码的复用性 3)提高安全性。

3.封装的原则：

1)将不需要对外提供的内容都隐藏起来。2)把属性隐藏，提供公共方法对其访问。

八.private关键字：

1.是一种“访问修饰符”(将在day10讲到)；

Java中一共有四种访问修饰符：从宽到窄：public，protected，(默认)，private 2.用于修饰“成员变量”和“成员方法”；

3.被private修饰的成员，只能在类的内部被其它成员访问。在类外部无法访问；

九.this关键字： 1.每个类都有一个“隐式”的变量：this；

2.它是在实例化对象时，由虚拟机自动赋值的，会被自动赋值为当前对象的“引用”。

所以每个对象内的this变量的值是不同的；

3.this关键字可以调用本对象的“成员属性”、“成员方法”、“构造方法”； 4.以下情况必须显示的使用this：

1).“局部变量”覆盖“成员变量”时，可以使用this显示的访问被覆盖的“成员变量”；

否则访问的是“局部变量”；

2).在一个构造方法中调用本类的其它构造方法；this()或this(实参)；

DAY09

一.构造方法：

1.当实例化一个类的对象时，JVM会自动调用本类的一个方法：构造方法；

2.定义类时，可以不定义构造方法，编译器会自动添加一个无参，什么都不做的构造方法； 3.如果类中定义了构造方法，编译器就不会添加任何构造方法了； 4.构造方法的格式要求：

1).构造方法名必须与类名一致；

2).构造方法不能定义“返回值类型”，甚至是void；

3).构造方法不能返回一个具体的值，但内部可以使用return;语句； 注意：

1).以下代码可以编译通过：

class Student(){

} public void Student(){ }

//普通成员方法，不是构造方法；

2).以下代码不能通过编译：

class Student(){ public student(){ }

//构造方法必须同类名一致，包括大小写；

} 5.一个类中可以定义多个“构造方法”，但每个构造方法的形参列表不能完全相同，叫：构造方法的重载； 6.在一个构造方法中可以调用另一个构造方法，使用this关键字； 7.构造方法可以调用“成员方法”，但“成员方法”不能调用构造方法；

构造方法也可以调用其它构造方法；

二.static关键字：

1.static关键字：静态的，全局的。

2.可以修饰“成员变量”和“成员方法”。被static修饰的成员变量存储在方法区的“静态存储区”，只有

一份拷贝，被多个对象共享；

3.特点：

1).随着类的加载而加载

2).优先于对象存在3).被类的所有对象共享

4).可以通过类名调用，也可以通过对象名调用； 4.static关键字注意事项：

1).在静态方法中是没有this关键字的

2).静态方法只能访问静态的成员变量和静态的成员方法

三.静态变量和成员变量的区别：

1.所属不同

1).静态变量属于类，所以也称为为类变量

2).成员变量属于对象，所以也称为实例变量(对象变量)2.内存中位置不同

1).静态变量存储于方法区的静态区 2).成员变量存储于堆内存

3.内存出现时间不同 1).静态变量随着类的加载而加载，随着类的消失而消失

2).成员变量随着对象的创建而存在，随着对象的消失而消失

4.调用不同

1).静态变量可以通过类名调用，也可以通过对象调用 2).成员变量只能通过对象名调用

DAY10 一.代码块(理解)：

1.普通代码块(类体中)：包含：局部代码块(方法或其它代码块内)2.静态代码块：(类体中)作用：

1.初始化成员变量。执行流程：

1.普通构造代码块：每次实例化此类对象时，会被执行。它会先于“构造方法”被执行； 2.静态代码块：第一次实例化此类对象时； 3.静态代码块-->普通构造代码块-->构造方法：

二.继承(必须掌握)：

1.使用关键字:extends 2.作用：代码重用。为多态提供了前提； 3.this和super的区别：

1).this:

1).在任何类中使用； 2).存储的是本类对象的引用；

3).可以访问本对象的成员变量、成员方法、构造方法；

2).super:

1).在子类中使用；

2).存储的是父类对象的引用；

3).可以访问父类对象的成员变量、成员方法、构造方法；

4.类的初始化过程：

加载class文件 堆中开辟空间 变量的默认初始化 变量的显示初始化 构造代码块初始化 构造方法初始化

成员变量-->构造代码块-->构造方法 5.Java中继承的特点：

1).Java中只能单继承； 2).Java中可以多级继承；

6.继承的好处和弊端：

好处： 1).代码复用

2).为多态提供了前提； 弊端：

1).由于继承，子类对父类产生了依赖；

三.方法重写:

1.在子类中，定义跟父类一模一样的方法，这叫：方法重写； 2.重写的规则：

1).返回值类型、方法名、形参列表：要完全一致； 2).子类的访问修饰符可以跟父类的相同，或更宽；

3.重写的意义： 1).子类保留了父类的方法，具有了自己特有的行为；

4.重写和重载的区别： 1).重写：在子类中定义跟父类一模一样的方法；

2).重载：在一个类中，定义：方法名相同，参数列表不完全相同的方法，叫：重载。跟返回值类型无关；

四.final关键字：

1.可以修饰： 成员变量：表示其变量拥有最终的值，不能被更改，成为“常量”。修饰基本数据类型：表示其值不能被修改。修饰引用数据类型，表示地址不能被修改；

成员方法：表示最终的方法。不能被重写； 类：

表示最终类。不能被继承；

局部变量：表示其值不能改变；区分：基本类型和引用类型； 方法形参：表示其值不能改变；区分：基本类型和引用类型；

DAY11

一.多态：

1.父类的引用指向子类的对象； 2.多态前提和体现

1).有继承关系 2).有方法重写

3).有父类引用指向子类对象

3.多态的转型：

1).自动转型：子类的引用转为父类的引用；Person p = new Student();2).强制转型：父类的引用转为它所指向的子类对象的引用；Student stu =(Student)p;3).在进行强制转型前，为保证安全，可以使用instanceof关键字进行判断：

if(p instanceof Student){ } Student stu =(Student)p;4.多态的好处：

1).提高了程序的维护性(由继承保证)2).提高了程序的扩展性(由多态保证)

5.多态的弊端： 1).不能访问子类特有功能(可以向下转型)6.多态时的访问规则：

1).总体规则：访问的任何成员父类中必须要有，否则编译错误；

例如：

class A{ } class B extends A{ } main(){

} A a = new B();System.out.println(a.n);//编译错误，父类中没有n int n = 20;int num = 10;2).成员变量：如果子、父类中都有，访问的是“父类”的；

class A{ } class B extends A { } main(){

} A a = new B();//多态

System.out.println(a.num);//打印10；

int num = 20;int num = 10;

普通方法：如果子、父类中都有(重写)，访问的是“子类”的；

class A{

} class B extends A{

} main(){

} A a = new B();a.show();

//打印：B-->show()(访问的是子类的show());void show(){ } System.out.println(“B-->show()”);void show(){ } System.out.println(“A-->show()”);

静态方法：如果子、父类中都有(重写)，访问的是“父类”的；

二.抽象类：

1.使用abstract关键字修饰；可以修饰“类”，可以修饰“成员方法”；

abstract class A{ } abstract void show();2.“抽象类”的特点：

1).不能被实例化，只能用于被继承；

2).可以包含：成员变量、构造方法、成员方法、抽象方法； 3).可以不包含抽象方法；

3.“抽象方法”的特点：

1).没有方法体；abstract void show();2).必须被子类重写。除非子类也是个抽象类；

3.子类继承抽象类使用关键字：extends，仍然是单继承；

4.一个子类继承 了一个抽象类，必须实现抽象类中所有的抽象方法；

否则子类也必须是抽象的。

例如：

abstract class A{ } class B extends A{ }

//编译错误。类B不是抽象的，继承类抽象类必须重写抽象类中的所有abstract void show();抽象方法。abstract class B extends A{ } //编译通过。类B没有重写父类中的抽象方法，但类B是抽象的。

5.abstract关键字不能和哪些关键字共存：

1.private:抽象方法就是用来被子类重写的，而私有方法不能被子类重写；

2.final：抽象类和抽象方法就是用来被子类继承和重写的，而fianl类和final方法不能

被继承和重写； 3.static：static修饰的方法在没有任何对象的情况下就会被分配内存空间；而抽象方法

没有方法体，无法分配空间；

三.接口：

1.使用interface关键字定义：只能修饰“类”：

interface IA{ } 2.“接口”的特点：

1).不能被实例化，没有构造方法，只能用于子类“实现”； 2).可以包含：

A.成员变量(常量)：隐式的定义为：public static final。

例如： interface IA{

} public int num1 = 10;

//OK

上述三个关键字中任何一个都可以不写，系统会自动添加；

static final int num2 = 20;//OK final int num3 = 30;

//OK

//OK public final num4 = 40;int num5 = 50;

//OK B.抽象方法：隐式的定义为：public abstract。可以省略，系统会自动添加

例如： interface IA{

} void show1();

//OK

//OK;public void show2();abstract void show3();//OK;3).接口的功能是：扩展功能；

3.子类实现接口使用关键字：implements 4.一个子类可以同时实现多个接口；

interface IA{} interface IB{} class C implements IA,IB{ //OK的。} 5.子类实现接口时，必须重写接口中所有的抽象方法，而且必须是public的--因为

接口中抽象方法的定义隐式的是public的。

例如：

interface IA{ } class B implements IA{ void show(){ }

//编译错误。父接口的show()隐式的为public的，子类重写时void show();必须是public的；

} 5.接口编译后一样会生成.class文件。

四.多态的形式：

1.父类的多态； 2.抽象类多态； 3.接口多态；

五.类与类，类与接口，接口与接口的关系：

1.类与类：继承关系，关键字：extends，只能单继承，但是可以多层继承

2.类与接口：实现关系，关键字：implements，可以单实现，也可以多实现。还可以在继承一个类的同时实现多个接口

3.接口与接口：继承关系，关键字：extends，可以单继承，也可以多继承

例如：

interface IA{} interface IB{} interface IC extends IA,IB{} //OK的

六.抽象类和接口的区别：

1.成员区别 1).抽象类 变量,常量;有抽象方法;抽象方法,非抽象方法

七.2).接口 常量;抽象方法

2.关系区别

1).类与类 继承，单继承

2).类与接口 实现，单实现，多实现 3).接口与接口 继承，单继承，多继承

3.设计理念区别

1).抽象类 被继承体现的是：”is a”的关系。共性功能 2).接口 被实现体现的是：”like a”的关系。扩展功能

一.类名作为形参：

1.实参可以是：

1).此类对象的引用;2).null;3).此类子类对象的引用；

二.抽象类作为形参：

1.实参可以是：

1).此类子类对象的引用； 2).null;

三.接口作为形参：

1.实参可以是：

1).此接口子类对象的引用； 2).null;

四.类名作为返回值：

1.可以返回的类型：

1).此类对象的引用； 2).null;

3).此类子类对象的引用；

2.可以用什么类型接收：

1).使用此类类型；

2).不能使用某个子类类型接收；

五.抽象类作为返回值：

1.可以返回的类型：

1).null;2).此类子类对象的引用；

2.可以用什么类型接收：

1).使用此类类型；(多态)2).不能使用某个子类类型接收；

六.接口作为返回值：

1.可以返回的类型：

1).null;2).此接口子类对象的引用；

2.可以用什么类型接收：

1).使用此接口类型；(多态)2).不能使用某个子类类型接收；

DAY12

一.包：

1.定义包使用关键字：package；

1).注意事项：

A.package语句必须是程序的第一条可执行的代码 B.package语句在一个java文件中只能有一个 C.如果没有package，默认表示无包名

2.导入包使用关键字：import；

1).注意事项：

A.导入到最终的类；

B.可以使用通配符：*，只统配包下的类，不包括子包下的其它类； C.在一个类文件中，可以有多条import语句；

D.import语句必须在package语句之后，在定义类之前；

3.package,import,class有没有顺序关系？ 有：package-->import-->class 二.访问修饰符：

1.用于限定“类”和“成员”被其它包下的其它类访问的； 2.四种访问修饰符：

1).public(公有)：可以修饰类、成员。可以被任何包下的其它类访问； 2).protected(保护)：可以修饰成员。可以被同包下的其它类访问。如果在包外

只能被子类访问；

3).(默认)：可以修饰类、成员。只能被包内的其它类访问； 4).private(私有)：可以修饰成员。只能被类中的其它方法访问；

3.类及成员可用的修饰符：

1).类：

默认，public，final，abstract 我们自己定义：public居多

2).成员变量：

四种权限修饰符均可,final,static 我们自己定义：private居多

3).构造方法：

四种权限修饰符均可,其他不可 我们自己定义：public 居多

4).成员方法：

四种权限修饰符均可，fianl,static,abstract 我们自己定义：public居多

三.内部类：

1.成员内部类：

1).定义在类体中，作为类的成员；

2).可以使用同类“成员方法”相同的修饰符；

2.局部内部类：

1).定义在某个方法或代码块内部；

2).不能使用“访问修饰符”，不能使用static修饰符；可以使用final和abstract 3).注意：局部内部类访问“局部变量”，要求局部变量必须是final的(常量)；（重点）

3.匿名内部类：

1).就是内部类的简化写法。2).前提：存在一个类或者接口 这里的类可以是具体类也可以是抽象类。

3).格式： new 类名或者接口名(){重写方法;} 4).本质： 是一个继承了类或者实现了接口的子类匿名对象

DAY14 一.Object类：

1.所有引用数据类型(包括类库中的类，自定义类，数组)的超类； 2.定义在java.lang包，使用时不需要导包； 3.常用方法：

public class Object{ public Object(){

内存的操作；

} public int hashCode(){ //功能：用于哈希表结构的键值

//默认实现：将此对象的地址转换为int值返回；

//此方法建议子类重写；

} public final Class getClass(){ //功能：获取此对象的Class对象，在day27讲解

//此方法不能被子类重写 } public String toString(){ //功能：返回此对象的字符串表现形式；

//默认实现：全名限定的类名 + @ + hashCode(无意义)//此方法建议子类重写；

} public boolean equals(Object obj){ //功能：将当前对象与参数对象进行比较

//默认实现：比较地址(跟==的结果是一样的)//此方法建议子类重写；

} protected void finalize(){ //功能：当前对象在被垃圾回收器回收前，由垃圾回收器自动调用的方法。一般用于做些释放 //默认实现：无

//此方法根据需要由子类重写(一般我们不用)}

} protected Object clone(){

} //功能：复制此对象的副本； //默认实现：本地方法 //一般子类无需重写；

--

二.java.lang.String类：

1.一个“字符串”对象； 2.一个“引用数据类型”； 3.使用方式：

String s1 = “abc”;(常用、存储的是常量池中的地址)或：

String s1 = new String(“abc”);(存储的是堆中的地址)(在内存中创建了两个对象：1.常量池：“abc”；

class Student(extends Object){ } //默认就拥有了Object类中可以继承的方法；

2.堆：new String())

4.特点：其“值”的内容不能改变(地址可以改变)；

String str = “你好”;str = “Java”;//原值被丢弃，存储了新的地址；

5.常见面试题： String s1 = “abc”;

String s2 = “abc”;System.out.println(s1 == s2);//true--------

String s1 = “Hello”;String s2 = “World”;String s3 = “HelloWorld”;String s4 = “Hello” + “World”;String s5 = s1 + s2;String s6 = “Hello” + s2;String s7 = s1 + “World”;String s8 = new String(“Hello”);System.out.println(s3 == s4);//true System.out.println(s3 == s5);//false System.out.println(s3 == s6);//false System.out.println(s3 == s7);//false System.out.println(s1 == s8);//false;6.构造方法：

public String()：构造一个空字符串。效果同String str = “";public String(byte[] bytes):使用一个byte[]数组构造一个字符串；

public String(byte[] bytes,int offset,int length)：使用byte[]数组的一部分构造一个字符串； public String(char[] value)：使用一个字符数组构造一个字符串；

public String(char[] value,int offset,int count)：使用字符数组的一部分构造一个字符串； public String(String original)：使用一个字符串构造一个字符串；

7.常用方法：----注意：以下方法返回String的，都是生成一个新字符串，原字符串不变； 1).判断功能：

boolean equals(Object obj):重写父类的方法。与参数字符串比较，如果包含一样的字符序列则返回true，否则返回false;

boolean equalsIgnoreCase(String str):作用与equals()相同；但此方法不区分大小写； boolean contains(String str):判断是否包含参数字符串；

boolean startsWith(String str):判断字符串是否以参数字符串开头； boolean endsWith(String str):判断字符串是否以参数字符串结尾； boolean isEmpty():判断字符串是否是”空字符串“；

----

String s1 = ”“;String s2 = new String();String s3 = new String(”“);String s4 = null;String s5 = ”“;String s6;System.out.println(s1.isEmpty());System.out.println(s2.isEmpty());System.out.println(s3.isEmpty());// System.out.println(s4.isEmpty());

System.out.println(s1.equals(s2));System.out.println(s2.equals(s3));System.out.println(s3.equals(s1));System.out.println(s1 == s2);System.out.println(s2 == s3);System.out.println(s1 == s3);System.out.println(s1 == s5);

System.out.println(s4 == s6);-----2).获取功能：

int length()：获取此字符串内部的字符数量。(区分数组的length属性)char charAt(int index)：获取此字符串中index位置的字符char;int indexOf(int ch)：从左向右查找，获取字符ch在字符串中第一次出现的位置。如果不包含，则返回：false

int indexOf(String str)：获取字符串str在此字符串中第一次出现的位置。int indexOf(int ch,int fromIndex)：从fromIndex位置开始，查找字符ch。int indexOf(String str,int fromIndex)：从fromIndex位置开始，查找str。

String substring(int start)：从start(包含)开始，截取到此字符串的末尾；返回一个新字符串，原字符串不变； String substring(int start,int end)：从start(包含)到end(不包含)截取字符串；返回一个新字符串，原字符串不变；

3).转换功能：

byte[] getBytes()：将字符串转换为一个byte[]数组。char[] toCharArray()：将字符串转换为一个char[]数组；

static String valueOf(char[] chs)：静态方法，将一个char[]数组转换为一个String static String valueOf(int i)：静态方法，将一个int转换为一个String String toLowerCase()：转换为小写； String toUpperCase()：转换为大写；

String concat(String str)：将参数字符串添加到本字符串的末尾。

4).替换功能：

String replace(char old,char new)：使用new字符替换本字符串中的所有old字符； String replace(String old,String new)：使用new字符串替换本字符串中的所有old字符串；

5).其它功能：

String trim():去掉字符串两边的空格；不包括中间的。

int compareTo(String str)：重写Comparable接口的方法。按Unicode编码表的顺序与参数字符串比较；

System.out.println(”a“.compareTo(”b“));//-1 System.out.println(”a“.compareTo(”a“));//0 System.out.println(”b“.compareTo(”a“));//1 int compareToIgnoreCase(String str):不区分大小写的比较；

DAY15 一.StringBuffer类：

1.String的缓冲池类。

2.String和StringBuffer的区别：

1).String:其”值“不可变； 2).StringBuffer:其”值"可变；

当我们多次进行字符串的拼接等操作时，使用String会产生大量的垃圾空间。建议使用此类； 2.构造方法：

public StringBuffer()：初始容量16 public StringBuffer(int capacity)：初始容量capacity public StringBuffer(String str):使用String构造一个StringBuffer。

3.添加功能：

public StringBuffer append(String str)：及各种重载的方法。将任何类型的参数添加到末尾； public StringBuffer insert(int offset,String str)：将一个String插入到offset位置。原位置上的字符依次后移；

4.删除功能：

public StringBuffer deleteCharAt(int index)：删除index位置上的字符

public StringBuffer delete(int start,int end)：删除start到end-1处的所有字符；

5.替换功能： public StringBuffer replace(int start,int end,String str)：将start到end处的所有字符替换为str;6.反转功能： public StringBuffer reverse()：反转内部字符串；

7.截取功能：

public String substring(int start)：截取从start到结尾，返回一个新字符串； public String substring(int start,int end)：截取从start到end-1处的所有字符；

二.StringBuffer类和StringBuilder类的区别：

1.StringBuffer是线程安全的； 2.StringBuilder是线程不安全的；

三.Arrays类：

1.对数组操作的类，没有构造方法，内部包含了大量静态的工具方法； 2.常用方法：

1).public static String toString(int[] a)：将int[]数组转换为String的表示形式； 2).public static void sort(int[] a)：升序排序int[]数组；

3).public static int binarySearch(int[] a,int key)：二分查找int[]数组中的key值；

四.包装类：

基本数据类型 byte short int long char float 包装类型

Byte Short Integer

Long Character Float Double Boolean double boolean

第三篇：《Java程序设计》课程总结.

《Java程序设计》总评成绩分析及课程总结

1、学期授课计划是否符合教学大纲要求 符合。

2、教学内容及进度是否与学期授课计划有出入,是何原因 无出入,完成规定的学习内容。

3、作业计划、阶段测试计划、期末考试完成情况如何

顺利完成预定的作业计划及阶段测试计划。顺利完成期末考试。

4、总评成绩结果分析

因学生素质较高,在课堂表现、课程作品和答辩中整体表现良好,因此总评成绩整体较高,85分以上人数占24%,无不及格学生。

5、对本课程教学及存在问题有何改进意见和设想

在今后的教学过程中应该加强“项目导向,任务驱动”的教学手段的运用,同时应采取各种方法加强与学生的互动。在本课程中,我采用了多媒体网络教室、MindMapper、飞秋等软件辅助教学,以学生为主体,以项目为主线,学生的参与性非常高,效果很好,在今后的课程中我会继续加以实践和总结。

总结人:xxx 2009-1-9

第四篇：JAVA课程总结（xiexiebang推荐）

Java课程总结

第1章 Java语言概述

1.字节码是将Java源程序编译后得到的中间代码，它在某计算机平台上由平台相关的Java虚拟机解释执行，从而实现Java程序的平台无关性和可移植性。2．Java的特点

3.Java应用程序（2种），它们不同的结构特点及实现方式 第2-4章 1．

 标识符：以英文字母、下划线、$符号开始的字符序列，后面可以跟英文字母、下划线、$符号或数字。可以标识类、接口、对象、方法、变量、数组等等。标识符不能和Java保留字同名。 数据类型 a)简单类型 i.ii.iii.iv.整数类型：byte(1字节)、short(2字节)、int(4字节)、long(8字节)浮点类型：float(4字节)、double(8字节)字符类型(2字节)布尔类型(1位)b)复合类型 i.ii.iii.类 接口 数组

2．运算符和表达式 3．控制语句

第5章 类、对象、消息的基本概念，面向对象的基本特征。※※第6章 Java语言中的面向对象特征 要求：熟练掌握本章的内容 1.类

源程序中由若干个类组成，类是源程序的基本单元

方法重载：多个方法使用同一个名称，这些方法的返回类型必须相同，但是参数个数或类型不相同

构造方法：和类同名的、没有返回类型(不是void)的方法，修饰符可以是public或private。构造方法的主要作用是在对象实例化过程中初始化成员变量。this变量

2.对象：对象的创建、使用、删除。

包括对象间的赋值操作，对象的方法调用（不同的参数类型）。

3.包：

以package语句定义的类前缀，没有定义包名的类属于默认包。Package语句必须是源代码文件的第一个有效语句。使用非默认包中的类一般都用import语句。

4.面向对象特性：封装、继承和多态性

Java访问修饰符种类：public、private、protected 继承：用于继承父类的所有非private成员，语法上使用extends关键字 覆盖(重写)：在子类中重新定义父类的方法 5.其他：

①final关键字 ②static关键字

③java.lang.Object类

6.抽象类和接口

抽象类：以abstract修饰符修饰的类，这种类不能被直接实例化成对象，一般都包含0个或多个abstract方法。

接口：以interface定义的特殊抽象类，其所有成员变量都是abstract型方法，所有成员变量都是常量。第7章 数组和向量

数组的定义：不能直接指定元素个数，复合类型的数组变量必须逐元素初始化 当我们需要存储不定长数据时，可以用向量（java.util.Vector类的对象）来代替数组。

第8章 字符串：构造方法、常用的成员方法

 在Java语言中，字符串作为对象来处理，对应的类为java.lang包中的String和StringBuffer。

第10章 异常处理（大部分类在java.io包中）

重点掌握：几种主要的异常类；异常处理机制

异常处理2种方式（try-catch-finally、在方法声明后面使用throws子句抛弃异常）try-catch-finally语法格式为：

try{ 可能导致异常的代码 } catch(异常类型 变量){ [异常的处理代码] } [catch(异常类型 变量){ [异常的处理代码] }] [finally{ 有无异常，都需要执行的代码 }]

能看懂自定义异常、提交和处理异常的过程。

※第11章 输入输出处理（java.io包中）

 常见字节流类：InputStream、OutputStream、FileInputStream、FileOutputStream

 常见字符流：Reader、Writer、BufferedReader、BufferedWriter、InputStreamReader、OutputStreamWriter ※ ※第12章 图形用户界面设计

Java GUI的实现方式：AWT和Swing，要求：掌握界面元素添加、布局，事件处理，灵活运用java.awt包中的类，看懂例题并能熟练编写程序。

组件、容器和布局管理器的使用

事件及事件处理（java.awt.event包）

第12章 线程

一般掌握

线程实现的两种方式：继承Thread类或实现Runnable接口

第13章 Applet技术基础（java.applet包中）一般掌握

Java Applet程序的执行过程。

Java语言具有多媒体功能，支持图像、动画的显示和声音的播放。第15章 网络编程（java.net包）一般掌握 Socket通信、URL 掌握基本的通信过程，理解建立套接字、通过获得输入、输出流对象，进行通信的过程。URL：（统一资源定位地址)，是Internet中信息资源所在位置的一种表示方法 掌握，从网络下载资源的基本操作语句。

第五篇：JAVA程序设计课程总结

JAVA程序设计课程总结

专业：计算机科学与技术 学号： 姓名：

JAVA程序设计课程总结

经过一学期的java学习，我在老师的上课讲解以及自己的课下学习中对java编程有了一定的了解，我深深喜欢上了这种语言。培养了我正确应用面向对象的思维方法分析问题和解决问题的能力。

学习的内容主要分为以下几个部分：（1）java程序的编辑，编译，运行环境

（2）java语言程序设计中最基本的问题，即标识符，关键字，数据类型，常量，变量，表达式，声明语句，赋值语句，数据的输入与输出等。（3）流程控制语句，即分支语句，循环语句，转移语句。

（4）控制研究对象复杂性的原则，即分类，抽象，封装和继承，多态等。（5）数组的定义。（6）高级GUI组件的应用。

其中我对类与继承了解较多。一．类

在Java中，类文件是以.java为后缀的代码文件，在每个类文件中最多只许出现一个public类，当有public类的时候，类文件的名称必须和public类的名称相同，若不存在public，泽类文件的名称可以为任意的名称，但不能是数字开头的名称。在类内部对于成员变量，如果在定义的时候没有进行显示的赋值初始化，则java会保证类的每个成员变量都得到恰当的初始化：

1）对于char、short、byte、int、long、float、double等基本数据类型的变量来说会默认初始化为0，bolean变量默认会被初始化为false； 2）对于引用类型的变量，会默认初始化为null。

3）如果没有显示地定义构造器，则编译器会自动创建一个无参构造器，注意：如果显示地定义了构造器，编译器就不会自动添加构造器，所有的构造器默认为static的。

初始化顺序为：当程序执行时，需要生成某个类的对象，Java执行引擎会先检查是否加载了这个类，如果没有加载，则先执行类的加载再生成对象，如果已经加载，则直接生成对象。在类的加载过程中，类的static成员变量会被初始化，另外，如果类中有static语句块，则会执行static语句块。static成员变量和static语句块的执行顺序同代码中的顺序一致。在Java中，类是按需加载，只有当需要用到这个类的时候，才会加载这个类，并且只会加载一次。例如：

运行这段代码就会发现“欧阳”只会被打印一次。在生成对象的过程中，会先初始化对象的成员变量，然后再执行构造器。也就是说类中的变量会在任何方法调用之前得到初始化，即使变量散步于方法定义之间。

二．继承

在java中使用extends关键字来表示继承关系，当创建一个类时，总是在继承，如果没有明确指出要继承的类，就总是隐式的从根类Object进行继承。例如：

类Number继承于Student类，Student类称为父类（基类），Number类称为子类（导出类）。如果两个类存在继承关系，则子类会自动继承父类的方法和变量，在子类中可以调用父类的方法和变量。在java中，只允许单继承，也就是说 一个类最多只能显示地继承于一个父类。但是一个类却可以被多个类继承，也就是说一个类可以拥有多个子类。1.子类继承父类的成员变量

当子类继承了某个类之后，便可以使用父类中的成员变量，但是并不是完全继承父类的所有成员变量。具体的原则如下： 1）能够继承父类的public和protected成员变量；不能够继承父类的private成员变量； 2）对于父类的包访问权限成员变量，如果子类和父类在同一个包下，则子类能够继承；否则，子类不能够继承； 3）对于子类可以继承的父类成员变量，如果在子类中出现了同名称的成员变量，则会发生隐藏现象，即子类的成员变量会屏蔽掉父类的同名成员变量。如果要在子类中访问父类中同名成员变量，需要使用super关键字来进行引用。

2.子类继承父类的方法

子类也并不是完全继承父类的所有方法。1）能够继承父类的public和protected成员方法；不能够继承父类的private成员方法； 2）对于父类的包访问权限成员方法，如果子类和父类在同一个包下，则子类能够继承；否则，子类不能够继承；

3）对于子类可以继承的父类成员方法，如果在子类中出现了同名称的成员方法，则称为覆盖，即子类的成员方法会覆盖掉父类的同名成员方法。如果要在子类中访问父类中同名成员方法，需要使用super关键字来进行引用。

注意：隐藏是针对成员变量和静态方法的，而覆盖是针对普通方法的。

3.构造器

子类是不能够继承父类的构造器，如果父类的构造器都是带有参数的，则必须在子类的构造器中显示地通过super关键字调用父类的构造器并配以适当的参数列表。如果父类有无参构造器，则在子类的构造器中用super关键字调用父类构造器不是必须的，如果没有使用super关键字，系统会自动调用父类的无参构造器。例如：

这样的代码是没有问题的，如果把父类的无参构造器去掉，则下面的代码必然会出错：

改成下面这样就行了：

4.Super super主要有两种用法： 1）2）super.成员变量/super.成员方法;super(parameter1,parameter2....)第一种用法主要用来在子类中调用父类的同名成员变量或者方法；第二种主要用在子类的构造器中显示地调用父类的构造器，要注意的是，如果是用在子类构造器中，则必须是子类构造器的第一个语句。

以上就是我掌握较好的点，但是其中也有很多我没有考虑到的地方。很感谢老师陪我度过了一个愉快的学期，老师的教学方法(即实例与理论结合）也是我所认可的，能接受的，相信我在以后的工作生活中会越来越好。