Java学习资料，ppt,复习资料

Java入门

Java语言的特点：1.面向对象 2.可移植性好（Java虚拟机是一个想象中的机器，在实际的计算机上通过软件模拟来实现。） 3.垃圾回收机制 4.分布式 5.多线程。 ? 包的含义：它是一系列类和接口的集合。主要是解决同名类或接口之间的冲突，因为一个包中的符号名如类名，接口名等不能重名，但有了包后则不同的包之间可以允许有同名的符号出现；利用包还可以将不同的.class文件放臵在不同的文件目录下。

1.java.lang语言包，? 系统包：Java API就是系统为我们提供的若干包，常用的有：○2. java.util实用包，提供利用 Java 编程语言进行程序设计的基础类○包含集合框3.java.awt抽象窗口工具包，架、事件模型、日期和时间设施和各种实用工具类。○4java.text文本包，包含用于创建用户界面和绘制图形图像的所有类。○提供以与自5.java.io通过数然语言无关的方式来处理文本、日期、数字和消息的类和接口。○

6java.applet提供创建据流、序列化和文件系统提供系统输入和输出的文件包。○

7java.net为实现网络应用程序提供类。○8.javax.swingApplet应用程序所必需的类。○

提供一组?轻量级?（全部是Java语言）组件，尽量让这些组件在所有平台上的

9.javax.sql 为通过Java语言进行服务器端数据源访问和处工作方式都相同。○

10.javax.xml根据XML规范定义核心XML常量和功能。java包应该理提供API。○

是基本的Java技术，而javax是扩展的一部分。 ? 自定义包格式： package 包名；

? 如何引用包：可以在一个包中使用另一个包中所定义的类和接口，这可由import 语句来实现。（注意：如果引入的几个包中包括有名称相同的类，则当使用类时必须指明包含的包，以便编译器能正确区别它们）

基本语法

