文章目录
- Java程序设计基础(第5版)
- 第1章 Java语言概述
- 1.1 Java语言的诞生与发展
- 1.2 Java语言的特点
- 1.3 Java技术简介
- 1.4 Java虚拟机(JVM)
- 1.5 Java程序种类和结构
- 习题1
- 第2章 Java语言开发环境
- 2.1 Java开发工具(JDK)
- 2.2 JDK帮助文档下载与安装
- 2.3 JDK的使用
- 习题2
- 第3章 Java语言基础
- 3.1数据类型
- 3.2 关键字与标识符
- 3.3 常量
- 3.4 变量
- 3.5 数据类型转换
- 3.6 由键盘输入数据(Scanner)
- 3.7 运算符与表达式
- 3.7.1 算术运算符
- 3.7.2 关系运算符
- 3.7.3 逻辑运算符
- 3.7.4 位运算符(二进制)
- 3.7.5 赋值运算符
- 3.7.6 条件运算符
- 3.7.7 字符串运算符
- 3.7.8 表达式及运算符的优先级、结合性
- 习题3
- 第4章 流程控制
- 4.1 语句和复合语句
- 4.2 顺序结构
- 4.3 分支结构
- 4.3.1 if条件语句
- 4.3.2 switch选择语句
- 4.4 循环结构
- 习题4
- 第5章 数组与字符串
- 5.1 数组的基本概念
- 5.2 一维数组
- 5.3 foreach语句与数组
- 5.4 多维数组
- 5.5字符串
- 5.5.1 字符串变量创建
- 5.5.2 String类常用方法(字符串变量名.方法名())
- 习题5
- 第6章 类和对象
- 6.1 类的基本概念
- 6.2 定义类
- 6.3 对象的创建与使用
- 6.3.1 创建对象
- 6.4 参数的传递
- 6.4.1 以变量为参数调用方法
- 6.4.2 以数组作为参数或返回值的方法调用
- 6.5 匿名对象
- 习题6
- 第7章 Java语言类的特性
- 7.1 类的私有成员与公共成员
- 7.1.1 私有成员(private)
- 7.1.2 公共成员(public)
- 7.1.3 缺省访问控制符
- 7.2 方法重载
- 7.3 构造方法
- 7.3.1 构造方法的作用与定义
- 7.3.2 默认构造方法(javac生成默认构造方法并默认调用)
- 7.3.3 构造方法的重载
- 7.3.4 构造方法调用构造方法(by this)
- 7.4 静态成员(static)
- 7.4.1 实例成员
- 7.4.2 静态变量
- 7.4.3 静态方法
- 7.4.4 静态初始化器
- 7.5 对象的应用
- 7.5.1 对象的赋值与比较
- 7.5.2 引用变量作为方法的返回值 ？
- 7.5.3 类类型的数组
- 习题7
- 第八章 继承、抽象类和接口
- 8.1 类的继承
- 8.1.1 子类的创建
- 8.1.2 在子类中访问父类的成员
- 8.1.3 覆盖/方法重写
- 8.1.4 不可被继承的成员和最终类(final)
- 8.1.5 Object类(万类之祖)
- 8.2 抽象类
- 8.2.1 抽象类与抽象方法
- 8.2.2 抽象类的应用
- 8.3 接口
- 8.3.1 接口的定义
- 8.3.2 接口的实现与引用
- 8.3.3 接口的继承
- 8.4 内部类与匿名内部类
- 8.4.1 内部类
- 8.4.2 匿名内部类
- 8.5 包
- 8.6 Java语言的垃圾回收
- 习题8
- 第9章 异常处理
- 9.1 异常处理的基本概念
- 9.1.1 错误与异常
- 9.1.2 Java语言的异常处理机制
- 9.2 异常处理类
- 9.3 异常的处理
- 9.4 抛出异常
- 9.5 自定义异常类
- 习题9
- 第10章 Java语言的输入输出与文件处理
- 10.1 Java语言的输入输出库(java.io)
- 10.1.1 流的概念
- 10.1.2 输入输出流类库
- 10.2 使用InputStream和OutputStream流类
- 10.2.1 基本的输入输出流
- 10.2.2 输入输出流的应用
- 10.3 Reader和Writer流类
- 10.3.1 使用FileReader类读取文件
- 10.3.2 使用FileWriter类读取文件
- 10.3.3 使用BufferedReader(缓存区内)类读取文件
- 10.3.3 使用BufferedReader类写入文件
- 10.4 文件的处理与随机访问
- 10.4.1 Java语言对文件与文件夹的管理
- 10.4.2 对文件的随机访问
- 习题10
- 第11章 多线程
- 11.1 线程的概念
- 11.1.1 程序、进程、多任务与线程
- 11.1.2 线程的状态与生命周期
- 11.1.3 线程的调度与优先级
- 11.2 Java的Thread线程类与Runnable接口
- 11.2.1 利用Thread类的子类来创建线程
- 11.2.2 利用Runnable接口来创建线程
- 11.2.3 线程间的数据共享
- 11.3 多线程的同步控制（Synchronized）
- 11.4 线程之间的通信
- 习题11
- 第12章 泛型与容器类
- 12.1 泛型
- 12.1.1 泛型的概念
- 12.1.2 泛型类及其应用
- 12.1.3 泛型方法
- 12.1.4 限制泛型的可用类型
- 12.1.5 泛型的类型通配符和泛型数组的应用
- 12.2 容器类
- 12.2.1 Java容器框架
- 12.2.2 Collection接口
- 12.2.3 列表接口List
- 12.2.4 集合接口Set
- 12.2.5 映射接口Map
- 习题12
- 第13章
- 13.1 图形用户界面概述
- 13.2 图形用户界面工具包——Swing
- 13.2.1 Swing组件分类
- 13.3 创建组件
- 13.3.1 标签JLable
- 13.3.2 命令按钮JButton,复选框JCheckBox,单选按钮JRadioButton
- 13.3.3 文本编辑组边与滚动窗格
- 13.3.4 选项卡窗格JTabbedPane
- 13.4 布局管理器
- 习题13
Java程序设计基础(第5版)
第1章 Java语言概述
1.1 Java语言的诞生与发展
1.2 Java语言的特点
1.简单易学
2.面向对象
- 封装
- 继承
- 多态
3.平台无关
4.分布式
5.可靠性
6.安全性
7.支持多线程
8.支持网络编程
9.编译与解释共存
1.3 Java技术简介
- Java SE
- Java ME
- Java EE
1.4 Java虚拟机(JVM)
Java程序app.java→字节码app.class[by 编译]→解释运行[by 解释器]
字节码:跨平台运行
1.5 Java程序种类和结构
Application(可在Java平台上独立运行的Java应用程序，必然包含mian()) + Applet(嵌入HTML中的小程序，主类必然是继承自Applet or JApplet的public子类)
一般程序拆解：
package+import(引入其他类库中的类)+class(定义类)+main[域+方法]
习题1
3.什么是字节码？采用字节码的最大好处是什么？
答：
字节码：Java是JVM的指令组，源代码经过虚拟机编译器编译后产生的与平台无关的文件(即扩展为.class的文件)，它不面向任何特定的处理器，只面向虚拟机。
采用字节码的最大好处：可跨平台运行，即Java的字节码可以编写一次，到处运行。
4.什么是平台无关性？Java语言是怎样实现平台无关性的？
答:
平台无关性：一种语言在计算机上的运行不受平台的约束，一次编译到处运行。
如何实现：靠Java虚拟机(JVM)在目标代码级实现平台无关性(需要Java语言规范、Class文件、Java虚拟机（JVM）等支持)
5.Java语言程序有哪几种？它们包含哪几个方面？
Java Application(Java应用程序)和Java Applet(Java小程序)
Java应用程序是独立完整的程序，主类包含一个定位为public static void main(String[] args)的主方法
Java小程序内嵌在HTML文档中，需要搭配浏览器
6.什么是Java程序的主类？应用程序与小程序的主类有何不同？
一个程序中可以有多个类，但只能有一个类是主类。在Java应用程序中，这个主类是指包含main()方法的类。而在Java小程序中，这个主类是一个继承自系统类JApplet或Applet的子类。
应用程序的主类不一定要求是public类，但小程序的主类要求必须是public类。主类是Java程序执行的入口点。
第2章 Java语言开发环境
2.1 Java开发工具(JDK)
JDK=Java API(Java提供的标准类库) + JAVA运行环境(JRE) + Java实用程序
JDK\bin:
- javac.exe:Java编译器
- java.exe:Java解释器
- appletviewer.exe:小程序浏览器
- javadoc.exe:HTML格式的帮助文档
- jdb.exe:Java调试器
- jar.exe:类同zip的.jar压缩文件
2.2 JDK帮助文档下载与安装
2.3 JDK的使用
public class App2_1
{
public static void main(String[] args)
{
System.out.println("Hello Java!");
}
}源文件扩展名必为.java;源文件最多只能有一个public类，若无自己取名，若有必须与public类同名
源文件名由操作系统管理，使用javac命令编译源文件时文件名不区分大小写;含main()方法的类是主类
习题2
1.什么是JDK?
答：JDK是由Java API,Java运行环境和一组建立，测试工具的Java实用程序等组成的开发工具
3.环境变量Path和ClassPath的作用是什么？如何设置这两个环境变量？
答：
Path:设置供操作系统去寻找可执行文件的路径的顺序
ClassPath:JVM执行Java程序时搜索类的路径的顺序
设置:我的电脑→属性→高级系统设置→高级→环境变量→找到或新建系统变量Path/ClassPath→编辑→输入bin/tools.jar路径
10.Java应用程序与小程序之间有哪些差别？
答：
①应用程序的主类不一定要求是 public 类，但小程序的主类要求必须是 public 类。
②一个程序中可以有多个类，但只能有一个类是主类。在 Java 应用程序中，这个主类是指包含 main（）方法的类。 在 Java 小程序中，这个主类是一个继承自系统类JApplet 或 Applet 的子类
第3章 Java语言基础
3.1数据类型
数据类型 = 基本数据类型(整型、浮点型、逻辑型和字符型) + 引用数据类型(类、数组、接口)
基本数据类型:
- 整型： byte short int long
- 浮点型： float double
- 布尔型：boolean
- 字符型：char
1.整型
- 十进制
- 八进制：0打头，后跟0~7
- 十六进制：0x或0X打头，后跟0~9 或 a~f
类型 | 数据位 |
byte | 8 |
short | 16 |
int | 32 |
long | 64 |
整数强制表示为长整数:后面加字母l或L
2.浮点型
- 标准计数法
- 科学计数法
类型 | 数据位 |
float | 32 |
double | 64 |
浮点数隐含double，数后加字母f或F可强制转为float
3.布尔型
true or false
4.字符型
单个字符+’’
字符强转：int c =20320; char s = (char)c;
3.2 关键字与标识符
1.关键字
一些不常见的：assert,enum,instanceof,volatile,synchronized,transient
2.标识符
①字母、数字、下划线、美元符号等
②必须以字母、下划线或美元符号开头，不能以数字开头
3.3 常量
1.整型常量
2.浮点型常量
3.布尔型常量
4.字符型常量
转义字符 | 意义 |
\b | 后退一格 |
\n | 换行 |
\ \ | 输出一个反斜杠 |
\ ’ | 输出一个单引号 |
\ ‘’ | 输出一个双引号 |
\f | 换页 |
\t | 横向跳格 |
5.字符串常量
6.常量的声明
通常用final标识。
final int MAX = 10;
final float PI = 3.14f;3.4 变量
1.变量声明
2.变量的赋值
3.5 数据类型转换
1.数值型不同类型转换
低→高(byte short char int long float double)
高→低 by强制转换
2.字符串型数据与整型数据相互转换
①字符串转化为数值型
parseXXX()方法：类型.parse类型(String s) 将数字字符串转换为[类型]数据
eg:Interger.parseInt(String s)
②数值型转化为字符串
通过"+"
eg: int myInt = 1234;String myString = “”+myInt
3.6 由键盘输入数据(Scanner)
3.7 运算符与表达式
3.7.1 算术运算符
①二元：±*/%
②一元：+ - ++ –
一元只能用于简单变量，例如++(x+1)会报错
int i = 10;
m = i++; //先m=i,再i=i+1,m=10,i=11
m = ++i; //先i=i+1,再m=i,m=12,i=123.7.2 关系运算符
3.7.3 逻辑运算符
运算符 | 规则 |
＆ | 双true结果为true |
| | 双false结果为false |
！ | 取反 |
^ | 双true或false结果为false |
&& | ＆左右均判定，&&只判断左,若左为false整体为false |
|| | |左右均判定，||只判断左,若左为true整体为true |
3.7.4 位运算符(二进制)
3.7.5 赋值运算符
1.赋值运算符
a=b=c=8 在java中可通
2.扩展运算符
+=,-=等
3.7.6 条件运算符
三元运算符：表达式1？表达式2：表达式3 即表达式1为真则输出2，否则3[类同if-else]
3.7.7 字符串运算符
3.7.8 表达式及运算符的优先级、结合性
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7LWEB7IV-1637985235542)(D:\DeskStudyGroup\考试\Java\PICTURE\1.png)]
习题3
11.编写一个程序，从键盘上输入一个浮点数，然后将该浮点数的整数部分输出
package A_1;
import java.util.*;
public class IntOut{
public static void main(String[] args)
{
Scanner in = new Scanner(System.in);
double a = in.nextDouble();
System.out.println((int)a);
}
}12.编写一个程序，从键盘上输入两个整数，然后计算他们相除后得到的结果并输出
package A_1;
import java.util.*;
public class IntOut{
public static void main(String[] args)
{
Scanner in = new Scanner(System.in);
int a = in.nextInt();
int b = in.nextInt();
System.out.println(a/b);
}
}13.编写一个程序，从键盘上输入圆柱体的底半径r和高h，然后计算其体积并输出
package A_1;
import java.util.*;
public class IntOut{
public static void main(String[] args)
{
Scanner in = new Scanner(System.in);
double r = in.nextDouble();
double h = in.nextDouble();
System.out.println(Math.PI*r*r*h);
}
}第4章 流程控制
4.1 语句和复合语句
1.单行注释://
2.多行注释:/ /
4.2 顺序结构
4.3 分支结构
4.3.1 if条件语句
4.3.2 switch选择语句
switch(表达式)
{
case 常量表达式1:
语句序列1;
break;
case 常量表达式2:
语句序列2;
break;
...
default:
}首先计算小括号内表达式的值，必然为整形或字符型
4.4 循环结构
while、do-while和for
习题4
1.学习成绩按不同的分数段分为优、良、中、及格和不及格,从键盘上上输入一个0~100之间的成绩,输出相应的等级。要求用 switch 语句实现。
import java.util.*;
public class grade {
public static void main(String[] args){
System.out.println("请输入一个0~100的成绩");
Scanner in=new Scanner(System.in);
int grade=in.nextInt();
switch (grade/10){
case 1:case 2:case 3:case 4:
case 5:
System.out.println("不及格");break;
case 6:
System.out.println("及格");break;
case 7:
System.out.println("中");break;
case 8:
System.out.println("良");break;
case 9:case 10:
System.out.println("优");break;
default:break;
}
}
}2.成绩分为四个等级：85-100 A ;70-84 B ;60-69 C ;0-59 D。键盘输入一个0~100，输出对应等级，switch语句实现
import java.util.*;
public class grade2 {
public static void main(String[] args)
{
double score;
int score1;
Scanner in=new Scanner(System.in);
System.out.print("请输入一个0~100的成绩\n");
score=in.nextDouble();
score1=(int)score/10;
switch(score1)
{
case 0:case 1:case 2:case 3:case 4:
case 5:
System.out.println("D");break;
case 6:
System.out.println("C");break;
case 7:
System.out.println("B");break;
case 8:
if(score%10<=4)
System.out.println("B");
else
System.out.println("A");
break;
case 9:case 10:
System.out.println("A");break;
default:break;
}
}
}3.输出1-100间能被3和7整除的数
import java.util.*;
public class NumberAptly {
public static void main(String[] args) {
for(int i=1;i<=100;i++)
{
if(i%3==0 && i%7==0)
{
System.out.println("i:"+i);
}
}
}
}4.输入n，计算并输出1！+2！+3！+···+n!的结果
import java.util.*;
public class MultifySum {
public static void main(String[] args) {
int sum = 0;
Scanner in = new Scanner(System.in);
int n=in.nextInt();
for(int i=1;i<=n;i++) {
int t=1;
for(int j=1;j<=i;j++) {
t*=j;
}
sum+=t;
}
System.out.println("sum:"+sum);
}
}5.输入n，计算sum = 1-1/2!+1/3!-···(-1)(n-1)/n!
import java.util.*;
public class sum {
public static void main(String[] args)
{
int n,i,j;
double s = 1.0;
double sum,total;
sum = 0;
Scanner in =new Scanner(System.in);
System.out.print("输入一个n: ");
n=in.nextInt();
for(i=1;i<=n; i++) {
total = 1;
for(j=1; j<=i; j++)
total*=j;
sum+=s*(1/total);
s*=-1;
}
System.out.println("Sum="+sum);
}
}6.水仙花数
public class waterflower {
public static void main (String[] args) {
for (int i = 100; i <1000 ; i++) {
int a = i/100;
int b = i/10%10;
int c = i%10;
if(a*a*a + b*b*b+c*c*c== i){
System.out.println(i);
}
}
}
}7.输入整数，判断是否完全数(所有因数的和等于该数自身)，例如28=1+2+4+7+14
import java.util.*;
public class CompleteNumber{
public static void main(String[] args)
{
int num;
Scanner in=new Scanner(System.in);
System.out.print("请输入一个数：");
num=in.nextInt();
int i, sum;
for(i=1, sum=0; i<num; i++)
if(num%i==0)
sum+=i;
if(sum==num)
System.out.println(num+"是完全数！");
else
System.out.println(num+"不是完全数！");
}
}8.计算并输出一个整数各位数字之和
import java.util.*;
public class IntegerSum {
public static void main (String[] args)
{
Scanner in=new Scanner(System.in);
System.out.println("输入一个整数:");
int s,i,sum=0;
int t=in.nextInt();
while (t>0){
s=t%10;
t=(t-s)/10;
sum+=s;
}
System.out.println(sum);
}
}9.输入一个浮点数，并分解输出整数和小数部分
import java.util.*;
public class doubleout {
public static void main(String[] args) {
Scanner in=new Scanner(System.in);
double a=in.nextDouble();
System.out.println("整数部分是："+(int)a);
System.out.print("小数部分是："+a%1);
}
}10.一根3000米长的绳，每天一半，问需几天绳长短于5m
import java.util.*;
public class StringLength {
public static void main(String[] args)
{
double i,t;
for(i=0,t=3000;t>=5.0;i++)
t/=2;
System.out.println(i);
}
}11.编程输出图案
public class NumSmg {
public static void main(String[] args) {
int x = 1;
for(int i=1;i<=5;i ++ ) {
int y=x;
System.out.print(x+" ");
for(int j=i;j<5;j++) {
y+=j+1;
System.out.print(y+" ");
}
System.out.println();
x+=i;
}
}
}第5章 数组与字符串
5.1 数组的基本概念
内存：栈内存(基本类型变量和对象的引用变量)+堆内存(对象和数组)
5.2 一维数组
数组类型[] 数组名=new 数据类型 [个数];//分配内存给数组
eg: int[]a=new int[10];5.3 foreach语句与数组
for(type element:array)
{
System.out.println(element);
}
/*
int []arr = {1,2,3,4,5};
for(int element:arr)
System.out.println(element);
*/5.4 多维数组
int [] [] a = new int [3][4]int [] [] array = new int[10] [ ] √
int [] [] array = new int[] [10] ×
int [] [] array = new int[] [] ×
int [][] a ={{11,22,33,44},{66,77,88,99}};5.5字符串
5.5.1 字符串变量创建
String s =new String("HelloJava");
String s ="HelloJava";
//若与其他类型变量进行"+"运算,则将其同化为字符串5.5.2 String类常用方法(字符串变量名.方法名())
1、求字符串长度
public int length()//返回该字符串的长度
String str = new String("asdfzxc");
int strlength = str.length();//strlength = 72、求字符串某一位置字符
public char charAt(int index)//返回字符串中指定位置的字符；注意字符串中第一个字符索引是0，最后一个是length()-1。
String str = new String("asdfzxc");
char ch = str.charAt(4);//ch = z3、提取子串
用String类的substring方法可以提取字符串中的子串，该方法有两种常用参数:
1)public String substring(int beginIndex)//该方法从beginIndex位置起，从当前字符串中取出剩余的字符作为一个新的字符串返回。
2)public String substring(int beginIndex, int endIndex)//该方法从beginIndex位置起，从当前字符串中取出到endIndex-1位置的字符作为一个新的字符串返回。
String str1 = new String("asdfzxc");
String str2 = str1.substring(2);//str2 = "dfzxc"
String str3 = str1.substring(2,5);//str3 = "dfz"4、字符串比较
1)public int compareTo(String anotherString)//该方法是对字符串内容按字典顺序进行大小比较，通过返回的整数值指明当前字符串与参数字符串的大小关系。若当前对象比参数大则返回正整数，反之返回负整数，相等返回0。
2)public int compareToIgnore(String anotherString)//与compareTo方法相似，但忽略大小写。
3)public boolean equals(Object anotherObject)//比较当前字符串和参数字符串，在两个字符串相等的时候返回true，否则返回false。
4)public boolean equalsIgnoreCase(String anotherString)//与equals方法相似，但忽略大小写。
String str1 = new String("abc");
String str2 = new String("ABC");
int a = str1.compareTo(str2);//a>0
int b = str1.compareToIgnoreCase(str2);//b=0
boolean c = str1.equals(str2);//c=false
boolean d = str1.equalsIgnoreCase(str2);//d=true5、字符串连接
public String concat(String str)//将参数中的字符串str连接到当前字符串的后面，效果等价于"+"。
String str = "aa".concat("bb").concat("cc");
//相当于String str = "aa"+"bb"+"cc";6、字符串中单个字符查找
1)public int indexOf(int ch/String str)//用于查找当前字符串中字符或子串，返回字符或子串在当前字符串中从左边起首次出现的位置，若没有出现则返回-1。
2)public int indexOf(int ch/String str, int fromIndex)//改方法与第一种类似，区别在于该方法从fromIndex位置向后查找。
3)public int lastIndexOf(int ch/String str)//该方法与第一种类似，区别在于该方法从字符串的末尾位置向前查找。
4)public int lastIndexOf(int ch/String str, int fromIndex)//该方法与第二种方法类似，区别于该方法从fromIndex位置向前查找。
String str = "I am a good student";
int a = str.indexOf('a');//a = 2
int b = str.indexOf("good");//b = 7
int c = str.indexOf("w",2);//c = -1
int d = str.lastIndexOf("a");//d = 5
int e = str.lastIndexOf("a",3);//e = 27、字符串中字符的大小写转换
1)public String toLowerCase()//返回将当前字符串中所有字符转换成小写后的新串
2)public String toUpperCase()//返回将当前字符串中所有字符转换成大写后的新串
String str = new String("asDF");
String str1 = str.toLowerCase();//str1 = "asdf"
String str2 = str.toUpperCase();//str2 = "ASDF"8、字符串中字符的替换
1)public String replace(char oldChar, char newChar)//用字符newChar替换当前字符串中所有的oldChar字符，并返回一个新的字符串。
2)public String replaceFirst(String regex, String replacement)//该方法用字符replacement的内容替换当前字符串中遇到的第一个和字符串regex相匹配的子串，应将新的字符串返回。
3)public String replaceAll(String regex, String replacement)//该方法用字符replacement的内容替换当前字符串中遇到的所有和字符串regex相匹配的子串，应将新的字符串返回。
String str = "asdzxcasd";
String str1 = str.replace('a','g');//str1 = "gsdzxcgsd"
String str2 = str.replace("asd","fgh");//str2 = "fghzxcfgh"
String str3 = str.replaceFirst("asd","fgh");//str3 = "fghzxcasd"
String str4 = str.replaceAll("asd","fgh");//str4 = "fghzxcfgh"9、其他类方法
1)String trim()//截去字符串两端的空格，但对于中间的空格不处理。
String str = " a sd ";
String str1 = str.trim();
int a = str.length();//a = 6
int b = str1.length();//b = 42)String[] split(String str)//将str作为分隔符进行字符串分解，分解后的字字符串在字符串数组中返回。
String str = "asd!qwe|zxc#";
String[] str1 = str.split("!|#");//str1[0] = "asd";str1[1] = "qwe";str1[2] = "zxc";drawString（String str，int x，int y）：
String str是可以在屏幕上显示的字符串。整数类型x和y是在图形窗口上保持x和y位置的变量。回文字符判定:
public class HuiWenDemo {
public static void main(String[] args) {
String str = "";
System.out.println("请输入一个字符串");
Scanner in = new Scanner(System.in);
str = in.next();
StringBuffer sb = new StringBuffer(str);
sb.reverse();// 将Str中的字符串倒置
int count = 0;
for (int i = 0; i < str.length(); i++) {
if (str.charAt(i) == sb.charAt(i)) {
count++;
}
}
if (count == str.length()) {
System.out.println("此字符串是一个回文字符串");
} else {
System.out.println("此字符串不是一个回文字符串");
}
}
}习题5
4.找出4x5矩阵中最小最大值，输出值及其行列数
import java.util.*;
public class App1 {
public static void main(String[] args)
{
int[][] arr=new int[4][5];
Scanner in=new Scanner(System.in);
int i, j, min, max, minRow=0, minColumn=0, maxRow=0, maxColumn=0;
System.out.println("Please enter 4*5 array: ");
for(i=0; i<4; i++)
for(j=0; j<5; j++)
arr[i][j]=in.nextInt();
for(i=0, min=arr[0][0], max=arr[3][4]; i<4; i++)
for(j=0; j<5; j++) {
if(arr[i][j]<=min) {
min=arr[i][j];
minRow=i;
minColumn=j;
}
if(arr[i][j]>=max) {
max=arr[i][j];
maxRow=i;
maxColumn=j;
}
}
System.out.println("Max="+max+" Max Row="+maxRow+" Max Column="+maxColumn);
System.out.println("Min="+min+" Min Row="+minRow+" Min Column="+minColumn);
}
}5.产生0~100间8个随机整数并冒泡排序(升序)
import java.util.*;
public class RandomInt {
public static void main(String[] args) {
int i,j;
int arr[] = new int[8];
//生成随机数并录入数组
Random r = new Random();
for (i = 0; i < 8; i++) {
int ran1 = r.nextInt(100);
arr[i] = ran1;
}
//冒泡
for (int x = 0; x < 8; x++) {
for (j = 0; j < arr.length - 1 - x; j++)
{
if (arr[j] > arr[j + 1]) {
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
//输出
for (i = 0; i < 8; i++) {
System.out.println(arr[i]);
}
}
}7.比较字符串是否相同并输出比较结果
import java.util.*;
public class Equal {
public static void main(String[] args) {
String str1, str2;
Scanner in = new Scanner(System.in);
System.out.print("字符串1: ");
str1 = in.nextLine();//next碰到空格或者任意空字符就算结束，而nextLine全部识别
System.out.print("字符串2: ");
str2 = in.nextLine();
System.out.println(str1.equals(str2));
}
}8.输入字符串，截取位置及长度，截取子串
import java.util.*;
public class A1_1 {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
System.out.println("输入字符串：");
String str = in.nextLine();
System.out.println("输入开始位置：");
int a = in.nextInt();
System.out.println("输入截取长度：");
int len = in.nextInt();
String str1 = str.substring(a,len+a);
System.out.println(str1);
}
}9.输入一个字符串和字符，删除串内字符
import java.util.*;
public class DeleteWord {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
String str1 = in.nextLine();// 输入一个字符串
String str2 = in.nextLine();// 指定字符
String str = str1.replace(str2,"");// 删除指定字符后的字符串
System.out.println(str);
}
}第6章 类和对象
6.1 类的基本概念
类(抽象)[车] 对象[雪铁龙 宝马 奥迪]
类=成员变量+成员方法
6.2 定义类
1.类的一般结构
修饰符 | 含义 |
public | 公共类，可被任何对象访问 |
abstract | 抽象类，需要子类提供方法实现 |
final | 非继承类，不能被其他类继承 |
缺省 | 啥也不加，仅限相同包内对象使用 |
abstract和final不能同时出现
2.成员变量
[修饰符] 变量类型 变量名
修饰符 | 含义 |
public | 公共，可被任何对象的方法访问 |
private | 私有，只允许自己类的方法访问，其他都不行(包括子类) |
protected | 保护，只允许自己类及子类或同包其他类访问 |
final | 最终，变量不能变 |
static | 静态，被所有对象共享 |
当出现private修饰成员变量时，其他类调用时应使用set变量名和get变量名方法
private int age;
public void setAge(int a)
{
age = a;
}
public int getAge(){
return age;
}
main
s.setAge(-30);3.成员方法
修饰符 | 含义 |
final | 最终，方法不能被重载 |
abstract | 抽象，创建方法时只声明方法头，无方法体，抽象方法需在子类中被实现 |
public private protected static | 类同成员变量 |
4.成员变量与局部变量的区别
- 局部变量：在方法、构造方法或者语句块中定义的变量被称为局部变量。变量声明和初始化都是在方法中，方法结束后，变量就会自动销毁。
- 成员变量：成员变量是定义在类中，方法体之外的变量。这种变量在创建对象的时候实例化。成员变量可以被类中方法、构造方法和特定类的语句块访问。
- 类变量：类变量也声明在类中，方法体之外，但必须声明为static类型。
6.3 对象的创建与使用
6.3.1 创建对象
public class Puppy{
int puppyAge;
public Puppy(String name){
// 这个构造器仅有一个参数：name
System.out.println("小狗的名字是 : " + name );
}
public void setAge( int age ){
puppyAge = age;
}
public int getAge( ){
System.out.println("小狗的年龄为 : " + puppyAge );
return puppyAge;
}
public static void main(String[] args){
/* 创建对象 */
Puppy myPuppy = new Puppy( "tommy" );
/* 通过方法来设定age */
myPuppy.setAge( 2 );
/* 调用另一个方法获取age */
myPuppy.getAge( );
/*你也可以像下面这样访问成员变量 */
System.out.println("变量值 : " + myPuppy.puppyAge );
}
}6.4 参数的传递
6.4.1 以变量为参数调用方法
6.4.2 以数组作为参数或返回值的方法调用
main
int [] a = {5,6,53,6};
LeastNume s = new LeastNume;
s.least(a);
class LeastNume
{ public void least(int[]attay){}}6.5 匿名对象
习题6
1.类与对象的区别是什么
答：
类是对某一类事物的描述，是抽象的、概念上的定义；而对象则是实际存在的属该类事物的具体的个体，因而也被称为实例。
2.如何定义一个类？类的结构是怎样的？
答:
定义类实际上就是定义类的属性和方法。
[类修饰符] class 类名称
{
[修饰符] 数据类型 成员变量名称 //声明成员变量
[修饰符] 返回值的数据类型 方法名(参数1，参数2，··· ···)//声明成员方法
{
语句序列;
return[表达式]
}
}3.定义一个类时所使用的修饰符有哪几个？每个修饰符的作用是什么？
修饰符 | 含义 |
public | 将一个类声明为公共类，可被任何对象访问 |
abstract | 将一个类声明为抽象类，没有实现方法，需要子类提供方法实现，所以不能创建该类的实例 |
final | 将一个类声明为最终类即非继承类，表示它不能被其他类所继承 |
缺省 | 缺省修饰符时，则表示只有在相同包中的对象才能使用这样的类 |
6.成员变量和局部变量的区别有哪些？
答:
- 从语法形式上看，成员变量是属于类的，而局部变量是在方法中定义的变量或方法的参数；成员变量可以被public、private、static等修饰符所修饰，而局部变量则不能被访问控制修饰符及static所修饰但都可以被final所修饰。
- 从变量在内存中的存储方式上看，成员变量是对象的一部分，而对象是存在于堆内存，而局部变量是存在于栈内存。
- 从变量在内存中的生存时间上看，成员变量是对象的一部分，它随对象的创建而存在，而局部变量随着方法的调用而产生，随着方法调用的结束而自动消失。
- 成员变量如果没有被赋初值，则会自动以类型的默认值赋值（有一种情况例外，被final修饰但没有被static修饰的成员变量必须显示地赋值）；而局部变量则不会自动赋值，必须显示赋值后才能使用。
13.定义一个Student类,包含如下内容：成员变量：学号，姓名，性别，班干部否，数学，语文，外语。成员方法：输入，总分，平均分。编程实现这个类，并调用相应的方法输入数据，计算总分和平均分。
import java.util.*;
class Student
{
int num;
String name, sex;
boolean master;
double math, literature, english;
Scanner in=new Scanner(System.in);
void input()
{
System.out.print("Please enter number, name, sex, master: ");
num=in.nextInt();
name=in.next();
sex=in.next();
master=in.nextBoolean();
System.out.print("Please enter Math, Literature, English score: ");
math=in.nextDouble();
literature=in.nextDouble();
english=in.nextDouble();
}
double sumScore()
{
return math+literature+english;
}
double averageScore()
{
return sumScore()/3;
}
void output()
{
System.out.println("Number: "+num);
System.out.println("Name: "+name);
System.out.println("Sex: "+sex);
System.out.println("Master: "+master);
System.out.println("The sum score="+sumScore());
System.out.println("The average score="+averageScore());
}
}
public class App1
{
public static void main(String[] args)
{
Student stu=new Student();
stu.input();
stu.output();
}
}在静态方法中不能访问类的非静态成员变量和非静态成员方法(因为非静态成员方法/变量都必须依赖具体的对象才能够被调用),但非静态成员方法中是可以访问静态成员方法/变量的!
14.以m行n列二维数组为参数进行方法调用，分别计算二维数组各列元素之和并输出计算结果
import java.util.*;
class sum
{
int[] colnum(int[][] array)
{
int[] temp=new int[array[0].length];//array[i].length表示第i行元素的个数,array.length表示行数
for(int j=0;j<array[0].length;j++)
for(int i=0;i<array.length;i++)
temp[j]+=array[i][j];
return temp;
}
public static void main(String[] args)
{
Scanner in=new Scanner(System.in);
int i,j,m,n;
System.out.println("请输入行数m=");
m=in.nextInt();
System.out.println("请输入列数n=");
n=in.nextInt();
int[][] a=new int[m][n];
int[] arr=new int[n];
System.out.println("请输入["+m+"*"+n+"]数组的数据");
for(i=0;i<m;i++)
for(j=0;j<n;j++)
a[i][j]=in.nextInt();
sum sum1=new sum();
arr=sum1.colnum(a);
for(i=0;i<arr.length;i++)
System.out.println("第"+(i+1)+"列数的和="+arr[i]);
}
}第7章 Java语言类的特性
7.1 类的私有成员与公共成员
7.1.1 私有成员(private)
private double radius;//外部类无法访问该变量7.1.2 公共成员(public)
7.1.3 缺省访问控制符
7.2 方法重载
多种方法同类同名不同参（参数个数，类型，顺序不同）
7.3 构造方法
7.3.1 构造方法的作用与定义
public void Cylinder(double r,int h);//普通方法
public Cylinder(double r,int h);//构造方法
main
Cylinder volu = new Cylinder(3.5,8);//创建对象的时候顺便就赋值了，不像普通方法还得多操作，便捷迅速，普通方法时()里不能包含任何参数特点：
- 构造方法的方法名与类相同
- 无返回值，但不能写void
- 主要作用是提前完成对类对象的初始化
7.3.2 默认构造方法(javac生成默认构造方法并默认调用)
7.3.3 构造方法的重载
首先构造方法和类同名，故才可方法重载一波。
7.3.4 构造方法调用构造方法(by this)
public Cylinder(){
this(2.5,5,"红色")
}
public Cylinder(double r,int h,String str){
readius = r;
height = h;
color = str;
}this的另一用法:
private String name;//与private用法结合
public void setName(String name){
this.name = name;//用this表示成员变量,name本身是局部变量
}
public String getName()
{
return name;
}方法被哪个对象调用，this就代表哪个对象
7.4 静态成员(static)
目的：方便在没有创建对象的情况下来进行调用（方法/变量）
7.4.1 实例成员
没有用static修饰的成员变量/方法。产生对象时自个儿玩自个儿的，存储空间不与其他对象共享
7.4.2 静态变量
存储在公共单元内，为全类服务，任何对象访问到时取到的都是同一个数值。
有点全局变量的味道,在Java中能够影响到访问权限的只有private,public,protected（包括包访问权限）这几个关键字,不包括static,且static是不允许用来修饰局部变量的。
7.4.3 静态方法
公共操控私有× 私有操控公共√[静态方法无法调用非静态成员变量/方法，但非静态方法可以调用静态成员变量/方法]
访问静态方法推荐: 类名.静态方法名()
7.4.4 静态初始化器
static
{
num =100;
}对整个类完成初始化操作
7.5 对象的应用
7.5.1 对象的赋值与比较
Cylinder volu1,volu2;//声明
volu1 =new Cylinder(2.5,2);
volu2 = volu1; //volu1赋值给volu2,使volu2也指向volu1的对象
volu2.setCylinder(1.0,2);//调用方法重新设置参数是基本数据类型时，传值方式调用;参数是引用变量时，传址方式调用,在这里赋值后其实是传址，首地址相同
7.5.2 引用变量作为方法的返回值 ？
7.5.3 类类型的数组
Person[] per = new Person[3];
per[0] = new Person("张三",20);
per[1] = new Person("李四",21);
per[2] = new Person("王五",22);//创建新对象并分配给数组元素
per[1].show; //利用per[1]调用show方法习题7
2.什么是方法的重载？
答:
在同一个类内定义相同名称的多个方法，这些同名的方法或参数的个数不同、或者参数的个数相同但类型不同，则这些同名的方法便可具有不同的功能
3.一个类的构造方法的作用是什么？若一个类没有声明构造方法该程序能正确执行吗？为什么？
答：
帮助创建的对象赋初值。
可以。如果一个类没有定义构造方法，则Java编译系统会自动为其生成默认的构造方法，默认的构造方法是没有任何参数，方法体内也没有任何语句的构造方法。
4.构造方法有哪些特性？
答:
- 构造方法的方法名与类名相同
- 构造方法没有返回值，但不能写void
- 构造方法的主要作用是完成对类对象的初始化工作
- 构造方法一般不能由编程人员显式地直接调用，而是用new来调用
- 在创建一个类的对象的同时，系统会自动调用该类的构造方法为新对象初始化
9.对象的相等与指向它们的引用相等，两者有什么不同？
答:
对象的相等是指对象所存储的内容是否相等，引用相等是指引用所指向的地址是否相等。
10.什么是静态初始化器？其作用是什么？静态初始化器由谁在何时执行？它在构造方法有何不同？
答:
静态初始化器是由关键字static修饰的一对大括号"{}"括起来的语句组
作用:初始化工作
静态初始化器是在所属的类被加载入内存时由系统调用执行的
不同：
- 对类自身进行初始化
- 不能由程序调用，而是在所属的类被加载入内存时由系统调用执行
- 在类被载入内存时只执行一次，与创建多少个对象无关
- 静态初始化器不是方法，因而没有方法名、返回值和参数
第八章 继承、抽象类和接口
8.1 类的继承
即父类(基类、超类)与子类(派生类)间的链接，子类能使用父类中定义的方法和变量，也能修改。
8.1.1 子类的创建
格式：class Son extends Farther{}
优点：提高代码的维护和复用性
缺点：削弱了子类的独立性
特点：
①在子类方法中访问一个变量：子类局部(方法内部)→子类成员→父类成员→报错。权限：方法>子类>父类
②子类中所有的构造方法默认都会访问父类中无参的构造方法[先访问父类方法，再访问子类]
③在执行子类的构造方法之前，会先调用父类中没有参数的构造方法。
在继承中构造方法且访问时，若父类中没有无参构造方法，需要自己搞一个空的无参构造方法，否则会报错;若父类中含有参的构造方法，子类必须自定义构造函数，并且在构造函数的第一行调用父类的带参的构造函数super()。
JAVA中类支持单继承，不支持多继承，但支持多层继承，一个子类只能拥有一个父类，但父类可以拥有多个子类。
可以爷爹儿，不能儿爸妈
class Person
{
private String name;
private int age;
public Person()
{
System.out.println("调用了个人类构造方法")
}
public void setNameAge(String name,int age)
{
this.name = name;
this.age = age;
}
public String getNameAge(){
return name,age;
}
public void show(){
System.println(name+age);
}
}
class Student extends Person
{
private String department;
public Student(){
System.out.println("调用了学生类构造方法");
}
public void setDepartment(String department)
{
this.department = department;
System.out.println(department);
}
public String getDepartment()
{
return department;
}
}
public class Main
{
public static void main(String[] args){
Student stu = new Student();
stu.setNameAge("张小三",21);//子类访问父类的方法
stu.show();
stu.setDepartment("计算机系");
}
}为初始化操作，子类会自动去调用父类中的无参构造方法，但是严格意义上来说，若想调用父类中特定的构造方法，则需要在子类的构造方法中通过super()来调用。
father
public Person(String name,int age)
{
this.name = name;
this.age = age;
}
son
public Student(String name,int age,String dep)
{
super(name,age);//调用了父类的有参构造方法，必然要写在第一行，也能重载，若父类中只有有参构造方法，子类中无super(),这时候就需要在父类里加一个空的构造方法public Pesrson(){},与this类似，super不能在static环境中使用，且二者不能共存,super是调用父类构造方法，this则是调用子类
}8.1.2 在子类中访问父类的成员
super.变量名/方法名;子类无法继承父类private故无法访问，但可以访问protected;灵光一闪:子继承父的实现是靠实例化对象，子访问父的实现是靠super.
8.1.3 覆盖/方法重写
在子类中，定义名称、参数个数与类型均与父类中完全相同的方法，用于实现重写父类中同名方法的功能。
子类无法覆盖父类中声明为final或static的方法
father
protected void show(){
System.out.println("姓名"+name+"年龄："+age);
}
son
protected void show(){
System.out.println("系列"+department);//完成对父类的覆盖
}
main
stu.show();//经覆盖后调用子类的覆盖方法通过父类对象访问子类成员，只限于“覆盖”情况，即为，多态；
Java实现多态有三个必要条件：继承、重写、向上转型。
继承：在多态中必须存在有继承关系的子类和父类。
重写：子类对父类中某些方法进行重新定义，在调用这些方法时就会调用子类的方法。
向上转型：在多态中需要将子类的引用赋给父类对象，只有这样该引用才能够具备技能调用父类的方法和子类的方法。
father
protected void show(){
System.out.println("姓名"+name+"年龄"+age);
}
son
protected void show(){
System.out.println("系列"+department);
}
Person per = new Student();
per.show();8.1.4 不可被继承的成员和最终类(final)
8.1.5 Object类(万类之祖)
1.equals()方法
对非字符串类型变量，和”==“相同，都是用来比较两个类类型的变量是否指向同一个对象，对字符串变量，”= =“比较两个变量本身的值，即对象在内存中的首地址，equals()方法则是比较内容。
2.toString()方法
3.getClass()方法
返回运行时的对象所属的类
Person per = new Person();
Class obj = per getClass();
System.out.println("obj");
System.out.println("obj.isInterface()");//是否是接口
Out:
class Person
false灵光一闪：一个文件中有多个类，只有与文件名一致的类名，才能声明为public
8.2 抽象类
可根据其格式创建和修改新的类，但不能通过抽象类创建对象，只能通过其派生子类创建对象，即不能new，作为父类可以被所有它的子类共享
8.2.1 抽象类与抽象方法
abstract class 类名{
声明成员变量；
返回值的数据类型 方法名 (参数表){
}
abstract 返回值的数据类型 方法名(参数表);//抽象方法，不能定义方法体,static和abstract无法共存
}抽象类必须被继承，故不能使用final，也不能private,static,final并列修饰同一方法
抽象类不一定含抽象方法，但包含抽象方法的类必要声明为抽象类，同时抽象类可以有构造方法，但不能声明为抽象。
8.2.2 抽象类的应用
abstract class Shape
{
protected String name;
public Shape(String xm)
{
name = xm;
System.out.println("名称："+name);
}
abstract public double getArea();
abstract public double getLength();
}
class Circle extends Shape
{
private final double PI = 3.14;
private double radius;
public Circle(String shapeName,double r)
{
super(shapeName);
radius = r;
}
public double getArea()
{
return PI * radius *radius;
}
public double getLength()
{
return 2 * PI * radius;
}
}
class Rectangle extends Shape
{
private double width;
private double height;
public Rectangle(String shapeName,double width,double height)
{
super(shapeName);
this.width = width;
this.height = height;
}
public double getArea()
{
return width * height;
}
public double getLength()
{
return 2 * (width + height);
}
}
public class App8_10
{
public static void main(String[] args)
{
Shape rect = new Rectangle("长方形",6.5,10.3);
System.out.print(";面积=" +rect.getArea());
System.out.println(";周长 = " + rect.getLength());
Shape circle = new Circle("圆",10.2);
System.out.print(";面积 =" + circle.getArea());
System.out.println("; 周长 = " + circle.getLength());
}
}灵光一闪：super.和super()不同！前者可以调用父类的成员变量及方法，后者主要可以调用父类的构造方法，且()内为父类构造函数中的参数！
abstract class A{
abstract void add();
public void delete(){}
}
abstract class B extends A{
//继承了抽象A类，因为也是抽象的，可以不写抽象方法，当然也可以重写抽象方法(切记抽象方法是没有方法体的)
//abstract void add(); //也是没有问题的
abstract void getXX();
}
public class C extends B{
//必须实现抽象方法
//继承了B，也就继承了A，A B方法都有，所以必须重写这两个抽象类的抽象方法
public void add(){}
public void delete(){}
public void getXX(){}
}抽象类继承抽象类可以不写抽象方法，非抽象类继承抽象类必须实现抽象方法！
对于子类是否重写：父类方法若为抽象方法，必须重写，父类方法若为普通方法，随您的便
8.3 接口
8.3.1 接口的定义
①数据成员都是静态的且必须初始化
②接口方法必须全为抽象方法
[public] interface 接口名称 [extends 父接口名列表]//同包下,public可省略
{
[public][static][final] 数据类型 成员变量名 = 常量;
[public][abstract] 返回值的数据类型 方法名(参数表);
}8.3.2 接口的实现与引用
class 类名 implements 接口名表
{
}①如果实现接口的类不是抽象类，则类的定义部分必须实现接口的所有抽象方法，即非抽象类不能存在抽象方法
②类在实现抽象方法时，必须使用完全相同的方法头
③类的实现方法时，必须使用public修饰符
interface IShape{
final double PI =3.14;
abstract double getArea();
abstract double getLength();
}
class Circle implements IShape{
double radius;
public Circle(double r)
{
radius = r;
}
public double getArea()
{
return PI * radius * radius;
}
public double getLength()
{
return 2 * PI * radius;
}
}
public class App8_11
{
public static void main(String[] args)
{
IShape circle = new Circle(5.0);
System.out.print(circle.getArea());
system.out.println(circle.gerLength());
}
}8.3.3 接口的继承
一个接口可以有多个父类，以逗号分隔，形成父接口表
interface Face1{
final double PI = 3.14;
abstract double area();
}
interface Face2{
abstract void setColor(String c);
}
interface Face3 extends Face1,Face2//接口继承
{
abstract void volume();
}
public class Cylinder implements Face3{
private double radius;
private int height;
protected String color;
public Cylinder(double r,int h)
{
radius = r;
height = h;
}
public double area()//Face1
{
return PI * radius * radius;
}
public void setColor(String c)//Face2
{
color = c;
System.out.println("颜色:"+color);
}
public void volume()//Face3
{
System.out.println("圆柱体体积=" + area() * height);//调用父接口的方法
}
public static void main(String[] args)
{
Cylinder volu = new Cylinder(3.0,2);
volu.setColor("红色");//Face1
volu.volume();//Face3
}
}8.4 内部类与匿名内部类
8.4.1 内部类
类中类，即嵌套(不能与外部类同名)，对于内部类，可通过建立外部类方法调用
public class Group{
private int age;
/* 内部类 public class Student{
public Student(String n , int a){
name = n;
age = a;
}
public void output()
{
Syso(this.name+age);
}
} */
public void output()//外部类方法,调用内部类成员方法
{
Student stu = new Student("刘洋",24);
stu.output();
}
public static void main(String[] args)
{
Group g = new Group();
g.output();//g对象调用外部类方法，外部类方法通过内部类对象从而去调用内部类
}
}内部类特性:
- 可以声明为private或protected
- final修饰不能被继承
- 可以定位abstract,但需要被其他内部类继承或实现
- 可以使用外部类的成员变量，也可使用内部类所在方法的局部变量
- 可以是接口，必须由另一个内部类来实现
8.4.2 匿名内部类
8.5 包
8.6 Java语言的垃圾回收
习题8
6.什么是多态机制？Java语言中是怎么实现多态的？
答:
相同类型的变量、调用同一个方法时呈现出多种不同的行为特征，这就是多态。
Java的多态机制体现在编译时多态和运行时多态，分别体现为重载和覆盖，
7.方法的重载与方法的覆盖有何不同？
答:
重载是指在同一个类内，定义名称相同，但参数个数或类型不同的多个方法，Java系统可根据参数的个数或类型，调用相对应的方法。
覆盖是在子类当中，定义名称、参数个数与类型均与父类相同的方法，用于覆盖父类中方法的功能。
①方法的覆盖是子类和父类之间的关系，是垂直关系；方法的重载是同一个类中方法之间的关系，是水平关系
②覆盖只能由一个方法，或只能由一对方法产生关系；方法的重载是多个方法之间的关系
③覆盖要求参数列表相同；重载要求参数列表不同
④覆盖关系中，调用哪个方法体，是根据对象的类型（对象对应存储空间类型）来决定；重载关系，是根据调用时的实参表与形参表来选择方法体。
8.this和super分别有什么特殊的含义？
答:
this代表对象本身，它可以调用当前对象的属性、方法和构造方法。
super相当于是指代当前的对象的父类，调用父类的属性、方法和构造方法。
10.什么是抽象类和抽象方法？使用时应注意哪些方面？
答:
抽象类是以修饰符abstract修饰的作为父类的类。
抽象方法是以abstract关键字开头的方法
注意:
①由于抽象类是需要被继承的，所以abstract类不能用final来修饰
②abstract不能与private,static,final或native并列修饰同一个方法
③不能直接由抽象类创建对象，只能通过抽象类派生出新的子类，再由其子类来创建对象。
11.什么是接口？为什么要定义接口？
答:
接口在JAVA编程语言中是一个抽象类型，是抽象方法的集合，通常以interface来声明。
利用接口可以实现多继承
12.如何定义接口？接口与抽象类有哪些异同？
[public] interface 接口名称 [extends 父接口名列表]
{
[public][static][final] 数据类型 成员变量名 = 常量;
[public][abstract] 返回值的数据类型 方法名(参数表);
}异同:
- 接口的数据成员都是静态的且必须初始化。
- 接口中的方法必须全部都声明为abstract的，也就是说，接口不能像抽象类一样拥有一般的方法，而必须全部是抽象方法
13.内部类的类型有几种？分别在什么情况下使用？它们所起的作用有哪些？
答:
①成员内部类：访问外部类所有的属性和方法。
②静态内部类：仅访问外部类的静态成员变量和方法(包括私有静态)
③局部内部类：访问仅限于方法内或者该作用域内
④匿名内部类：编写事件监听代码，或当一个内部类需要继承或者实现，而且只使用一次时。
内部类：定义在类中的类，主要作用是将逻辑上相关的类放到一起；
匿名类：特殊的内部类，没有类名，在定义类的同时，就生成该类的一个实例，由于不会在其他地方用到该类，所以不用取名字。
作用:
①将逻辑上相关的类放在一起，增强可读性。
②实现隐藏。
③间接实现多继承。
④内部类拥有外围类的所有元素的访问权限
⑤可以避免修改接口而实现同一个类中两种同名方法的调用。
16.什么是包？它的作用是什么？如何创建包？如何引用包中的类？
答:
所谓包，就是Java语言提供的一种区别类名空间的机制，是类的组织方式。
方便编辑和管理。
package 包名1[.包名2[.包名3]···]；
import 包名1[.包名2[.包名3···]].类名|*
第9章 异常处理
9.1 异常处理的基本概念
9.1.1 错误与异常
语法错，语义错，逻辑错。
9.1.2 Java语言的异常处理机制
1.异常
程序出现了不正常的情况
Throwable:Error, Exception(异常类，需要处理)[RuntimeException和非RuntimeException]
2.抛出异常
生成异常对象并把它提交给运行系统的过程
3.捕获异常
异常抛出后，从生成异常对象的代码开始，沿方法的调用栈逐层回溯查找，直到找到包含相应异常处理的方法，并把异常对象提交给该方法为止。
9.2 异常处理类
Exception类及其子类
public Exception();
public Exception(String s);//接受参数传入信息
public String toString()//返回描述字符串
public void printStackTrace()//9.3 异常的处理
try-catch-finally语句
try{要检查的语句序列}
catch(异常类名 形参对象名){}//catch(XXX e)，多个catch块表示多异常
finally{一定会运行的语句序列}9.4 抛出异常
类型:①系统自动抛出的异常②指定方法抛出异常
抛出异常的方法
<1>
throw 由异常类所产生的对象;<2>
[修饰符] 返回值类型 方法名 ([参数列表]) throws 异常类列表//异常类多个时要用","隔开eg:
try{
if(b==0)
throw new ArithmeticException();//抛出
else
System.out.println(a+"/"+b+"="+a/b);//若不抛出异常则运行此行
}
catch(ArithmeticException e){
System.out.println("异常:"+e+"被抛出了！");
e.printStackTrace();//输出当前异常对象的堆栈使用轨迹
}
}9.5 自定义异常类
习题9
1.什么是异常？简述Java语言的异常处理机制。
答：
异常是指程序在运行过程中发生由于算法考虑不周或软件设计错误等导致的程序异常事件。
Java语言中定义了很多异常类，每个异常类都代表一种运行错误，类中包含了该运行错误的信息和处理错误的方法等内容。每当Java程序运行过程中发生一个可识别的运行错误时，即该错误有一个异常类与之对应时，系统多会产生一个相应的该异常类的对象，即产生一个该错误的异常。一旦一个异常对象产生了，系统中就一定有相应的机制来处理它，从而保证整个程序运行的安全性
2.Throwable的两个直接子类Error和Exception的功能各是什么？用户可以捕捉的异常是哪个类的异常？
答:
Error子类由系统保留，因为该类定义了那些应用程序通常无法捕捉到的异常。即Error类对象是由Java虚拟机生成并抛出给系统，这种错误有内存溢出错、栈溢出错、动态链接错等。通常Java程序不对这种错误进行直接处理，必须交由操作系统处理。
Exception子类是供应用程序使用的，它是用户程序能够捕捉到的异常情况，通常产生它的子类来创建自己的异常。即Exception类对象是Java程序抛出和处理的对象，它有各种不同的子类分别对应于各种不同类型的异常。
Exception
3.Exception类有何作用？每个Exception类的对象代表了什么？
答:
Exception子类是供应用程序使用的，它是用户程序能够捕捉到的异常情况，通常产生它的子类来创建自己的异常。即Exception类对象是Java程序抛出和处理的对象，它有各种不同的子类分别对应于各种不同类型的异常。
4.什么是运行时异常？什么是非运行时异常？
答:
运行时异常(RuntimeException)是程序运行时自动的对某些错误做出反应而产生.
非运行时异常经常是在程序运行过程中由环境原因引起的异常
5.抛出异常有哪两种方式？
答:
①系统自动抛出的异常：所有系统定义的运行异常都可以由系统自动抛出
②使用throw语句抛出的异常：用户程序自定义的异常不可能依靠系统自动抛出，而必须借助于throw语句来定义何种情况算是产生了此种异常对应的错误，并应该抛出这个异常类的对象。
9.若try语句结构中有多个catch()子句，这些子句的排列顺序与程序执行效果是否有关？为什么？
答:
有关；由于异常对象与catch块的匹配是按照catch块的先后排列顺序进行的，所以在处理多异常时应注意认真设计各catch块的排列顺序。一般地，将处理较具体的较常见的异常的catch块应放在前面，而可以与多种异常相匹配的catch块应放在较后的位置。若将子类异常的catch语句块放在父类的后面，则编译不能通过。
第10章 Java语言的输入输出与文件处理
10.1 Java语言的输入输出库(java.io)
10.1.1 流的概念
计算机各部件之间的数据流动。输入和输出，字符和字节
1.输入输出流
2.缓冲流
10.1.2 输入输出流类库
字节流(二进制8字节)，字符流(字符16字节)
java.io包中四个基本类(抽象类):
字节流:InputStream,OutputSteam
字符流:Reader,Writer
10.2 使用InputStream和OutputStream流类
10.2.1 基本的输入输出流
1.InputStream流类
方法 | 功能 |
public int read() | 读入一个字节的二进制数据，配上8个全0高位字节合成16位整形返回，若无数据，则返回-1 |
public int read(byte[] b) | 从输入流中的当前位置连续读入多个字节保存在数组b中，同时返回读到的字节数 |
public int available() | 返回可以读取的字节数 |
public void close() | 关闭输入流与外设连接并释放所占用的内存 |
2.OutputStream流类
方法 | 功能 |
public void write(int b) | 将参数b的低位字节写入到输出流 |
public void(byte[] b) | 从输入流中的当前位置连续读入多个字节保存在数组b中，同时返回读到的字节数 |
public void flush() | 强制清空缓冲区并执行向外设写操作 |
public void close() | 关闭输出流与外设连接并释放所占用的内存 |
两个流类均为抽象类，故输入/出流对象一般是流类某个子类的对象，通过调用该子类继承的read()/write()方法即可实现对外设的操作
10.2.2 输入输出流的应用
1.文件输入输出流
2.顺序输入输出流
3.管道输入输出流
4.过滤输入输出流
10.3 Reader和Writer流类
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jVpnUi3k-1637985235546)(D:\DeskStudyGroup\考试\Java\PICTURE\3.png)]
10.3.1 使用FileReader类读取文件
import java.io.*;
public class App10_5
{
public static void main(String[] args) throws IOException
{
char []c = new char[500];
FileReader fr = new FileReader("d:\\Gun.txt");
int num = fr.read(c);
String str = new String(c,0,num);//str2=new String(c,start,num)把字符数组的部分字符转化为字符串
System.out.println("读取的字符个数:"+num+",内容如下");
System.out.println(str);
fr.close();
}
}10.3.2 使用FileWriter类读取文件
import java.io.*;
public class App10_6
{
public static void main(String[] args) throws IOException
{
FileWriter fw = new FileWriter("d:\\Gun.txt");
char [] c ={'H','e','l','l','o'};
String str = "就这？";
fw.write(c);
fw.write(str);
fw.close();
}
}10.3.3 使用BufferedReader(缓存区内)类读取文件
import java.io.*;
public class App10_7
{
public static void main(String[] args) throws IOException
{
String thisLine;
int count = 0;
FileReader fr = new FileReader("d:\\Gun.txt");
BufferedReader bfr = new BufferedReader(fr);
while ((thisLine = bfr.readLine())!=null)
{
count++;
System.out.println(thisLine);
}
System.out.println("共读取了"+count+"行");
bfr.close();
}
}10.3.3 使用BufferedReader类写入文件
import java.io.*;
public class App10_8
{
public static void main(String[] args) throws IOException
{
String str = new String();//等价于String str = ""
BufferedReader in = new BufferedReader(new FileReader("d:\\Gun.txt"));
BufferedWriter out = new BufferedWriter(new FileWriter("d:\\Gun.txt"));
while ((str = in.readLine())!=null)
{
System.out.println(str);
out.write(str);//将读取到的一行数据写入到输出流中
out.newLine();//写入回车换行符
}
out.flush();//将缓冲区中的数据全部写入到文件中
in.close();
out.close();
}
}10.4 文件的处理与随机访问
10.4.1 Java语言对文件与文件夹的管理
10.4.2 对文件的随机访问
习题10
1.什么是文件的输入与输出？
答:
向文件写入数据，从文件读取数据
2.什么是流？Java语言中分为哪两种流？这两种流有何差异？
答:
流是指计算机各部件之间的数据流动。
按照数据的传输方向，流可分为输入流与输出流。
对于输入流只能从其读取数据而不能向其写入数据。
对于输出流只能向其写入数据而不能从其读取数据。
3.InputStream、OutputStream、Reader和Writer四个类在功能上有何异同？
答:
InputStream和OutputStream类通常是用来处理位流，也就是二进制文件，但也可以处理纯文本文件；
Reader和Writer类是用来处理字符流，也就是纯文本文件。
第11章 多线程
11.1 线程的概念
11.1.1 程序、进程、多任务与线程
1.程序
含有指令和数据的文件，即静态的代码
2.进程
程序的一次执行过程，动态。
3.多任务
一个系统同时运行多个进程。
4.线程
比进程更小的执行单位，进程执行时可产生多个线程，形成多条执行路径
11.1.2 线程的状态与生命周期
1.新建状态
Thread类或其子类的对象被声明并创建，但还未被执行。
2.就绪状态
新建状态的线程被启动排队
3.运行状态
被调度且获得CPU资源，每一个Thread类及其子类的对象都有run()方法，此时开始执行。在以下情况让出CPU控制权：
- 线程运行完毕
- 有比当前线程优先级更高的线程处于就绪
- 线程主动睡眠
- 线程等待资源
4.阻塞状态
让出CPU并中止自己的执行，此时无法进入就绪状态
- sleep()/yield()
- 等待一个条件变量，调用wait()
- 该线程与另一线程join()在一起
5.消亡状态
①寿终正寝②半道崩殂
11.1.3 线程的调度与优先级
1.调度
在各个线程之间分配CPU资源。分时模型和抢占模型，Java用后者，即优先级高的如果介入，则gg
2.优先级
1~10，MIN_PRIORITY 最小优先级1 MAX_PRIORITY 最高优先级10 NORM_PRIORITY 普通优先级5
新建线程继承父类优先级;
一般情况下，主线程具有普通优先级。
调用线程对象的setPriority()方法可以改变线程优先级
11.2 Java的Thread线程类与Runnable接口
实现多线程的方法：①继承lang包中Thread类②实现Runnable接口
11.2.1 利用Thread类的子类来创建线程
条件:
①此类必是继承自Thread类
②线程执行的代码必须写在run()方法内
class MyThread extends Thread //从Thread类派生子类
{
private String who;//成员变量
public MyThread(String str)//构造方法
{
who = str;
}
public void run() //重写父类Thread里的run()方法
{
for(int i = 0;i<5;i++){
try{
sleep((int)(1000*Math.random()));//sleep方法必须写在try-catch内
}
catch(InterruptedException e){}
System.out.println(who + "正在运行！");
}
}
}
public class DateDemo
{
public static void main(String[] args)
{
MyThread you = new MyThread("你");
MyThread she = new MyThread("她");
you.start();//注意是start而不是run
she.start();
System.out.println("主方法main()运行结束");
}
}设置和获取线程名称
void setName(String name):
String getName()
you.setName("");
she.setName("");
you.start();
she.start();如何得到父类的线程名称？
System.out.println(Thread.currentThread().getName());线程优先级
public final int getPriority() 返回优先级
public final void setPriority(int newPriority) 更改优先级
System.out.println(my1.getPriority());线程默认优先级5，范围是1-10
线程控制
方法名 | 说明 |
static void sleep(long millis) | 执行中线程停留指定毫秒 |
void join() | 等待线程死亡 |
void setDaemon(boolean on) | 标记守护线程，当运行线程全是守护，JVM退出 |
you.start();
you.join(); //逐渐死去，也可以对其做一个异常捕获
Thread.currentThread().setName("刘备");//设置主线程守护线程：
Thread.currentThread().setName("刘备");
for(int i=0;i<10;i++)
{
System.out.println(Thread.currentThread().getName()+i);
}
you.start();
she.start();
you.setDaemon(true)//随刘备自杀，线程死亡前也会挣扎一波
she.setDaemon(true)11.2.2 利用Runnable接口来创建线程
若类本身已经继承某个父类，不允许多重继承，就无法再继承Thread类。
class MyThread implements Runnable
{
private String who;
public MyThread(String str)
{
who = str;
}
public void run()
{
for(int i = 0;i<5;i++){
try{
Thread.sleep((int)(1000*Math.random()));
}
catch(InterruptedException e)
{
System.out.println(e.toString());
}
System.out.println(who + "正在运行!");
}
}
}
public class DateDemo
{
public static void main(String[] args)
{
MyThread you = new MyThread("你");
MyThread she = new MyThread("她");
Thread t1 = new Thread(you);
Thread t2 = new Thread(she);
t1.start();
t2.start();
}
}11.2.3 线程间的数据共享
多个线程执行代码来自同一个类的run()方法，则称它们共享相同代码。
Runnable接口可以轻松实现多个线程共享相同数据
11.3 多线程的同步控制（Synchronized）
11.4 线程之间的通信
习题11
1.简述线程的基本概念，程序、进程、线程的关系是什么？
答:
运行一个进程时，使程序中一些彼此相对独立的代码段可以同时运行，从而获得更高的执行效率的运行单位，称为线程。
线程与进程相似，也是一个执行中的程序，但线程是一个比进程更小的执行单位。一个进程在其执行过程中可以产生多个线程，形成多条执行线路。
2.什么是多线程？为什么程序的多线程功能是必要的？
答:
多线程就是同时执行一个以上的线程，一个线程的执行不必等待另一个线程执行完才执行，所有的线程都可能发生在同一时刻。但操作系统并没有将多个线程看做多个独立的应用，来实现线程的调度和管理以及资源分配。
由于可以共享内存，所以各线程之间的通信速度很快，线程之间进行切换所占用的系统资源也较少。
3.多线程与多任务的差异是什么？
答:
多任务是针对操作系统而言，表示操作系统可以同时运行多个应用程序；
多线程是指一个程序而言的，表示在一个程序内部可以同时执行多个线程。
4.线程有哪些基本状态？这些状态是如何定义的？各状态之间的切换依靠什么方法？这些状态的切换如何形成了线程的生命周期？
答:
新建状态：当一个Thead类或其子类的对象被声明并创建，但还未被执行的这段时间里，处于一个特殊的新建状态中；
就绪状态：也称为可运行状态，处于新建状态的线程被启动后，将进入线程队列排队等待CPU时间，此时它已具备了运行的条件；
运行状态：当就绪状态的进程被调度并获得处理器资源时，进入运行状态；
阻塞状态：一个正在执行的线程如果在某些特殊情况下，如被人为挂起或需要执行输入输出操作时，将让出CPU并暂时中止自己的执行，进入阻塞状态；
消亡状态：不具备继续运行的能力；
各状态之间通过线程的控制与调度进行切换。
新建状态的线程被调度，变成就绪状态，也可以调用stop()方法变成停止状态；
就绪状态等待得到CPU资源后，可以脱离创建它的主线程独立开始自己的生命周期，阻塞状态进入就绪状态；
当就绪状态的进程被调度并获得处理器资源时，进入运行状态；
正常运行线程完成了全部工作或线程被强制性地终止，进入消亡状态。
5.Java程序实现多线程有哪两个途径？
Thread类和Runnable接口。
第12章 泛型与容器类
12.1 泛型
泛型实质上就是将数据类型参数化，通过为类、接口及方法设置类型参数来定义泛型。又被称为参数多态。
12.1.1 泛型的概念
优点：在编译时就可检测出错误
实现：类型参数
泛型类定义：[修饰符] class 类名
泛型接口定义：[public] interface 接口名
泛型方法定义：[public] [static] 返回值类型 方法名(T参数)
12.1.2 泛型类及其应用
public class App12_1<T>
{
private T obj;
public T getObj(){
return obj;
}
public void setObj(T obj)
{
this.obj = obj;
}
public static void main(String[] args)
{
App12_1<String> name = new App12_1<String>();//创建App12_1<String>类对象
App12_1<Integer> age = new App12_1<Integer>();//创建App12_1<Integer>类对象
name.setObj("刘燕鹏");
String newName = name.getObj();
System.out.println("姓名: "+newName);
age.setObj(25);//Java将25包装为new Integer(25)
int newAge = age.getObj();//Java将Integer自动解包为Int
System.out.println("年龄 : " + newAge);
}
}12.1.3 泛型方法
泛型方法存在与否和是否为泛型类无关
public static <E> void display(E[] list){
阿巴阿巴阿巴;
}
main
Integer [] num ={1,2,3,4};
String [] str = {"红","橙","黄"};
App12_2.display(num);
App12_2.display(str);一个static方法无法访问泛型类类型参数，除非先让其变为泛型方法
12.1.4 限制泛型的可用类型
class ClassName<T extends anyClass>//anyClass指类或接口12.1.5 泛型的类型通配符和泛型数组的应用
?:①泛型类创建泛型对象 ②方法参数
?表示某个类或其子类或接口类，创建的对象只能获取or删除，而无法添加信息
泛型类名 <? extends T> o =null;
GeneralType<? extends List> x = null;
GeneralType<? extends List> y = null;
x = new GeneralType<LinkedList>();//LinkedList类实现了List接口
y = new GeneralType<ArrayList>();//ArrayList类实现了List接口12.2 容器类
12.2.1 Java容器框架
两个接口Collection和Set
12.2.2 Collection接口
- 单列集合
- List(元素可重复) ArrayList/LinkedList
- Set(不可重复) HashSet/TreeSet
概述：单例集合的顶层接口，表示一组对象(元素)
创建对象：多态+ArrayList
main
Collection<String> c =new ArrayList<String>();//创建对象
c.add("hello");
c.add("world");
System.out.println(c);
Out:
[hello,world]常用方法:
c.add()//可存储重复元素
c.remove()//移除元素
c.clear()//删除全部元素
c.contains()//判断是否存在指定元素
c.isEmpty()//判断集合是否为空
c.size();//集合内元素个数遍历：
Iterator 迭代器，集合专属
main
···
Iterator<String> it = c.iterator();
//常用方法
it.next();//返回迭代中的下一个元素
it.hasNext()//若迭代有更多元素，则返回True
//改进判断
while(it.hasNext()){
String s =it.next();
System.out.println(s);
}使用步骤：
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6uyn0w7r-1637985235548)(D:\DeskStudyGroup\Java\Pic\集合1.png)]
12.2.3 列表接口List
概述：精确控制元素插入位置与索引访问搜索
main
List<String> list = new ArrayList<String>();
list.add("hello");
list.add("java");
list.add("world");
list.add("java");//证明可重复
Iterator<String> it = list.iterator();
while(it.hasNext())
{
String s = it.next();
System.out.println(s);
}
System.out.println(list);
Out:
hello
world
java
worldList的特有方法(类似ArrayList)
12.2.4 集合接口Set
①哈希值：根据地址字符串or数字算出来的int类型的数值
获取哈希值：
Student s1= new Student();
System.out.println(s1.hashCode());//同一对象多次调用所得哈希值相同②HashSet集合
特点：不保证存储与取出元素一致；不能普通for，可以增强for；底层数据结构是哈希表;不包含重复元素
main
HashSet<String> hs = new HashSet<String>();
hs.add();
for(String s : hs )
{
System.out.println(s);
}类型通配符：<?>
为了表示各种泛型List的父类
List<?> //仅表示各种泛型List的父类，无法添加元素
<? extends/super 类型> //类型通配符上/下限
List<? entends/super Number>//类型为Number或其子/父类型Show
main
List<?> list1 = new ArrayList<Object>();
List<?> list2 = new ArrayList<Number>();
List<?> list3 = new ArrayList<Integer>();
List<? extends Number> list5 =new ArrayList<Number>();//上限限定Number，AL中如果是父类会报错，下限同理12.2.5 映射接口Map
双列集合;HashMap
Interface Map<K,V> K:键的类型 V:值的类型
将键映射到值的对象；不能包含重复键；每个键可以映射到最多一个值
main
Map<String,String> map = new HashMap<String,String>;
map.put("","");
map.put("","");
//put remove clear containsKey containsValue isEmpty size
System.out.println(map);获取功能:
map.get("");//根据键获取值
Set<String[即K]> keySet/values = map.keySet/values();
for (String key:keySet/value:values){System.out.println(key/value)}//获取全部键/值的集合遍历：
Map<String,String> map = new HashMap<String,String>();
map.put();
Set<String> keyset = map.keySet();
for (String key:keySet){
String value = map.get(key);
System.out.println(key+","+value);
}习题12
3.在泛型中，类型通配符的主要作用是什么？
答:
一是用于创建可重新赋值但不可修改其内容的泛型对象，二是用在方法的参数中，限制传入不想要的类型实参.
10.利用HashMap类对象存储公司电话号码簿，其中包含公司的电话号码和公司名称，然后删除一个公司和查询一个公司的操作
import java.util.*;
public class CompanyTel
{
public static void main(String [] args)
{
HashMap<String ,String> hm=new HashMap<String,String>();
hm.put("1234", "嘉世");
hm.put("12345", "霸图");
hm.put("123456", "兴欣");
hm.remove("12345");
System.out.println(hm.get("123456"));
}
}第13章
13.1 图形用户界面概述
GUI(图形用户接口)
主要的包:java.awt和javax.swing
AWT(抽象窗口工具集)
13.2 图形用户界面工具包——Swing
13.2.1 Swing组件分类
组件(构成GUI的各种元素)：容器类、辅助类、组建类
顶层容器[JFrame,JApplet,JDialog]和非顶层容器[JPanel]
一般框架用JFrame,放置JPanel控制布局，浏览器的话咱就Applet完事儿
JFrame是带标题且可改变大小的窗口，JDialog无标题栏且无法独立存在，必须包含在另一个容器内
1.Swing容器的层次关系
2.框架类JFrame
import java.awt.*;
import javax.swing.*;
public class App13_1{
public JFrame jfrm = new JFrame("这是个Swing程序");//创建静态框架并设置标题
public static void main (String args[])
{
JLable lab = new JLable("俺是一个标签儿");
Image im = (new ImageIcon("邓紫棋.jpg")).getImage();//创建图标对象im
jfrm.setIconImage();
jfrm.setSize(250,140);
jfrm.setBackground(Color,WHITE);
jfrm.setLocation(260,150);//设置窗口的位置
jfrm.add(lab);//将标签对象加入窗口中
jfrm.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);//单击窗口的关闭按钮结束程序
jfrm.setVisible(true);//显示窗口
}
}3.面板类
无标题栏无边框中间层容器，默认透明，可用JComponent包中的setOpaque(true)方法设置不透明
import javax.swing.*;
import javax.swing.border.TitledBorder;
public class A1_1{
public static void main(String args[])
{
JFrame jfrm = new JFrame("塔塔开！");
jfrm.setSize(210,180);
jfrm.setLocation(500,400);
JPanel jpan = new JPanel();//创建面板对象jpan
jpan.setSize(120,90);
jpan.setLocation(40,30);
JButton bun = new JButton("Click Me!");//创建按钮对象bun
bun.setSize(80,20);
bun.setLocation(20,30);
jfrm.setLayout(null);//取消jfrm的默认布局管理器
jpan.setLayout(null);//取消jpan的默认布局管理器
jpan.add(bun);//将命令按钮加入面板
jpan.setBorder(new TitledBorder("小面板儿"));
jfrm.add(jpan);//将面板加入框架
jfrm.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
jfrm.setVisible(true);
}
}/*文本复制*/
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class Person {
public static void main(String args[]) {
JFrame fr = new JFrame();
fr.setLayout(new FlowLayout(FlowLayout.LEFT));
final JTextArea textArea1 = new JTextArea(20, 30);
final JTextArea textArea2 = new JTextArea(20, 30);
JButton button = new JButton("=>");
button.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent event) {
textArea2.setText(textArea1.getText());
}
});
fr.add(textArea1);
fr.add(button);
fr.add(textArea2);
fr.pack();
fr.setVisible(true);
}
}13.3 创建组件
13.3.1 标签JLable
13.3.2 命令按钮JButton,复选框JCheckBox,单选按钮JRadioButton
13.3.3 文本编辑组边与滚动窗格
13.3.4 选项卡窗格JTabbedPane
13.4 布局管理器
习题13
1.Swing组件分为哪三类
答:
容器类、辅助类、组件类
2.Swing的顶层容器包含哪些窗格？大部分的可见组件都放在哪个窗格内？
答:
Swing 的顶层容器主要有 JFrame、JApplet 和 JDialog 等；
内容窗格;
3.框架组件与面板组件的区别有哪些？
答:
以 JFrame 为代表的框架是一种带标题栏并且可以改变大小的窗口，而以 JPanel 类为代表的面板类与窗口类似，但它是一种没有标题栏的容器，且不能独立存在，必须包含在另一个容器之中
4.颜色类 Color 中提供了哪些表示颜色的变量?
答:
变量名 | 代表颜色 |
black | 黑 |
blue | 蓝 |
yellow | 黄 |
white | 白 |
gray | 灰 |
green | 绿 |
red | 红 |
orange | 橘黄 |
pink | 粉 |
5. 字体类 Font 的主要用途有哪些？
答:
字体类 Font 是 java.awt包中的类，是用来设置组件所用字体的样式、大小与字形等属性的
6.图像图标类 ImageIcon 的主要作用是什么？Java 语言当前支持哪三种图像格式？
答:
图像图标类 ImageIcon 的主要作用是用来装饰组件的；
Java 语言当前支持三种图像格式：GIF、JPEG 和 PNG，这三种图像文件的扩展名分别 gif、jpg 和 png
7.Swing 主要用来处理文字输入的组件有几个？这几个组件有何不同点？
答:
文本编辑组件分为三种：
第一种是单行文本编辑组件，简称文本行，也称文本框，是通过 JTextField 类实现的；
第二种是密码文本行组件，是通过 JPasswordField 类实现的；
第三种是多行文本编辑组件，简称文本区，是通过 JTextArea 类实现的。
8.在将组件添加到窗口中时，为什么需将组件设置为不透明状态才能将其底色显现出来？
答:
因为 JFrame 的框架一旦被创建，其中就已经包含一个内容窗格，设置的 JFrame 背景颜色，仍然会被内容窗格遮盖，由框架内容窗格的委托特性可知，在往 JFrame 中添加组件时，组件都加在了内容窗格中。
