# 基本语法
## java基本数据类型
1. 数值型
* 整数类型：byte(8)、short(16)、int(32)、long(64)
* 浮点类型：float、double <strong>(double，双精度数值，表示的数据类型是float类型的双倍)</strong>
2. 字符型：char ('a')
3. 布尔型：boolean (true,false)
注意：
1. JAVA默认正数类型是int类型，如果需要声明正数是long类型，必须在数字末尾添加字母“L”
long lon = -1245L；
2. float类型数值要以F作为后缀，没有后缀，默认为double类型；
## 数据类型转换
1. <strong>自动类型转换:低精度向高精度类型转换，适合于整数类型和浮点类型</strong>
byte类型-short类型-int类型-long类型-float类型-double类型
2. <strong>强制类型转换：高精度向低精度类型转换</strong>
注意：boolean不能被强制转换为其他数据类型，反之亦然
## 赋值运算符
自增自减运算符：
++X：先将变量X的值+1，然后再引用该变量的值参与运算
X++：先将引用的变量参与表达式的运算，然后再将其做+1处理
```java
public calss Operation{
public static void main(String[] args){
int m=5;
int b=m++;
System.out.println("变量b的值为："+b); // 5
System.out.println("变量m的值为："+m); //6
}
}
```
## 变量与常量
变量：type 标识符 int age；
常量：final type 变量名称[=值] final float PI=3.1415926f；
## 变量的有效范围
1. 成员变量（全局变量）：定义在类体中，有效范围是整个类的代码段。在类体中的任何位置都可使用该变量。
* 静态变量：
1. 有效范围是整个类，被类的所有实例共享。
2. 使用static定义，调用变量，通过“类名.变量名”方式访问。
```java
public calss Variable{
static int age=5;
public static void main(String[] args){
int m=5;
int b=m++;
System.out.println("静态变量值为："+Variable.age); // 5
}
}
```
* 实例变量:
1. 与类的实例对应，有效范围为整个实例。
```java
public calss Student{
public static int amount=50;
public int average=18;
public static void main(String[] args){
Student stu = new Student();
System.out.println("班级人数为："+Student.amount); // 50
System.out.println("平均年龄为："+stu.average); // 18
}
}
```
2. 局部变量:
* 局部变量只在当前代码块才有效，不能用于其他类的方法中。
* 局部变量可与全局变量的变量名称相同，此时全局变量将被隐藏，可以使用“this”关键字访问局部变量。
```java
public calss Student{
static String words = "全局变量";
public void getStu(){
String words ="局部变量";
System.out.println("words变量现在是：" + words); // 局部变量
System.out.println("访问全局变量：" + this.words); // 全局变量
}
public static void main(String[] args){
Student stu = new Student();
stu.getStu();
}
}
```
# 流程控制语句
## if条件判断语句
1. 简单的if条件语句
```java
if(关系表达式){
复合语句
}
```
```java
public calss IfExercise{
public static void main(String[] args){
float price=60.89f;
if(price<100){
System.out.println("价格可以接受");
}
System.out.println("over");
}
}
```
2. if...else语句
```java
if(条件表达式){
复合语句1
}
else{
复合语句2
}
```
```java
public calss IfElseExercise{
public static void main(String[] args){
float price=60.89f;
if(price<100){
System.out.println("价格可以接受");
}else{
System.out.println("太贵了，拒绝购买");
}
System.out.println("over");
}
}
```
<strong>注意：if...else语句可使用三元运算符代替，if(price<100)?"价格可接受":"太贵了，拒绝购买"</strong>
3. if...else if多分支语句
```java
if(条件表达式1){
复合语句1
}
else if(条件表达式2){
复合语句2
}
...
else if(条件表达式n){
复合语句n
}
```
```java
public calss Verdict{
public static void main(String[] args){
int number=14;
if(number>20){
System.out.println("变量number大于20");
}else if(number>10){
System.out.println("变量number大于10小于20");
}else if(number>0){
System.out.println("变量number大于0小于10");
}else{
System.out.println("变量number小于等于0");
}
}
}
```
## switch语句
```java
switch(条件表达式){
case 常量表达式1:
语句块1
[break;]
...
case 常量表达式n:
语句块n
[break;]
default;
语句块n+1;
[break;]
}
```
1. 条件表达式为必要参数；
2. 常量表达式必须与条件表达式类型相兼容的值；
3. 语句块：可选参数，一条或多条语句，不需要大括号。当表达式的值域常量表达式的值匹配时执行，否则继续判断其他值，直到常量表达式n；
4. break:可选参数，用于跳出switch语句；
5. default:可选参数，如果没有该语句，switch语句不与任何case语句常量值相同时，不做任何处理。
```java
public calss SwitchExercise{
public static void main(String[] args){
int week=3;
switch(week){
case 1:
System.out.println("周一");
break;
case 2:
System.out.println("周二");
break;
case 3:
System.out.println("周三");
break;
default:
System.out.println("I dont't know");
}
}
```
注意：如果不加break，则匹配之后，会继续判断并执行其他case。比如，上述例子中，去除break之后，则会打印“周三”和"I dont't know"。
## 循环语句
1. for循环语句
```java
for(初始化语句;循环语句;迭代语句){
语句序列
}
```
```java
public calss CountSum{
public static void main(String[] args){
int sum=0;
for(int i=1;i<=100;i++){
sum+=i;
}
System.out.println("1~100的和为："+sum);
}
}
```
2. while循环语句:先进行条件判断，再执行循环体中的内容。
```java
while(条件表达式){
循环体
}
```
```java
public calss GetSum{
public static void main(String[] args){
int x=1;
int sum=0;
while(x<=10){
sum+=x;
x++;
}
System.out.println("1~10的和为："+sum);
}
}
```
3. do...while循环语句:先执行循环体中的内容，再进行条件判断，如果条件不满足，则不执行循环体中内容，即循环体中内容至少执行一次。
```java
do{
语句序列
}while(条件表达式);
```
```java
public calss Cycle{
public static void main(String[] args){
int number=100;
while(number==60){
System.out.println("使用while循环");
number--;
}
do{
System.out.println("使用do...while循环");
number--;
}while(number==60);
}
}
```
## 结束本次循环的continue语句
1. continue语句用于终止当前循环，返回到循环开始处，接着开始新的循环；
2. continue语句只能出现在循环语句：while、for、do...while语句中；
```java
public calss Continue{
public static void main(String[] args){
System.out.println("可以被10整除的数有:");
for(int i=1;i<=100;i++){
if(i%10!=0){
continue;
}
System.out.println(i+"、");
}
}
}
```
## 强行退出循环的break语句
1. 中途中断循环执行，可使用break强迫跳出循环；
2. continue语句可出现在循环语句：while、for、do...while语句中；
```java
public calss BreakPractice{
public static void main(String[] args){
int sum=0;
int control=0;
while(true){
control++;
if(control>100){
System.out.println("1~100所有整数的和是:"+sum);
break;
}
sum+=control;
}
}
}
```
## 循环中使用标签
1. 指定程序跳转至哪一行。
2. 使用break只能退出当前循环，如果想通过break语句退出嵌套的循环时，需要使用带标签的break语句实现。
3. break和continue都可以配合标签使用。
```java
标签名称: //标签名称的命名规则与变量的命名规则一致，可添加到程序的任意位置
```
```java
public calss Multiplication{
public static void main(String[] args){
loop:
for(int i=1;i<=9;i++){
for(int j=1;j<=i;j++){
System.out.println(i+"*"+j+"="+i*j+" ");
if(j==5){
break loop;
}
}
System.out.println();
}
}
}
```
注意：
1. for循环主要针对有限循环而言，也就是说，循环有上限的时候，一般使用for循环；
2. while循环则针对无限循环的代码而言，当程序没有明确的上限，则一般使用while循环。
# 数组
## 一维数组
1. 创建数组的语法格式
```java
数组类型 数组名[];
或
数组类型[] 数组名;
```
```java
// 如：
int arr[];
char arr[];
```
```java
// 为数组分配内存空间的格式如下：
数组名字 = new 数组类型[数组长度];
// 如：
int[] arr = new int[5];
```
2. 数组初始化
```java
// 第一种初始化方式
int arr[] = new int[] {1,3,5,7};
// 第二种初始化方式
int arr[] = {1,3,5,7};
```
```java
int arr[] = new int[4];
int arr[0]=1;
int arr[1]=3;
int arr[2]=5;
int arr[3]=7;
```
3. 遍历一维数组
```java
public calss SearchArray{
public static void main(String[] args){
int day[]=new int[]{31,28,31,30,31};
for(int i=0;i<5;i++){
System.out.println((i+1)+"月有"+day[i]+"天");
}
}
}
```
```java
// length表示数组长度
public calss SearchArray{
public static void main(String[] args){
int day[]=new int[]{31,28,31,30,31};
for(int i=0;i<day.length;i++){
System.out.println((i+1)+"月有"+day[i]+"天");
}
}
}
```
##二维数组
1. 声明数组对象的语法格式
```java
数组类型 数组名[][];
或
数组类型[][] 数组名;
```
```java
// 如：
int arr[][];
char arr[][];
```
```java
// 为数组分配内存空间的格式如下：
数组名字 = new 数组类型[数组长度][数组长度];
// 如：
int arr[][] = new int[5][5];
```
2. 二维数组初始化
```java
数组类型 变量名称 [][]={
{value1,value2,value3...valuen},
{value1,value2,value3...valuen}
...
}
// 如:
int arr[][]={{23,12,2},{12,45}} ;
// arr[1]的第一个元素赋值为12:
arr[1][0]=12;
```
3. 使用嵌套的for循环语句遍历二维数组
```java
public calss CountMark{
public static void main(String[] args){
int grades[][]={
{77,68,86,73},
{96,87,89,81},
{70,90,86,81}
} ;
int lowGrade = grades[0][0];
for(int i=0;i<grades.length;i++){
for(int column=0;column<grades[i].length;column++){
if(grades[i][column]<lowGrade)
lowGrade=grades[i][column];
}
}
int highGrade = grades[0][0];
for(int j=0;j<grades.length;j++){
for(int column=0;column<grades[j].length;column++){
if(grades[j][column]>highGrade)
highGrade=grades[j][column];
}
}
System.out.println("最低分数为:"+lowGrade);
System.out.println("最高分数为:"+highGrade);
}
}
```
4. 使用嵌套的for循环语句遍历二维数组
```java
public calss CountMark{
public static void main(String[] args){
int grades[][]={
{77,68,86,73},
{96,87,89,81},
{70,90,86,81}
} ;
int lowGrade = grades[0][0];
for(int i=0;i<grades.length;i++){
for(int column=0;column<grades[i].length;column++){
if(grades[i][column]<lowGrade)
lowGrade=grades[i][column];
}
}
int highGrade = grades[0][0];
for(int j=0;j<grades.length;j++){
for(int column=0;column<grades[j].length;column++){
if(grades[j][column]>highGrade)
highGrade=grades[j][column];
}
}
System.out.println("最低分数为:"+lowGrade);
System.out.println("最高分数为:"+highGrade);
}
}
```
5. 使用foreach遍历二维数组
```java
for(元素变量:遍历对象){
循环体
}
```
```java
// 一维数组遍历
int[] array={12,34,43,22,13,58};
for(int i :array){
System.out.println(i);
}
```
```java
// 使用嵌套foreach循环语句遍历二维数组
public calss ArrayForEach{
public static void main(String[] args){
int array[][]={{1,2,3},{7,8,9},{13,14,15}};
for(int[] is:array){
for(int is2:is){
System.out.println(is2+"\t");
}
System.out.println();
}
}
}
```
## 使用sort() 方法实现数组排序
1. 语法：
```java
Arrays.sort(array)
```
2. example：
```java
public static void main(String[] args){
int arr[]=new int[]{61,30,52,40,12,21};
System.out.println("声明的数组原有内容如下：");
for (int i = 0; i < arr.length; i++){
System.out.println(arr[i]+"\t");
}
System.out.println("\n排序后的数组内容如下：");
Arrays.sort(arr);
for (int i = 0; i < arr.length; i++){
System.out.println(arr[i]+"\t");
}
}
```
##复制数组
1. Arrarys类的copyOf()方法：
```java
// 语法
copyOf(arr,int newlength)
注意：
如果新数组的长度，大于数组arr的长度，则用0填充。
根据复制数组的类型来决定填充的值，整型数组用0填充，char型数组则会使用null填充。
如果复制后的数组长度小于数组arr的长度，会从数组arr的第一个元素开始，截取至满足新数组长度为止。
```
```java
public static void main(String[] args){
int arr[]=new int[]{61,30,52};
int newarr[]=Arrays.copyOf(arr,6);
System.out.println("复制后新数组的元素为:");
for (int i = 0; i < newarr.length; i++){
System.out.println(newarr[i]+"");
}
}
```
2. Arrarys类的copyOfRange()方法：
```java
// 语法
copyOfRange(arr,int formIndex,int toIndex)
注意：
formIndex:开始复制数组的索引位置，formIndex必须在0与整个数组的长度之间。新数组包括索引是formIndex的元素。
toIndex:复制范围的最后索引位置，可以大于数组arr的长度，新数组不包括索引是toIndex的元素。
```
```java
public static void main(String[] args){
int arr[]=new int[]{61,30,52,23,47};
System.out.println("原数组的元素为:");
for (int i = 0; i < arr.length; i++){
System.out.println(arr[i]+"");
}
int newarr[]=Arrays.copyOfRange(arr,0,4);
System.out.println("复制后的元素为:");
for (int i = 0; i < newarr.length; i++){
System.out.println(newarr[i]+"");
}
}
```
# 类与对象
## 类的定义
1. 声明类的具体语法格式：
``` java
class className{
成员变量
...
成员方法
...
}
```
``` java
public class Person{
int age;
public void say(){
System.out.println("在类体中定义的方法");
}
}
```
## Java中的类包
1. 如何定义包:
```java
package 包名；
```
将类Person定义在包com.cdd.util中：
```java
package com.cdd.util;
public class Person{
int age;
... // 省略类体中的其他代码
}
```
2. 实现在类中导入包：
在每个类名之前添加完整的包名：
```java
java.util.Date date=new java.util.Date();
```
import语句引入包中的类：
```java
import com.wgh.Circ;
```
```java
import com.wgh.*;
```
## Java中的类
1. 成员方法
成员方法定义了Java类的行为，类的成员方法由方法的声明和方法体两部分组成。
```java
[修饰符]<方法返回值的类型><方法名>([参数列表]){
[方法体]
}
```
```java
public class Person{
public void print(){ //在类中定义成员方法
System.out.println("类的成员方法！！");
}
}
```
2. 静态方法
在使用成员变量和成员方法时，必须通过对象才能访问。静态方法则不同，直接通过类名就能调用，或者通过类的实例来调用，还可以在类的非静态方法中像访问其他非静态方法一样去访问静态成员方法。
```java
[修饰符]<方法返回值的类型><方法名>([参数列表]){
[方法体]
}
```
```java
public class Chinese {
public static void say() { //创建静态方法
System.out.println("JavaClass类中的静态方法！");
}
public void sing(){
System.out.println("JavaClass类中的非静态方法！");
}
}
```
```java
public class TestChinese {
public static void main(String[] args){
Chinese.say(); //调用Chinese类的静态方法
Chinese javaClass =new Chinese(); //创建Chinese类对象
javaClass.sing(); //调用Chinese类的非静态方法
javaClass.say(); //调用Chinese类的静态方法
}
}
```
3. 静态块
静态块是指不包含在任何方法体中的静态代码块，应用static关键字包围。当类被加载时，静态块就会被执行且只被执行一次。
```java
public class Test {
static{
int age=32;
System.out.println("int类型变量中age的值为："+age);
}
public static void main(String[] args){
new Test();
new Test();
}
}
```
4. 权限修饰符
private:成员变量只能在本类中使用,在子类中不可见，并且对其他包的类也是不可见的
public:不仅可以在本类中使用，在子类和其他包的类也可以使用
protected:只有本包内的该类的子类或其他类可以访问此类中的成员变量和成员方法
5. 方法重载
在一个类中，出现多个方法名相同，但参数个数或者参数类型不同的方法，Java在执行具有重载关系的方法时，将根据调用参数的个数和类型区分具体执行的是哪个方法。
```java
public class Calculate {
final float PI = 3.14159f;
public float getArea(float r) {
float area = PI * r * r;
return area;
}
public float getArea(float l, float w) {
float area = l * w;
return area;
}
public void draw(int num) {
System.out.println("画" + num + "个任意形状的图形");
}
public void draw(String shape) {
System.out.println("画一个" + shape);
}
public static void main(String[] args) {
Calculate calculate = new Calculate();
float l = 20;
float w = 30;
float areaRectangle=calculate.getArea(l, w);
System.out.println("长为"+l+"，宽为"+w+"，的矩形面积是："+areaRectangle);
float r=7;
float areacirle=calculate.getArea(r);
System.out.println("半径为"+r+"，的圆形面积是："+areacirle);
int num=7;
calculate.draw(num);;
calculate.draw("三角形");
}
}
```
6. 构造方法
构造方法是一种特殊的方法，它的名字必须与它所在的类的名字完全相同，并且没有返回值，也不需要使用void进行标识，在方法中不能用return语句返回一个值。构造方法用于对对象中的所有成员变量进行初始化，在创建对象时立即被调用。一个类中可以有多个构造方法。
```java
package com.practice;
public class Fruit {
public String color;
public Fruit(){ //定义构造方法
color="绿色";
}
public void harvest(){
String color="红色";
System.out.println("水果是："+color+"的！");
System.out.println("水果已经收获～");
System.out.println("水果原来是："+this.color);
}
public static void main(String[] args) {
Fruit fruit=new Fruit();
fruit.harvest();
}
}
```
7. 对象
```java
类名 对象名=new 类构造方法();
```
构造方法：是类创建对象时必须执行的方法，用于构造一个新的对象并初始化对象属性；
8. 匿名对象
```java
Calculate calculate = new Calculate();
calculate.draw();
new calculate.draw();
```
# 字符的集合-字符串
## 创建字符串
1. 产生String对象
```java
String str=new String("java编程词典"); //使用String类的构造方法创建字符串对象
String str="java编程词典"; //指定运算
```
2. 获取字符串的长度
```java
str.length();
```
```java
package com.practice;
public class GetLength {
public static void main(String[] args) {
String name="一棵椰子树";
String address="一座孤岛上";
String message="在"+address+"有"+name;
System.out.println("字符串"+name+"\t\t长度为："+name.length()); //字符串一棵椰子树 长度为：5
System.out.println("字符串"+address+"\t\t长度为："+address.length()); //字符串一座孤岛上 长度为：5
System.out.println("字符串"+message+"\t\t长度为："+message.length()); //字符串在一座孤岛上有一棵椰子树 长度为：12
}
}
```
3. 对字符串进行截取
```java
str.substring(int beginIndex) //指定从某一索引处开始截取字符串
```
```java
String str="Hello World";
String substr=str.substring(3); //lo World
```
```java
substring(int beginIndex,endIndex) //返回从字符串某一索引位置开始截取，至某一索引位置结束的子字符串
```
```java
String str="Hello World";
String substr=str.substring(0，7); //Hello W 不包含endIndex这个索引位置的字符
```
4. 分割字符串
```java
str.split(String sign) //根据给定的分隔符对字符串进行拆分
sign:分割字符串的分隔符，也可以使用正则表达式
```
```java
str.split(String sign,int limit) //根据给定的分隔符对字符串进行拆分，并限定拆分的次数
```
```java
package com.practice;
public class SubString {
public static void main(String[] args) {
String str = "公司名称：明日科技！公司所在城市：长春市。公司电话：********";
String[] info = null;
info = str.split("！|。");
for (int i = 0; i < info.length; i++) {
System.out.println(info[i]);
}
}
}
```
5. 去除字符串尾部空格
```java
str.trim()
```
6. 查找字符串
```java
str.indexOf(ch) //用于获取字符串中指定字符第一次出现处的索引，若字符没有出现则返回-1
```
```java
str.lastindexOf(ch) //用于获取字符串中指定字符最后一次出现处的索引，若字符没有出现则返回-1
```
```java
str.indexOf(substr) //用于获取字符串中指定字符串首次出现的索引位置，如果子字符串作为该字符串的子字符串出现，则返回该子字符串的第一个字符的索引，如果没有作为一个子字符串出现则返回-1
```
```java
str.lastindexOf(substr) //用于获取字符串中指定字符串最后一次出现的索引位置，如果子字符串作为该字符串的子字符串出现了一次或更多次，则返回最后一次出现该子字符串的第一个字符的索引，如果没有作为一个子字符串出现则返回-1
```
```java
indexOf(ch,startIndex) //根据指定的搜索起点，搜索指定字符首次出现的位置
ch:一个字符，unicode代码点
```
```java
int lastindexOf(ch,startIndex) //根据指定的搜索起点，搜索指定字符最后一次出现的位置
ch:一个字符，unicode代码点
```
7. 比较字符串是否相等
```java
boolean equals(String str) //严格区分大小写
boolean equalsIgnoreCase(otherString) //不区分大小写
```
# 继承与多态
## 父类与子类
1. 定义子类
```java
[修饰符]class 子类名 extends 父类名
修饰符：可选参数，用于指定类的访问权限，可选值为：public，abstract，final
子类名：必须参数，一般要求首字母大写
```
```java
package com.practice;
public class Car {
public String color="黑色";
public int speed=1;
public int level;
public void gear(int num){
level=num;
speed=10*level*level;
}
public void driver(){
System.out.println("我是一辆"+color+"的轿车。");
System.out.println("现在以时速"+speed+"公里每小时的速度形式中。");
System.out.println("车档位是"+level+"档。");
}
}
```
```java
package com.practice;
public class SonCar extends Car {
public static void main(String[] args){
SonCar sonCar=new SonCar();
sonCar.gear(5);
sonCar.driver();
}
}
```
```
--------------
我是一辆黑色的轿车。
现在以时速250公里每小时的速度形式中。
车档位是5档。
--------------
```
2. 子类覆盖父类
```
1. 方法的覆盖也叫做方法的重写，被覆盖的方法必须和覆盖方法具有相同的方法名称、参数以及返回值类型；
2. 子类不能覆盖父类中声明为final或者static的方法；
3. 子类必须覆盖父类中声明为abstract的方法，或者子类也将该方法声明为abstract；
4. 子类覆盖父类中的同名方法时，子类中方法的声明也必须和覆盖中被覆盖的方法的声明相同；
5. 子类的访问权限必须要比父类的访问权限大；
```
```java
package com.practice;
public class Person {
public String name;
public int age;
public void getInfo(){
System.out.println("姓名为："+name);
System.out.println("年龄为："+age);
}
}
```
```java
package com.practice;
public class Worker extends Person{
String company;
public void getInfo(){
System.out.println("姓名为："+name);
System.out.println("年龄为："+age);
System.out.println("公司为："+company);
}
public static void main(String[] args){
Worker worker=new Worker();
worker.name="张三";
worker.age=18;
worker.company="科技公司";
worker.getInfo();
}
}
```
3. super关键字
如果在子类中想调用父类中被覆盖的方法，可以使用super关键字。
* 使用super关键字操作父类中被覆盖的方法
如果要在子类中使用被父类隐藏的成员变量或方法，就可以使用super关键字。
例如访问父类的成员变量x：
```java
super.x
```
例如访问父类中的方法play(),代码为：
```java
super.play()
```
```java
package com.practice;
public class Worker extends Person{
String company;
public void getInfo(){
super.getInfo();
System.out.println("公司为："+company);
}
public static void main(String[] args){
Worker worker=new Worker();
worker.name="张三";
worker.age=18;
worker.company="科技公司";
worker.getInfo();
}
}
```
* 使用super关键字操作父类中被覆盖的方法调用父类的构造方法
子类并不继承父类的构造方法。如果子类要使用父类的构造方法，需要使用super关键字，并且一定要在子类的构造方法中使用。
```java
super([构造参数列表])
```
4. 方法重载
在一个类中，出现多个相同名称的方法，但是参数类型与参数个数不相同。
# 接口与抽象类
## 接口
1. 接口定义
```java
[修饰符]interface 接口名 [extends 父接口名列表]{
[public][static][final] 常量；
[public][abstract]方法；
}
```
```java
public interface Calculate{
final float PI=3.14159f;
float getArea(float r);
float gerCircumference(float r);
}
```
2. 实现接口
在实现接口时，一次则可以实现多个接口，每个接口间使用逗号分隔。
```java
[修饰符] class <类名> [extends 父类名] [implemennts 接口列表]{
}
```
```java
package com.practice;
public interface Calculate1 {
final float PI=3.14159f;
float getArea(float r);
float getCircumference(float r);
}
```
```java
package com.practice;
public class Round implements Calculate1 {
@Override
public float getArea(float r) {
float area = PI * r * r;
return area;
}
@Override
public float getCircumference(float r){
float circumference=2*PI*r;
return circumference;
}
public static void main(String[] args){
Round round=new Round();
float r=3f;
float area=round.getArea(r);
float circumference=round.getCircumference(r);
System.out.println("半径为："+r+"的圆的面积为："+area);
System.out.println("半径为："+r+"的圆的周长为："+circumference);
}
}
```
3. 定义抽象类
抽象类只声明方法的存在，而不去具体实现它的类。
抽象类不能被实例化，不能使用new关键字来创建对象。
使用抽象类的好处在于，当有的方法在父类中不想实现时，可以不用实现。
```java
abstract class 类名{
类体
}
```
```java
abstract class Fruit{
public String color;
public Fruit(){
color="绿色";
}
}
```
4. 解析抽象方法
在一个抽象类中，可以定义一个或多个抽象方法；
定义抽象方法需要在方法的声明处使用关键字abstract.
```java
abstract <方法返回值类型> 方法名(参数列表);
```
```java
public abstract void harvest();
```
```java
package com.practice;
abstract class Fruit1 {
public String color;
public Fruit1() {
color = "绿色";
}
public abstract void harvest();
}
```
```java
package com.practice;
public abstract class Apple extends Fruit1{
public String color;
public Apple(){
color="绿色";
}
public abstract void harvest();
}
```
```java
package com.practice;
public class Pear extends Fruit1{
public void harvest(){
System.out.println("大白梨成熟啦！");
}
}
```
```java
package com.practice;
public class Farm {
public static void main(String[] args) {
Apple apple= new Apple() {
@Override
public void harvest() {
System.out.println("大苹果成熟啦！");
}
};
apple.harvest();
Pear pear=new Pear();
pear.harvest();
}
}
```
5. 创建内部类
一个类定义在另一个类的内部，那么就称之为内部类，也叫做嵌套类。
在类中直接定义的内部类的使用范围，仅限于这个类的内部。
例如，在类A中定义了类B，那么类B为类A所知，但却不被A的外部所知。
在内部类中可以引用它所在的外部类的所有变量和方法。
内部类可以使用private或protected来修饰。
```java
package com.practice;
public class Outer {
private String strOut = "我是外部类中的变量";
private void test() {
Inner inner = new Inner();
inner.transfer();
}
class Inner {
void transfer() {
System.out.printf("在内部类中调用外部类中变量: %s", strOut);
}
}
public static void main(String[] args) {
Outer outer = new Outer();
outer.test();
}
}
```
# 集合
## collection集合
1. Collection集合
collection集合又称为容器，他们与数组不同，数组的长度是固定的，集合的长度是可变的，数组用来存放基本类型的数据，集合用来存放类对象的引用。
2. collection接口
collection接口是List接口和Set接口的父接口，通常情况下不被直接使用。
3. collection接口中的常用方法
* add()方法 向指定的集合中添加对象。
```java
package com.practice;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class Append {
public static void main(String[] args){
Collection list=new ArrayList();
list.add("apple");
list.add("pear");
list.add("apple");
Iterator it=list.iterator();
System.out.println("集合中的元素有：");
while (it.hasNext()){
String str=(String)it.next();
System.out.println(str);
}
}
}
```
* addAll()方法 将指定集合中的所有对象都添加到集合中，如果对该集合进行了泛化，则要求指定集合中的所有对象都符合泛化类型，否则编译程序时将抛出异常。
```java
package com.practice;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class AddGather {
public static void main(String[] args){
String apple="Apple";
String pear="Pear";
String orange="Orange";
Collection<String> list =new ArrayList<String>();
list.add("apple");
list.add("pear");
list.add("orange");
Collection<String> list2 =new ArrayList<String>();
list2.addAll(list);
Iterator<String> it=list2.iterator();
System.out.println("集合中的对象为：");
while(it.hasNext()){
String str=it.next();
System.out.println(str);
}
}
}
```
4. iterator() 方法 在指定的集合对象中创建迭代器，返回在此Collection的元素上进行迭代的迭代器。当获取迭代器后，通过迭代器Iterator对象的hasNext()方法，判断集合中是有仍有元素可以迭代，如果有则返回true，否则返回false。hasNext()方法通常被用在循环语句中，作为判断循环的条件。
5. removeAll()方法 用来从该集合中移除同时包含在指定参数集合中的对象。如果集合中包含符合条件的对象，则返回true，否则返回false。
```java
package com.practice;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class RemoveCollection {
public static void main(String[] args){
Collection <String> list=new ArrayList<String>();
list.add("Java编程词典");
list.add("C++编程词典");
list.add("VB编程词典");
list.add("C#编程词典");
list.add(".net编程词典");
Iterator<String> it=list.iterator();
System.out.println("集合中原有的对象为：");
while(it.hasNext()){
String obj=(String)it.next();
System.out.println(obj);
}
Collection <String> list2=new ArrayList<String>();
list2.add(".net编程词典");
list2.add("C#编程词典");
list.removeAll(list2);
Iterator<String> it2=list.iterator();
System.out.println("移除指定对象后集合中的对象为：");
while(it2.hasNext()){
String obj=(String)it2.next();
System.out.println(obj);
}
}
}
```
```
--------------------
集合中原有的对象为：
Java编程词典
C++编程词典
VB编程词典
C#编程词典
.net编程词典
移除指定对象后集合中的对象为：
Java编程词典
C++编程词典
VB编程词典
--------------------
```
## List集合
List集合包括List接口与List接口的所有实现类。List接口继承Collection接口，因此具有该接口的所有方法。List集合中的对象允许重复。Set集合中的对象没有顺序。Map集合是按照Key-value形式进行存储的。
1. List接口
List集合为列表类型，以线性方式存储对象，可以通过对象的索引操作对象。因此该接口中包含一些与索引相关的方法。
2. ArrayList类
ArrayList类实现了List接口，由ArrayList类实现的List集合采用数组结构保存对象。
3. LinkedList类
LinkedList类实现了List接口，用LinkedList类实现的List集合采用链表结构保存对象。
## Set集合
Set集合为集类型，集时最简单的一种集合，存放于集中的对象不按特定方式排序，只是简单地把对象加入集合中，类似于向口袋中放东西。不能存放重复对象。
## Map集合
Map没有继承Collection接口，其提供的是key到value的映射。Map中不能包含相同的key值，每个key只能映射一个value。
1. Map接口
Map接口提供了将键映射到值的对象，集合中不能包含重复的键。
2. HashMap类
HashMap类实现了Map接口，由HashMap类实现的Map集合，允许以null作为键对象，但是因为健对象不可以重复，所以这样的键对象只能有一个。
3. TreeMap类