1 public class StaffInfo {

2 public static void main(String[] args) { 3 String name = \李丽\姓名，字符串变量 4 char sex = '女'; // 性别，字符变量 5 int age = 40; // 年龄，整型变量

boolean marital = true; // 婚否，布尔型变量

7double wage = 3565.85; // 工资，实型变量

8 System.out.println(\本公司工资最高的员工**\从控制台输出信息

数据类型 说明 整型 双精度实型 布尔型 举例 int double 用于存储整数，例如：数量、年龄 用于存储实数，例如：成绩、价格、工资 boolean 用于存储逻辑值，例如：婚否用true表示?是?、用false表示?char 字符型 字符串型 用于存储单个字符，例如：性别 String 用于存储一个字符串 ? 常量因其数据类型不同有不同的表示方法。

? （1）整型常量,即整数，可以有十进制、八进制、十六进制:十进制整数：只包含数码0~9:八进制整数：必须以数字0开头，只包含数码0~7:十六进制整数：必须以0X或0x开头，包含0~9，A~F或a~f.（2）实型常量:又叫浮点型常量，即实

数，是带有小数点的一类数据类型,占用存储空间为8个字节。实数只采用十进制形式，有两种表示方法：十进制小数形式和指数形式。（3）字符型常量。（4）字符串常量。（5）布尔型常量。

功 能 转义字符 转义字符 \\n \\f \\’ \\” \\\\ 功 能 \\r 表示接受键盘输入，作用等同于回车键 换行 \\b 退格，作用等同于Back Space键 换页 \\t 水平制表，作用等同于table键 单引号 \\ddd 1～3位八进制数所代表的字符 双引号 \\xhh 1～2位十六进制数所代表的字符 一个斜杠?\\” ? 变量代表的是内存中的一块空间，可以存放各种类型的数据，并且空间里存放的数据是可以改变的。（1）变量的声明与赋值：类型名 变量名;变量名 = 值;也可以在声明的同时给变量赋初值，定义形式为：类型名 变量名=变量值;（2）变量的命名规则：变量名的长度没有限制，但是变量必须以字母、下划线?_”或者?$”符开头。变量可以包括数字，但不能以数字开头。除了?_”或者?$”之外，变量名不能包含任何特殊字符。不能使用Java的关键字。

? 数据类型转换：（1）自动类型转换，自动类型转换需要满足以下两个条件：转换之前和转换之后的两种类型要兼容；转换后的要比转换前的数据类型的范围大。（2）强制类型转换，int sum; sum=(int)num1;//(int) num1能够把当前变量num1转换成括号中的数据类型int。

? 任务：从键盘输入王竹同学语文、数学、英语课的成绩，计算该生这三门课程的平均分，要求平均分为整数。

1import java.util.Scanner; //导入Scanner 2 public class Judgment {

3 public static void main(String[] args) {

4 intavg=0; // 平均分

5 Scanner input=new Scanner(System.in); // Java输入的一种方法 6

System.out.println(\请输入王竹同学的语文成绩:\提示输入语文成绩

7 int language=input.nextInt(); // 将值赋给语文成绩language 8

System.out.println(\请输入王竹同学的数学成绩:\ // 输入数学成绩

9 int math=input.nextInt(); // 将从键盘获得的值赋给数学成绩math 10 System.out.println(“请输入王竹同学的英语成绩:”); //输入英语成绩 11 intenglish=input.nextInt(); // 将从键盘获得的值赋给成绩english 12 avg =(int) (language + math + english) / 3; // 计算平均分 13 System.out.println(\王竹的平均分为\输出平均分

Scanner类：importjava.util.Scanner;Scanner input = new Scanner(System.in); int language= input.nextInt();

自增运算符的用法○

1a=i++; 等价于a=i; ○2 i=i+1; a=++i; 等价于i=i+1; 条件运算符：条件运算符是唯一的三元运算符，其格式为：表达式1？表达式式3

switch ( 表达式){ case 常量1： 语句1; break;

…… default: 语句n; break;

a=i; 2：表达 }注意：switch后面括号中表达式的类型只能是整型或字符型。 while(循环条件){ 循环操作； 改变循环变量值；

}

public class ShowInfo {

public static void main(String[] args) {

inti=1; //循环变量i赋初值

while(i<=1000) { //循环条件i<=1000成立，执行循环操作

System.out.println(\我爱Java!\ //循环操作 i++; //循环变量步进

}}}

万年历

1 import java.util.Scanner; 2 public class Calendar1 {

3 public static void main(String[] args) { 4

System.out.println(\欢迎使用********\输出信息

5 Scanner input = new Scanner(System.in); // 从键盘接收年份值，赋给year 6 System.out.print (\请选择年份：\7 int year = input.nextInt();

8

System.out.print(“请选择月份：?); // 增加月份值的输入

9 int month = input.nextInt(); 10 int days = 0; // 存储当月的天数 11 booleanrunNian; // 存储是否是闰年 12 // 判断是否是闰年 13

if (year % 4 == 0 && !(year % 100 == 0) || year % 400 == 0) {// 闰年的条件14true; // 条件表达式为真，是闰年

15 } 16

else {

runNian =

17 runNian = false; // 条件表达式为假，是平年 18

}

19 // 根据runNian的值，输出 20 21 22 23

if (runNian) {

System.out.println(year + \年闰年\} else {

24 System.out.println(year + \年平年\

/ 26 /* 计算当月的天数 */

/ / / / / / / / / / / / / / / / / / / / / /

27 switch (month) {

28 case 1: // 1、3、5、7、8、10、12这7个月的天数相同 29 case 3:

30 case 5:

31 case 7: 32 case 8: 33 case 10: 34 case 12:

35 days=31; 36 break; 37 case 2:

38 if (runNian) { // 2月的天数因平年或是闰年而不同 39 40 41 42 43 25 45 46 47

days = 29; } else { days = 28; } break; }44 default: days = 30; break; }

48 System.out.println(month + \月\\t共\天\

49 inttotalDays = 0; //totalDays输入年份之前的总天数 50 inti = 1;

51 while (i< year) { //使用循环累加从公元1年到（year-1）年的总天数 52 if (i % 4 == 0 && !(i % 100 == 0) || i % 400 == 0) { //判断是否为闰年

53 totalDays = totalDays + 366; //闰年366天 54 55

} else {

56 totalDays = totalDays + 365; //平年365天 57 } 58 i++; 59 }

60 System.out.println(year + \年之前的总天数：\天\61 intbeforeDays = 0; //year年中month月前几个月的天数 62 i = 1;

63 do { //从1月到（month-1）月的天数 64

switch (i) {

65 case 1: // 1、3、5、7、8、10、12这7个月的天数相同 66 67 68 69 70 71 72 73 74

case 3: case 5: case 7: case 8: case 10: case 12: days = 31; break; case 2:

if (runNian) { // 2月的天数因平年或是闰年而不同

75

76 days = 29; 77 } 78 else { 79 days = 28; 80 } 81 82 83 84

break;

default:

days = 30; break;

85 } 86 87

if (i< month) { beforeDays = beforeDays + days;

88 } 89 i++;

90 }while (i<= month);

91 totalDays = totalDays + beforeDays;

92 System.out.println(year+\年\月之前的总天数：\天\93 System.out.println(\当前月份的天数：\天\

94 /*存储当月第一天是星期几：0为星期日，1~6为星期一~星期六*/ 95 96 97 98 99 100 101 102 103 105 106

intfirstOfMonth = (1 + totalDays )% 7;

/* 输出日历 ‘\\t’是制表符，相当于table键*/

System.out.println(\星期日\\t星期一\\t星期二\\t星期三\\t星期四\\t星期五\\t星期六\ for (intnulNum = 0; nulNum

//该月第一天之前要输出的空格数，如果是星期五，前面要输出5个空格

System.out.print(\ //输出空格 }

for (int j = 1; j <= days; j++) { //在输完空格的位臵上输出本月的日历 System.out.print(j+ \ if ((totalDays + j) % 7 == 6) { // 如果当天为周六，输出换行

}

System.out.println();

? 107 }

?

? 根据学生的成绩，判定其优秀等级。

1 import java.util.Scanner; 2 public class CountGrade {

3 public static void main(String[] args) { 4 int score = 0; // 学生成绩 5 int num = 0; // 90分以上的科目数

6 Scanner input = new Scanner(System.in); 7 System.out.println(\请输入各门成绩：\8 for (int i = 0; i < 3; i++) { //统计90分以上的科目数 9 score = input.nextInt(); //接收数据 10 if (score < 60) { //成绩低于60分时 11 System.out.println(\别泄气，加油！\12 num = -1; // num臵为-113 break; //结束循环 14 } else if (score < 90) { // 90分以下的科目不计数 15 continue; //结束本次循环，不再执行循环体内下面的语句 16 17

} else {

num = num + 1; } //成绩>90，num加1

18 }

19 switch (num) { //根据num值判定等级 20 case 1:

21 System.out.print(\该生的优秀级别为：☆\22 break; 23 case 2:

24 System.out.print(\该生的优秀级别为：☆☆\25 break;26 case 3:

27 System.out.print(\该生的优秀级别为：☆☆☆\28 29 30 31

break; default: break; } }

32 }

保存程序为CountGrade.java，程序运行结果如下： 请输入各门课成绩：

96 75 56

别泄气，加油！

兔子生兔子

1 /** Fibonacci数列前20项的输出**/ 2 public class ArrayFibonacci {

3 public static void main(String args[]) { 4 5 6

int Fibonacci[]; // 声明一维数组 int i;

Fibonacci = new int[20]; // 创建一维数组

7 Fibonacci[0] = 1; 8 Fibonacci[1] = 1; 9

System.out.println(\数列前20项的输出--------\// 给数组元素赋值

10

11 for (i = 2; i < Fibonacci.length; i++)

12 Fibonacci[i] = Fibonacci[i - 1] + Fibonacci[i - 2]; 13 14 15 16 17 18 19

// 输出数组元素

for (i = 0; i < Fibonacci.length; i++) { System.out.print(Fibonacci[i] + \ if ((i + 1) % 5 == 0) System.out.println(\ } }

20 }

? 数组的概念：数组是常用的数据结构，数组用于将相同类型的若干变量按照有序的方式组织起来，数组中每一个变量称为数组元素，数组分为一维数组和多维数组。

声明：数据类型数组名[ ]；或者数据类型[ ] 数组名；例如int a[];float[] b; 创建：数组名=new 数据类型[数组长度]：例如a=new int[20]; 同时声明和创建int a[]=new int[20];

? 一维数组的初始化int[] a=new int[5];a[0]=1;或者int a[]={1,2,3,4,5}; ?

任务：有一个3×4的矩阵和一个4×3的矩阵，请求解两矩阵的乘积。

1 /** 矩阵的乘法**/

2 public class MatricesMultiplication { 3 public static void main(String args[]) { 4 // 创建二维数组并初始化 5 6 7 8 9

int a[][] = { { 1, 2, 3, 4 }, { 5, 6, 7, 8 }, { 9, 10, 11, 12 } }; int b[][] = { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 }, { 10, 11, 12 } }; // 创建存放结果矩阵的二维数组 int c[][] = new int[3][3]; int i, j, k;

10 System.out.println(\矩阵的乘积-----\

11 12 13 14 15 16 17 18 19 20 21 22

// 三重循环求矩阵乘积

for (i = 0; i < 3; i++) { for (j = 0; j < 3; j++) { c[i][j] = 0; for (k = 0; k < 4; k++) c[i][j] = c[i][j] + a[i][j] * b[i][j]; System.out.print(c[i][j] + \ } System.out.println(); } } }

? 任务：将10名学生的考试成绩进行从大到小的排序。（Arrays类的sort方法）

1 /**起泡排序**/

2 import java.util.*;

3 public class ArraySort1 {

4 public static void main(String args[]) { 5 float score[] = new float[10]; 6 int i, j;

7 float temp;

8 System.out.println(“请输入10名学生的考试成 9

Scanner in = new Scanner(System.in);

10 // 循环输入学生成绩 11 for (i = 0; i < score.length; i++) 12 score[i] = in.nextFloat(); 13 // 起泡排序法

14 for (i = 0; i < score.length - 1; i++) 15 for (j = 0; j < score.length - 1 - i; j++) 16 if (score[j] < score[j + 1]) {

17 18 19 20 temp = score[j]; score[j] = score[j + 1]; score[j + 1] = temp; }

21 System.out.println(\学生成绩排序-------------\22 //循环输出排序后数组元素 23 for (i = 0; i < score.length; i++) { 24 System.out.print(score[i] + \25 if ((i + 1) % 5 == 0) 26 System.out.println(); 27 } 28 } 29 }

排序的算法有很多种，可分为插入排序、快速排序、选择排序、归并排序、计数排序等几大类。

先将数组第1个元素和第2个元素进行比较，若发现逆序，则进行一次对调；接着再对第2个元素和第3个元素进行比较，若逆序，再交换……如此一直进行到第n-1个元素和第n个元素。此时数组中最大（小）的一个元素已经?沉底?。然后进行第二趟的相邻元素两两比较，直到次大（小）的元素放到倒数第2个元素的位臵上。如此循环往复，直到所有元素位臵均正确不需要交换为止。

Arrays类的sort方法

1 /** 使用Arrays类的sort()方法**/ 2 import java.util.*; 3 public class ArraySort2 { 4 public static void main(String args[]) { 5 6

float score[] = new float[10]; int i;

7 System.out.println(\请输入10名学生的考试成绩：\

8 Scanner in = new Scanner(System.in); 9

// 循环输入学生成绩

10 for (i = 0; i < score.length; i++) 11

score[i] = in.nextFloat();

12 Arrays.sort(score); // 使用Arrays类的sort()方法排序

13 System.out.println(\学生成绩排序-------------\14 // 逆序输出排序后数组元素 15 16 17 18 19 20 } 21 }

for (i = score.length - 1; i >= 0; i--) { System.out.print(score[i] + \if ((i + 1) % 6 == 0) }

System.out.println();

Arrays是java.util包中预定义的一个类，因此在使用时需要用import说明将其导入到程序中。Arrays类包含用来操作数组的各种方法，比如排序和搜索。Arrays类的sort方法是一个静态方法，所以可以不创建Arrays类的实例而直接使用类名来调用sort方法，其一般的调用格式为： Arrays.sort(数组名)

使用sort方法对数组进行排序，避免了在程序中用代码实现复杂的排序算法，其实sort方法中使用的就是一个经过调优的快速排序算法。sort方法是将数组中的元素按照升序进行排列，也就是从小到大的顺序进行排列。

判断回文字符串（字符串处理String类）

5 /**判断回文字符串**/

6 import java.util.*; 7 public class StringJudge { 8 9

public static void main(String args[]) {

String s; char c1, c2; int i, l;

10 11

12 boolean flag = true;

13 System.out.println(\请输入要判断的字符串：\14 Scanner in = new Scanner(System.in); 15 16

s = in.next(); l = s.length();

17 //取对应位臵字符进行比较 18

for (i = 0; i < l / 2;) {

19 c1 = s.charAt(i); 20 c2 = s.charAt(l - i - 1); 21 22 23 24 25 26 27

if (c1 == c2) }

i++; else { flag = false; break; }

28 System.out.println(\判断回文字符串-----\29 //根据flag的值进行判断

30 if (flag == true)

31 System.out.print(\所输入字符串是回文字符串\32

else

33 System.out.print(\所输入字符串不是回文字符串\34 35 }

}

? 字符串的查询和提取

String类中提供了很多对字符串进行查询和提取的方法，常用的有下列几种： （1）char charAt(int index)

该方法功能为返回当前字符串中指定索引处的字符，这个方法的返回值为char。 例如：String s=\

char c=s.charAt(1); //c的值为’e’ （2）int indexOf(int ch)

该方法功能为返回指定字符在当前字符串中第一次出现处的索引，如果指定字符没有出现在当前字符串中，则返回-1。 例如：String s=\int a=s.indexOf('o'); //a的值为4 int b=s.indexOf('g'); //b的值为-1

（3）int indexOf(String str)

该方法功能为返回指定子字符串在当前字符串中第一次出现处的索引，如果指定子字符串不在当前字符串中，则返回-1。 例如：String s=\int a=s.indexOf(\ //a的值为2 （4）int indexOf(String str, int fromIndex)

该方法功能为从指定的索引处开始，返回指定子字符串在当前字符串中第一次出现处的索引，参数fromIndex指定查询的起始位臵。

例如：String s=\

int a=s.indexOf(\ //a的值为7

（5）int length()

该方法功能为返回字符串的长度。

例如：String s=\

int a=s.length(); //a的值为11

（6）substring(int beginIndex)

该方法功能为返回一个新的字符串，它是当前字符串的一个子串，新字符串从参数beginIndex指定的位臵处开始，到当前字符串末尾结束。

例如：String s=\

String a=s.substring (6); //a的值为\

（7）substring(int beginIndex, int endIndex)

该方法功能为返回一个新字符串，它是当前字符串的一个子串，新字符串从参数 beginIndex指定的位臵开始, 到 endIndex-1处结束。

例如：String s=\

String a=s.substring (2,4); //a的值为\

6．字符串的比较

String类中提供如下方法对两个字符串进行比较 （1）boolean equals(Object anObject)

该方法将当前字符串与指定的anObject表示的字符串进行比较，并返回一个boolean类型的值。如果两者相同，返回值为true，否则返回值为false。

例如：String s1=\

String s2=\

boolean a=s1.equals (s2); //a的值为false

（2）boolean equalsIgnoreCase(String anotherString)

该方法将当前字符串与参数字符串进行比较，其用法与equals(Object anObject)方法基本相同，但是比较时不考虑大小写。

例如：String s1=\

String s2=\

boolean a=s1. equalsIgnoreCase (s2); //a的值为true

（3）int compareTo(String anotherString)

该方法按字典顺序比较两个字符串，并返回两者之间的差值。若当前字符串比参数字符串大，则返回正值；若比参数字符串小，则返回负值；若两者相等，则返回0。实际上，该方法的返回值为两个字符串从左向右依次比较每个字符时，第一对不同字符的unicode码的差值。

例如：String s1=\

String s2=\

int a=s1.compareTo (s2); //a的值为-3

但是要在使用中注意下例所示的情况。

String s1=\

String s2=\

int a=s1.compareTo (s2); //a的值为3，也就是两字符串长度之差

字符串的追加（字符串处理StringBuffer类）

1 /**字符串的追加**/ 2 import java.util.*; 3 public class StringAppend { 4 5 6 7 8 9

public static void main(String[] args) { StringBuffer varString = new StringBuffer(); String str1, str2;

System.out.println(\请输入字符串的初始内容：\Scanner in = new Scanner(System.in); str1 = in.next();

10 varString.append(str1);

11 System.out.println(\请输入要追加的内容：\12 str2 = in.next(); 13 varString.append(str2);

14 System.out.println(\字符串最终的内容为：\15 }

? 16 }

StringBuffer类也可以用来创建字符串对象，它与String类不同的是该类用于存放一个可变的字符串，当对字符串对象进行修改时，不会象String类一样创建新的字符串对象，而是直接修改原字符串。使用StringBuffer类创建的字符串对象，其实体的内存空间可以随着字符串的改变而自动改变大小。 ? StringBuffer对象的创建 （1）StringBuffer()

该方法创建一个空的StringBuffer类对象，系统为其分配的字符串缓冲区初始容量为16 个字符。 （2）StringBuffer(int size)

该方法创建一个StringBuffer类对象，系统为其分配的字符串缓冲区容量为size个字符。

（3）StringBuffer(String value)

该方法创建一个StringBuffer类对象，并将其内容初始化为指定字符串value的内容，系统为其分配的字符串缓冲区容量为指定字符串的长度再加上16个字符。

? StringBuffer类的常用方法 （1）append方法

append方法的功能就是将指定字符串追加到StringBuffer对象的后面，append提供了很多种重载的方法，下面只列出常用的几种：

StringBuffer append(boolean b) StringBuffer append(char c) StringBuffer append(int i) StringBuffer append(float f) StringBuffer append(string str)

10 public void introduction() {

11 System.out.println(\我的名字叫\12

System.out.println(\我的年龄是\岁\

13 }

14 public void eat() { 15

System.out.println(\每个人都要吃饭\

16 } 17 }

18 // 测试类，可以和Person类写在一个文件中，文件名和public类同名 19 class PersonTest {

20 public static void main(String args[]) { 21

Person p1 = new Person(\创建对象的同时，初始化 22 Person p2 = new Person(\

23 System.out.println(\24 System.out.println(p2.name + \25 p1.introduction(); 26 p2.eat();

27 } 28 }

保存程序为Person.java，编译后，运行PersonTest.class文件，程序运行结果为： p1's name is Jack.Steven is 21 years old.我的名字叫Jack。我的年龄是18岁。每个人都要吃饭

1.构造方法的名字与包含它的类相同，在语法上类似于一个方法。构造方法没有返回值，甚至连void修饰符都没有（因为它只是用来创建对象）。

作用：实现对象在实例化时的初始化（当对象在实例化时将自动地调用构造函数，实现对其成员数据赋初值）。如下列代码：

Rectangle rectA=new Rectangle();//对象在实例化时未初始化其属性 Rectangle rectA=new Rectangle(10,10,200,200);//对象在实例化时初始化其属性

2. 构造函数的可能形式

类中未定义出构造函数时，此时系统中会生成一个缺省形式的构造函数（函数体为空），对象在实例化时将不能进行初始化；

重载形式（定义出多个同名的构造函数时），从而可以在对象实例化时以多种方式初始化它，在讲解多态时给出例子。 3．this关键字的使用。

当方法内部定义的局部变量和成员变量同名时，如果要调用成员变量，就要用this。没有同名的状况发生就不需要用this。

完善Person类——带get和set方法（封装）

? 步骤1：在8.1Person类中修改属性为私有的，增加set和get方法 1 public class Person 2 {

3 private String name; // 定义人的姓名为私有的

4 private int age; // 定义人的年龄为私有的 5 // 类的构造方法，用于初始化成员变量 6 Person (String name,int age){ 7 this.name= name; 8

this.age= age;

9 }

a) public String getName() {

10 return name; 12 }

13 public void setName(String name) { 14 this.name = name; 15 }

16 public int getAge() { 17 return age; 18 }

19 public void setAge(int age) {

20 // setAge（）方法采取了保护措施，用户调用该方法时对年龄验证不会出现年龄为负数的情况 21 if(age<0){

22 System.out.println(\错误！年龄不能为负数!\23 }

24 else{ this.age = age;} 25 }

26 public void introduction () // 定义introduction ()方法 27 {// 略，与原代码一致 }

28 public void eat() // 定义eat ()方法 29 {// 略，与原代码一致 } 30 }

步骤2：在代码8.2中修改第7和8行代码

P1.setName(“Jack “); //测试类中通过调用setter方法，为对象的各个属性赋值 P1.setAge(18);

封装的概念

封装（encapsulation），即信息隐藏，封装的目的有： ? 隐藏类的实现细节，以防别人误用。 ? 迫使用户通过接口去访问数据。 ? 增强代码的可维护性。

使用get和set方法封装私有数据

? get和set方法一般是用来给类的成员变量赋值的，set表示设臵值，get表示获取值。由于类的成员变量一般会声明为private的，其他类是不能直接访问成员变量的，所以为了在类以外给该类的成员变量赋值或者取值，只有用声明为public的setXxx（）和getXxx（）方法来实现，这些方法可以对参数的数值进行安全检查。如果编写了一个原型类，又按照这种封装类的要求把它封装好了，这样的类就叫做Java的组件，即JavaBean。

? 3. 注意：setXxx（）和getXxx（）方法要按照规定命名，不能随意编写。方法前半部分必须是get

或set，后半部分是属性名，属性名首字母必须要大写。4．在MyEclipse中自动生成get和set方法在MyEclipse中先定义好字段后，在要写get和set方法的位臵单击鼠标右键，打开快捷菜单，选择?Source”——” Generate Getters and Setters”选项，可以根据选择自动生成这些方法。

? 自动统计人数（类成员）

1 public class Person_s { 2 3

private String name; // 实例变量，私有的 private int age; // 实例变量，私有的

4 static int count = 0; // 类变量 5 Person_s(String n, int a) { 6 7 8

name = n;

age = ((a > 0) & (a < 150)) ? a : 0; count++;

9 }

10 public static void print_count() // 类方法，只能访问类变量 11 { 12

System.out.println(\ \

13 } 14 15 16 17

public void print() // 实例方法 { // 可以访问类变量和实例变量 print_count(); // 调用类方法

System.out.println(name + \

18 } 19

public void finalize() // 析构方法

20 { 21

count--;

22 } 23 }

24 class Person_sTest {

25 public static void main(String args[]) { 26 Person_s p1 = new Person_s(\27 p1.print_count(); // 通过对象调用类方法 28 p1.print(); // 通过对象调用实例方法 29 Person_s p2 = new Person_s(\30

p2.print();

31 System.out.println(\共有 \个对象.\32

p1.finalize(); // 调用对象的析构方法

33 System.out.println(\调用析构方法后还有 \个对象.\

34 35 } 36 }

Person_s.print_count();// 通过类名调用类方法

? 程序结果 count=1 count=1 Jack is 21 years old. count=2 Tom is 18 years old. 共有 2个对象.

调用析构方法后还有 1个对象. count=1 ? 程序说明：

Person_s类中的变量name、age是实例变量，对于不同的对象p1和p2各有自己的值。所以程序的36行的执行结果是输出语句?Jack is 21 years old.”，程序的38行的执行结果是输出语句?Tom is 18 years old.” Person_s类中的变量count是类变量，系统运行时，只为该类的第一个对象p1分配内存单元，其后创建的对象p2共享一个count变量。所以在创建了对象p2后，count的值为2。但是，程序的第36行通过对象p1调用析构方法，count的值减1后为1。

? Java类就包括两种成员：实例成员和类成员。类成员也称为静态成员。使用static修饰的成员称为类成员。

类的成员变量有实例方法和类方法两种。没有static修饰的方法称为实例方法。实例方法体中既可以访问类变量，也可以访问实例变量，实例方法只能通过对象来调用。

用static修饰的方法称为类方法或静态方法。类方法体中只能访问类变量。类方法既可以通过对象来调用，也可以通过类名调用，如程序的第31行和37行。

在程序中也可以使用析构方法finalize()随时销毁对象。Java的每个类都有一个析构方法，用于将资源返回给系统。方法finalize()没有参数，也不返回值。

设计亚洲人的类（继承）

1 class Asian extends Person { 2 3 4 5 6

static String skinColor = \黄色\static String hairColor = \黑色\String country;

Asian(String name,int age,String country) {

7 super(name，age); 8 this. Country =country;

9 System.out.println(\调用了子类中的构造方法========\10 }

11 public void print() { 12

System.out.println(getName() + \，皮肤是:\的。\

13 System.out.println(getName() + \，头发是:\的。\14

System.out.println(getName() + \是:\人。\

15 } 16 }

17 public class Test { 18

public static void main(String args[]) {

19 Asian s = new Asian(\紫怡\中国\创建子类对象 20 s.introduction();// 调用父类的方法 21

s.print(); // 调用子类的方法

22 } 23 } 运行结果如下：

========调用了子类中的构造方法======== 我的名字叫紫怡 我的年龄是20岁 紫怡，皮肤是:黄色的。 紫怡，头发是:黑色的。 紫怡是:中国人。

继承：在已有类的基础上快速构造出新类的过程；派生：在构造新类的同时并新增新的特性的过程。

基（父）类：被继承特性的类；派生（子）类：在基类的基础上新创建出的类。 为什么要继承派生：实体（对象）之间不仅在横向方面具有关联特性，在纵向上也存在继承与派生的特性（遗传与变异）；如果编程时能充分利用此特性将可快速地构造出新类。

实现继承的格式为： class 子类名 extends 父类

子类中如何进行继承与派生父类（可以采用简单的比较法）。常用的手段有： 继承基类中的原始成员（当派生类中未定义出该成员时将自动采用继承）。 覆盖（重写或替换）父类中的成员方法：当父类中的某些成员方法不再适合子类的需要时，在子类中应重写出自己的成员方法。

扩充增强子类功能：当子类要求具有新的能时，应添加出该功能（增添新的成员）。代码8.6中print()方法是新增的功能。

1 class Father // 父类 2 {

3 4 5

public int f = 5; int Move(int x) {

return 65 + x;

6 } 7 } 8

9 class Fils extends Father // 子类 10 {

11 public int boy = 6; 12 int FilsMove(int x) { 13 14

}

return 165 + x;

15 }

16 public class fatherFils // 应用类 17 { 18 19

public static void main(String[] args) {

Father s = new Fils(); // 父类可以用子类实例化，因为子类包含了父类的内容 System.out.println(s.Move(55));

// System.out.println(s.FilsMove(55)); //子类的东西是不能直接用的，所以这样写不可以的 System.out.println(((Fils) s).FilsMove(55)); //父类想用子类的东西可用强制数据类型转换 // Fils s1=new Father(); //子类用父类来实现是错误的 Father s2 = new Father();

20 21

22 23 24

25 Fils s3 = new Fils(); 26

s2.f = 777;

27 28 29 30 31 32 33 } 34 }

s3.boy = 88; s3.f = 999;

s2 = s3; // 子类可以赋值给父类，比如

// 当然，一般来说，子类的boy数据在父类是不能直接看到了 System.out.println(s2.f);

System.out.println(((Fils) s2).boy);// 要显示boy数据，可以使用强制数据类型转换

说明：强制数据类型转换，可以在父子关系中应用，但主要用于父类转成子类，因为子类包含着父类的内容，所以子转成父的转换是没必要的。

子类对父类方法的重写（方法的重写）

1 class Person{ 2

。。。。。。

3 // 略，与原代码一致

4 public void eat() // 父类定义的eat()方法 5 { 6

System.out.println(\每个人都要吃饭\

7 } 8 }

9 class Chinese extends Person{ 10 String province;

11 public Chinese(String name,int age,String province) 12 {

13 super(name,age); // 直接指明调用父类中有两个参数的构造方法

14 this.setProvince (province); 15 } 16 17 18

public void setProvince(String province){ this. province = province; }

19 public String getProvince (){ 20 21

}

return this. province ;

22 public void eat() // 重写了父类的eat ()方法 23 {

24 System.out.println(\中国人喜欢吃中餐\25 } 26 }

27 public class ChineseTest{

28 public static void main (String[] args){

29 Chinese liming=new Chinese(\黎明\山西省\30 Chinese lisi=new Chinese(\李四\山东省\31 liming.eat(); // 调用子类的成员方法 32 liming.introduction ();// 调用父类的成员方法 33 lisi.eat(); // 调用子类的eat()方法 34 super.eat(); // 调用父类的eat()方法 35 } 36 } this引用

Java中，每个对象都具有对其自身引用的访问权，成为this引用。this引用是作为非static方法调用中的隐含参数传送到对象中的。使用规则如下： （1）指代对象本身，格式：this

例如：下面的方法比较两个对象obj1、obj2是否相等。其中obj2对象通过参数传递值，obj1对象是隐藏的。在方法中，通过this引用，指代调用本方法的当前对象。

void equals(Object obj2) {

Object obj1=this; //this指调用本方法的当前对象 }

（2）访问本类的成员变量和成员方法，格式为： this.<变量名> this.<方法名>

例如下面代码中，类A中有成员变量i，而在方法m中也用i作为参数。在m的方法中容易混淆两个i，此时必须要用this.i指代对象自己的成员变量i。 class A { int i ; void m(int i) {

this.i=2*i ; //this.i中的i指成员变量i，表达式中的i指参数i } }

? super引用

在上面的实例中，实际上在子类的构造方法中调用了一个super（）的方法。该方法表示调用父类（即超类）的构造方法。

如果子类中定义的成员变量和父类中的成员变量同名时，则父类中的成员变量不能被继承，此时称子类的成员变量隐藏了父类的成员变量。当子类中定义了一个方法，并且这个方法的名字，返回类型，用参数个数和类型和父类的某个方法完全相同时，父类的这个方法将被隐藏，既不能被子类继承下来。如果我们在子类中想使用被子类隐藏的父类的成员变量或方法就可以使用关键字super。使用关键字super，可以引用被子类隐藏的父类的成员变量和成员方法，成为super引用，引用规则如下：

1）被子类隐藏的父类的成员变量和成员方法，格式为： super.<变量名> super.<方法名>

（2）调用父类的构造方法

例8.2使用super调用父类的构造方法

子类不能继承父类的构造方法。因此，子类如果想使用父类的构造方法，必须在子类的构造方法中使用，并且必须使用关键字super来表示。而且super必须是子类构造方法中的头一条语句。代码如下：

本文来源：https://www.bwwdw.com/article/gzj5.html