甘肃龙网

  1. 首页 > 生活 > >

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.用记事本打开，编写程序，并保存
【Java课程期末复习学习总结】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"));//输出trueSystem.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"));//输出trueSystem.out.println(str1.matches("(Jav|JJJ)a"));//输出true
3 [abc] a或b或c
String str="Java";System.out.println(str.matches("Ja[uw]a"));//输出falseSystem.out.println(str.matches("Ja[uvw]a"));//输出true
4 [ [ [^abc ] ] ] 除了a、b或者c之外的任意字符
String str1="Java"; System.out.println(str1.matches("Ja[^abcdv]a"));//输出falseSystem.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"));//输出falseSystem.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"));//输出trueSystem.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)*"));//输出falseSystem.out.println(str1.matches("(ab)*a"));//输出trueString str2="ababab";System.out.println(str2.matches("(ab)*"));//输出trueString str3="aaaaaa";System.out.println(str3.matches("(ab)*"));//输出falseSystem.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?"));//输出falseSystem.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}"));//输出trueString 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继承GeometricObjectpublic 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关键字：

Java课程期末复习学习总结

文章插图
子类可以继承父类的方法和可访问的数据域，但是不能继承父类中的构造方法，这时就只能用关键字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
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) 都不能被实例化


    上一篇：黄瓜种的功效与作用 黄瓜种植效益怎么样

    下一篇：广西靖西市：生猪代养 广西养猪网