Java课程期末复习学习总结
JAVA课程学习总结 知识点总结
文章目录 常用DOS命令数组正则表达式继承多态 抽象类与接口的异同点 集合框架 内置API 文件
如何与连接 1.前期准备
：/JAVA-: JAVA- ()
1选择 ，选择，点击Add Entry
添加自己的name 和 email
然后生成公钥私钥
复制一下
接下来打开
点击
然后如图操作
输入title和key
key就是之前复制的公钥
2.远程建库
远程仓库new一个
取名
复制SSH 等一下要用到
3.本地操作
1.先新建一个
2.然后new一个class
取个名字，然后最好勾上圈出来的
接下来写代码
提交到本地仓库
然后再
点击你要上传的，通常后缀是.java
再点击2处的绿的加号
然后再3处随便写点东西
最后点最底部的push
这时把刚才拷贝的粘贴到这里来
接下来就一直点，
出现下面这个页面应该就是成功了
然后回到 发现上面出现了你的代码即可
常用DOS命令
盘符切换：e:回车
查看当前路径下的内容：dir
进入单级目录：cd 目录
回退到上一级目录：cd…
进入多级目录：cd 目录1\目录2
回退到盘符目录：cd\
清屏：cls
退出命令提示符窗口：exit
hello world案例分析
1.先建一个文本文档，修改名称，后缀改成.java
2.用记事本打开，编写程序，并保存
3.编译运行
编译：javac 文件名.java
运行：java 文件名
1.打代码可以打一些，再打alt+/，
2.鼠标定位在某一行，按住shift+方向键，可以选取多行，ctrl+\是注释多行
1.输入什么，输出什么
Scanner in =new Scanner(System.in);System.out.println("echo"+in.nextLine());//加前缀的话，要带上加号哦，加号起到连接字符串的作用，如果是print也是打印，只不过他不会自动换行
2.加法的使用
加法的使用方法，是起到连接字符串的作用还是运算的作用
注意最上面加了一行代码 java.util.;（若使用了第十行，则要加这行代码）
数组
int [] arr1 = new int[10]
int [] arr1 = new int[n]
int [] arr1 = {1,2,3,4,5,6}
int [][] arr1 = new int[3][5]
int [] arr1 = new int[10];
arr1[0]=5;
int [] arr2 = arr1;
arr2[0]=16;
System.out.println(arr1[0]);//输出的是16
//因为arr1相当于管理者，而非数组本身，创建arr2，数组其实还是原来的数组，相当于arr1和arr2管理同一个数组
int[]a={1,2,3};
int[]b={1,2,3};
System.out.println(a==b);//输出false，尽管元素相同，因为a，b管理的两个不同的数组
.("%.3f",num) 表示保留三位小数 ，记住要加双引号哦
float a=8.2//编译失败，因为看到小数点，会自动认为是类型，此时需要强制类型转换。
下面两种都可以
float a=8.2f;
float a=(float)8.2;
注意:这和C语言有点不一样的
保留两位小数并且向下取整
private static double getTwoDecimalPlaces(double number) {return (double) Math.floor(number*100)/100;
}
保留两位小数并向下取整，如果是向上取整，用ceil即可
如果要保留三位小数呢，*1000 / 1000 依此类推
多组输入
Scanner input = new Scanner(System.in); int a, b; while(input.hasNextInt()){//重点在这里a = input.nextInt();b = input.nextInt(); System.out.println(a + b); }
1.使用sqrt
Math.sqrt()
2 生成随机函数
(int) (Math.()*10) 随机产生0到9
正则表达式
1 . 任意单个字符，除了换行符外
一个点就代表一个字符
String str="Java";
System.out.println(str.matches("..va"));//输出true
System.out.println(str.matches(".va"));//输出false
2 (ab|cd) ab或者cd
String str="ten";
System.out.println(str.matches("t(en|im)"));//输出true
//单个字符或者多个字符也是可以的哦
String str1="Java";
System.out.println(str1.matches("J(a|v)va"));//输出true
System.out.println(str1.matches("(Jav|JJJ)a"));//输出true
3 [abc] a或b或c
String str="Java";
System.out.println(str.matches("Ja[uw]a"));//输出false
System.out.println(str.matches("Ja[uvw]a"));//输出true
4 [ [ [^abc ] ] ] 除了a、b或者c之外的任意字符
String str1="Java"; System.out.println(str1.matches("Ja[^abcdv]a"));//输出false
System.out.println(str1.matches("Ja[^abcd]a"));//输出true
5 [a-z] a到z
是区分大小写的，两端都是闭区间
String str1="Java";
System.out.println(str1.matches("Ja[A-V]a"));//输出false
System.out.println(str1.matches("Ja[a-v]a"));//输出true
6 [a-e[m-p]] a到e或者m到p
String str1="Java";
System.out.println(str1.matches("[A-G[I-M]]av[a-d]"));//输出true
7 [a-e&&[c-p]] a到e与c到p的交集
String str1="Java";
System.out.println(str1.matches("[A-P[I-M]]av[a-d]"));//输出true
Tips 为什么正则表达式是\d，而敲的时候要\\d呢
因为反斜杠是一个特殊的字符，在字符串中开始转移序列，因此用\ \来表示\
8 \d 一位数字，等同于0-9
String str1="Java23";
System.out.println(str1.matches("Java[\\d][\\d]"));//输出true,两位数字就要用两次哦
System.out.println(str1.matches("Java\\d\\d"));//输出true,意外发现，不需要方括号也可以
9 \D 一位非数字
String str1="Java23";
System.out.println(str1.matches("[\\D]ava23"));//输出true System.out.println(str1.matches("J\\Dva\\d\\d"));//输出true
10 \w 单词字符
单词字符是任意的字母，数字或者下划线字符。
11 \W 非单词字符
12 \s 空白字符
13 \S 非空白字符
14 p* 0次或者多次出现模式p
多个字母要加括号哦
String str1="ababa";
System.out.println(str1.matches("(ab)*"));//输出false
System.out.println(str1.matches("(ab)*a"));//输出true
String str2="ababab";
System.out.println(str2.matches("(ab)*"));//输出true
String str3="aaaaaa";
System.out.println(str3.matches("(ab)*"));//输出false
System.out.println(str3.matches("aaaaaa(ab)*"));//输出true
15 p+ 一次或者多次出现模式p
String str1="aaa";
System.out.println(str1.matches("a+b*"));//输出true
16 p? 0次或者1次出现模式p
String str1="aaa";
System.out.println(str1.matches("b?"));//输出false
System.out.println(str1.matches("aaab?"));//输出true
17 p{n} 正好出现n次模式p
18 p{n,} 至少出现n次模式p
19 p{n,m} n到m出现模式p
String str1="abb";
System.out.println(str1.matches("a{1,9}bb"));//输出true,说明是包含区间端点的 System.out.println(str1.matches("a{2,9}bb"));//输出false
20 \p{P} 一个标点字符
String str1="j!erw";
System.out.println(str1.matches("j\\p{P}erw"));//输出true
示例：
1.社会安全号的模式为xxx-xx-xxxx，x是一位数字
String str1="111-22-2222";
//表示数字恰好出现了3次-恰好出现了2次-恰好出现了4次
System.out.println(str1.matches("[\\d]{3}-[\\d]{2}-[\\d]{4}"));//输出true
2.偶数表示
偶数是以数字0、2、4、6、8结尾
String str1="112";
System.out.println(str1.matches("[\\d]*[02468]"));//输出true，结尾是偶数就行了，因为前面的[\\d]*已经读取了前面的数字了
3 电话号码表示模式是(xxx)-xxx-xxxx, x代表一位数字，其中不能以0开头
String str1="(123)-123-1231";
System.out.println(str1.matches("\\([\\d]{3}\\)-[\\d]{3}-[\\d]{4}"));//输出true
String str1="(123-123-1231";
System.out.println(str1.matches("\\([\\d]{3}\\)-[\\d]{3}-[\\d]{4}"));//输出false,少括号不行哦
tips ()在正则表达式中是特殊字符，用于对模式分组。为了在正则表达式中表示字面值，必须使用 \ \
4.假定姓由最多25个字母组成，并且第一个字母为大写
String str1="Adsfds";
System.out.println(str1.matches("[A-Z][a-z[A-Z]]{1,24}"));//输出true
tips 不能随便将空白符放入到正则表达式中，会报错 ，编译都过不了
5 java标识符
标识符必须以字母，下划线或者以美元符号($)开头，不能以数字开头
标识符是一个由字母，数字，下划线或美元符号组成的字符序列
String str1="Adsfds$";
System.out.println(str1.matches("[a-z[A-Z][$]][\\w|$]*"));//输出true
继承
如果类C1继承自类C2，那么就将C1称为子类(又叫继承类或派生类),C2称为超类(又叫父类或基类)
public class GeometricObject {private String color = "white";private boolean filled;private java.util.Date dateCreated;//这是我没见过的public GeometricObject() {dateCreated = new java.util.Date();//获取对象创建的时间}public GeometricObject(String color,boolean filled){dateCreated = new java.util.Date();this.color = color;this.filled = filled;}public String getColor() {return color;}public void setColor(String color) {this.color = color;}public boolean isFilled() {return filled;}public void setFilled(boolean filled) {this.filled = filled;}public java.util.Date getDateCreated(){return dateCreated;//返回时间}
//表示Circle继承GeometricObject
public class Circle extends GeometricObject{private double radius;public Circle() { }public Circle(double radius) {this.radius=radius;} //重载的构造方法，通过调用setColor和setFilled方法来设置color和filled的属性，这两个方法是在父类中定义的public Circle(double radius,String color,boolean filled) {this.radius =radius;setColor(color);setFilled(filled);//this.color=color;//this.filled=filled;//这种写法错误，因为他们是GeometricObject类中的私有数据域,不能被其他任何类访问，唯一读取和改变color和filled的方法就是通过他们的获取方法和设置方法。//用super关键字可以改写成下面的代码//super(color,filled)//this.radius=radius}public double getRadius() {return radius;}public void setRadius(double radius) {this.radius=radius;}public double getArea() {return radius*radius*Math.PI;}public double getDiameter() {return 2*radius;}public double getPerimeter() {return 2*radius*Math.PI;}public void printCircle() {System.out.println("The circle is created "+getDateCreated()+" and the radius is "+radius);}
}public class Rectangle extends GeometricObject{
private double width;
private double height;public Rectangle() {
}public Rectangle(double width,double height) {this.width=width;this.height=height;
}public Rectangle(double width,double height,String color,boolean filled) {this.width=width;this.height=height;setColor(color);setFilled(filled);
}public double getWidth() {return width;
}public void setWidth(double width) {this.width=width;
}public double getHeight() {return height;
}public void setHeight(double height) {this.height=height;
}public double getArea() {return width*height;
}public double getPerimeter() {return 2*(width+height);
}
}public class EX11_4 {public static void main(String[] args) {Circle circle=new Circle(1);System.out.println("A circle "+circle.toString());System.out.println("The color is "+circle.getColor());System.out.println("The radius is "+circle.getRadius());System.out.println("The area is "+circle.getArea());System.out.println("The diameter is "+circle.getDiameter());Rectangle rectangle=new Rectangle(2,4);System.out.println("\nA rectangle "+rectangle.toString());System.out.println("The area is "+rectangle.getArea());System.out.println("The perimeter is "+rectangle.getPerimeter());}}super关键字：
子类可以继承父类的方法和可访问的数据域，但是不能继承父类中的构造方法，这时就只能用关键字super。
基本语法：1.super() 调用父类的无参构造方法
2.super() 调用与父类匹配的构造方法
注：super()或super()必须出现在子类构造方法的第一行，这是显式调用父类构造方法的唯一方式
原因：因为在任何情况下，构造一个类的实例时，将会调用沿着继承链的所有父类的构造方法，如果没有被显式调用，编译器会自动地将super()作为构造方法的第一条语句。所以如果没有把显式调用放在第一行，编译器在执行到第一行时会自动将super()加上去，然后再执行到下面时就会出错了
来看一个错误代码
public class Apple extends Fruit{}class Fruit{public Fruit(String name){System.out.println(".........");}
}
由于Apple没有显式定义构造方法，所以Apple的默认无参构造方法会被隐式调用,即调用Fruit的无参构造方法(因为Apple是Fruit的子类),然而，因为Fruit显式地定义了构造方法，所以Fruit没有无参构造方法，因此，改程序不能被成功编译。
设计指南：一般情况下，最好为每个类提供一个无参构造方法，以便于对该类进行继承，同时避免错误。
方法重写：子类从父类中继承方法，但有时需要修改父类中定义方法的实现
重写与重载的区别：方法重写发生在具有继承关系的不同类中，而方法重载可以发生在同一个类中，也可以发生在具有继承关系的不同类中。
方法重写具有同样的签名，方法重载具有同样的签名但是不同的参数列表
多态
poly +
许多 形态 即多种形态
继承或者实现，是多态性的前提。
多态意味着父类型可以引用子类型的对象
继承关系使一个子类能继承父类的特征，并且附加一些新特征。子类是它的父类的特殊化，每个子类的实例都是其父类的实例，但是反过来并不成立。例：每个圆都是几何对象，但并非每个几何对象都是圆。因此，总可以将子类的实例传给需要父类型的参数
Eg1：
//父类
public class Father {public void method() {System.out.println("父类方法");}public void methodf() {System.out.println("父类特有方法");}
}
//子类
public class Son extends Father{@Overridepublic void method() {//super.method()这样就可以调用父类的method方法，super关键字，Cannot use super in a static context，主函数里面用不了吧System.out.println("子类方法");}
}
/*代码体现多态性的一句话，父类引用指向子类对象格式：父类名称 对象名 = new 子类名称();*/
public class Demo1 {public static void main(String[] args) {Father obj = new Son();obj.method();//输出 子类方法obj.methodf();//输出 父类特有方法}
}
Eg2：
public class Father {int num=20;public void method() {System.out.println(num);}
}
public class Son extends Father{int num=10;int age=16;@Overridepublic void method() {System.out.println(num);}
}
/*访问成员变量的两种方式：1.直接通过对象名称访问成员变量：等号左边是谁，优先用谁，没有则向上找2.间接通过成员方法访问：看该方法属于谁,优先用谁，没有则向上找*/
public class Demo1 {public static void main(String[] args) {Father obj = new Son();System.out.println(obj.num);//输出20// System.out.println(obj.age);错误写法，不会向下找的，只会向上找，找objcect，而object里面肯定没有ageobj.method();//输出10，如果子类没有方法重写的话就输出20}
}
Eg3：
public class Father {public void method() {System.out.println("父类方法");}public void methodf() {System.out.println("父类特有方法");}
}
public class Son extends Father{public void method() {System.out.println("子类方法");}public void methods() {System.out.println("子类特有方法");}
}
/*在多态的代码中，成员方法的访问规则是：看new的是谁，就优先用谁，没有则向上找编译看左边，运行看右边*/
public class Demo1 {public static void main(String[] args) {Father obj = new Son();obj.method();obj.methodf();obj.methods();//编译报错，因为父类没有methods这个方法}
}
总结：多态：基类型对象访问派生类重写的方法
向上转型
对象的向上转型，其实就是多态写法
父类名称 对象名 = new 子类名称(); //Animal animal = new Cat() 创建了一只猫，把他当作动物
含义：右侧创建一个子类对象，把他当做父类来看待使用==注==：向上转型一定是安全的，从小范围到大范围。但也有一个弊端，就是对象一旦向上转型成父类，那么就无法再调用子类原本特有的内容。(即上面Demo1里面注释编译报错的那一行，因为methods是子类特有的内容)，此时就有了向下转型类似于：double num=100；//正确，int->double
向下转型
对象的向下转型，其实就是一个【还原】的动作
格式：子类名称 对象名 = (子类名称) 父类对象;(类似于强制类型转换)
含义：将父类对象，还原成本来的子类对象
= new Cat();//本来是猫，向上转型为动物
Cat cat = (Cat) ;//本来是猫，已经被当作动物了，现在还原成原来的猫
注意：a.必须保证对象本来创建的时候，就是猫，才能向下转型成为猫，如果对象原来创建的时候不是猫，现在非要向下转型成为猫，就会报错。(编译不会出错，运行会出错)
那怎么知道父类引用的对象中本来是什么子类呢？
这时就需要使用
public class Demo2 {public static void main(String[] args) {giveMeAPet(new Dog());}
}public static void giveMeAPet(Animal animal){if(animal instanceof Dog){Dog dog = (Dog) animal;dog.watchHourse();}if(animal instanceof Cat){Cat.cat = (Cat) animal;cat.catchHouse();}
}
//给我了一只动物，但我只知道她是动物，所以此时要用instanceof判断他是什么，从而物尽其用。
多态的应用
1.循环调用基类对象，访问不同派生类方法
public static void main(String[] args) {
GradedActivity[] tests = new GradedActivity[3];// 第一次考试采用五级计分制，考了75tests[0] = new GradedActivity();tests[0].setScore(75);// 第二次考试采用二级计分制（P或者F）。总共20题，每题分值相同，考生答错5题。// 通过的最低分数线是60分tests[1] = new PassFailExam(20, 5, 60);// 第三次是期末考试也采用五级计分制. 总共50题，每题分值相同，考试答错7题tests[2] = new FinalExam(50, 7);// 显示每次考试的分数和等级for(int i=0; i<tests.length; i++){showValue(tests[i]);}
}public static void showValue(GradedActivity exam){System.out.println("Score: " + exam.getScore()+ "\t" + "Grade: " + exam.getGrade());}
2.实参是派生类,形参是基类
图形类()是矩形和圆形等具体形状类的共同父类，他有一个方法的功能是计算图形的面积，但是在图形类中并不知道具体的形状，因此无法计算，也就是说，方法的方法在父类中实际上没有任何意义。
解决办法：通过关键字将方法修饰为抽象的，此时的方法称为抽象方法。
抽象方法是出现在基类中的一种方法，但要求在派生类中被重写。(如果派生类没有重写抽象方法，编译器就会报错，抽象方法被用来确保派生类会实现这个方法)
格式：访问修饰符 返回类型 方法名(参数列表);
例: void ();//关键字 出现在方法头中，方法头以分号结尾
若类含有抽象方法，则类必须以关键字声明为抽象类。
格式： class 类名
注意
1.不论抽象类是否含抽象方法，其都不允许实例化，即不能创建抽象类的对象，因为其描述的是抽象概念。它只能作为其他类的基类。
2.若父类是抽象类，且子类不想成为抽象类，则子类必须将父类中的所有抽象方法重写为带方法体的普通方法，否则子类仍必须是抽象类。
super的使用
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img--13)()]
调用父类的构造方法
抽象类与接口的异同点 不同点：
1.关键字不同：
① 继承抽象类的关键字是，而实现接口的关键字是；
②定义抽象类的关键字是 class，而定义接口的关键字是;
2.权限修饰不同：抽象方法可以有、和这些修饰符（缺省情况下默认为），而接口方法只能是 ;
3.抽象类中可以有构造方法，而接口中不能有构造方法；
如果写了构造方法，编译报错： have
4.抽象类中既可以有抽象方法也可以有普通方法，接口中只能有抽象方法；
注：从jdk1.8开始允许接口中出现非抽象方法，但需要使用关键字修饰。
意义：
1.假如你接口中有很多的抽象方法，但是实现类中有时候并不需要用到那么多的抽象方法，但是又要全部重写，就会很麻烦，这时如果使用非抽象方法，就可以在实现类中重写需要使用到的抽象方法即可，大大减少了代码量。
2.当我们在接口中增加一个抽象方法时，这时所有实现接口的类中都要重写这个方法，就有牵一发而动全身的麻烦。那么如果用非抽象方法，就可以根据实际需要重写该非抽象方法。
5.抽象类中增加方法可以不影响子类，而接口中增加方法通常都影响子类。
理解：因为在抽象类中，可以定义非抽象方法，这时就不需要在子类中重写了，而接口中增加方法，这方法肯定是抽象类方法，则必须要在子类中重写。（为什么是通常呢，因为上面第四点提到，在jdk1.8开始，允许接口中出现非抽象方法）
6.抽象类中的变量可以是普通变量，接口里定义的变量只能是公共的静态的常量；
实际操作中发现定义变量时没写 final也不会报错，因为接口只能是公共的静态常量的,编译器默认会加上，同理，定义方法时没写 也不会报错
7.抽象方法可以继承单个类和实现多个接口，接口可以多继承接口；
abstract class Demo{abstract void printfa();//抽象方法void printfb();//编译报错，add bodyvoid printfb() {//非抽象方法}}interface Demo1{void printfab();void printfa() {//编译报错，因为接口中必须是抽象方法 }default void printfb() {//加上default可以了 }}
相同点：
(1) 都可以被继承
(2) 都不能被实例化
