自学Java-0基础到框架(JDK8)-day07
今天对基础知识进行收尾，然后开始进行面向对象的学习
正则表达式
语法
在其他的语言中\\表示插入一个普通的反斜线
在Java中\\表示插入一个正则表达式的反斜线
可以简单的理解在 Java 的正则表达式中，两个 \\ 代表其他语言中的一个 \，这也就是为什么表示一位数字的正则表达式是 \\d，而表示一个普通的反斜杠是 \\。
示例：
public class RegexTest {
public static void main(String[] args) {
System.out.println("\\");
System.out.println("\\\\");
}
}
输出：
\
\\
其他的字符基本与其他语言相同，不过方法可能不同，这个目前没学太懂，后面慢慢补充吧~
IO流
创建一个文件并向文件中写数据
FileOutputStream类
从文件读取数据
FileInputStream类
示例：
import java.io.*;
public class ReadAndWrite {
public static void main(String[] args) {
try {
OutputStream f = new FileOutputStream("write.txt");
byte[] s = {66, 99, 0};
for (byte x : s) {
f.write(x);
}
f.close();
InputStream g = new FileInputStream("write.txt");
int c;
while ((c = g.read()) != -1) {
System.out.print((char) c);
}
}catch (Exception e) {
System.out.println("Error");
}
}
}
输出：
Bc (乱码)
发现只要强转为Byte格式就可以了
import java.io.*;
public class ReadAndWrite {
public static void main(String[] args) {
try {
OutputStream f = new FileOutputStream("write.txt");
byte[] s = {66, 99, 0};
for (byte x : s) {
f.write(x);
}
f.close();
InputStream g = new FileInputStream("write.txt");
int c;
while ((c = g.read()) != -1) {
System.out.print((byte) c);
}
}catch (Exception e) {
System.out.println("Error");
}
}
}
输出:
66990
第二种方式+注释
示例
import java.io.*;
public class ReadAndWrite2 {
public static void main(String[] args) {
try{
FileOutputStream fos = new FileOutputStream("write2.txt");
// 构建一个FileOutputStream对象，指向一个文件
OutputStreamWriter osw = new OutputStreamWriter(fos, "UTF-8");
// 构建一个OutputStreamWriter对象，指定编码
osw.write("Hello, world!");
osw.write("\n");
osw.write("你好，Java");
// 写入文件
osw.close();
// 关闭流
fos.close();
// 关闭文件
FileInputStream fis = new FileInputStream("write2.txt");
// 构建一个FileInputStream对象，指向一个文件
InputStreamReader isr = new InputStreamReader(fis, "UTF-8");
// 构建一个InputStreamReader对象，指定编码
StringBuffer sb = new StringBuffer();
// 构建一个StringBuffer对象
while (isr.ready()){
// 判断是否读取到文件末尾
sb.append((char)isr.read());
// 从输入流中读取一个字符
}
System.out.println(sb.toString());
// 输出文件内容
isr.close();
// 关闭流
fis.close();
// 关闭文件
}catch (IOException e){
System.out.println("Error");
// 捕获异常
}
}
}
输出：
Hello, world!
你好，Java
File操作
创建目录
mkdir
import java.io.File;
public class FillDirTest {
public static void main(String[] args) {
File f = new File("D:\\Desktop\\Project\\java1.8\\testdir");
boolean a = f.mkdir();
System.out.println(a);
}
}
//输出：true
mkdirs
import java.io.File;
public class FillDirTest {
public static void main(String[] args) {
File f = new File("D:\\Desktop\\Project\\java1.8\\testdir\\testdir2\\testdir3");
boolean a = f.mkdirs();
System.out.println(a);
}
}
//输出：true
创建了testdir3并创建了父文件夹testdir2
读取目录文件
File类list方法
我在testdir3目录下创建了text.txt和demo.html和test文件夹
import java.io.*;
public class FileList {
public static void main(String[] args) {
String path = "D:\\Desktop\\Project\\java1.8\\testdir\\testdir2\\testdir3";
File f1 = new File(path);
if (f1.isDirectory()) {
String s[] = f1.list();
for (int i = 0; i < s.length; i++) {
File f = new File(path + "\\" + s[i]);
if (f.isDirectory()) {
System.out.println(s[i] + " 是一个目录");
} else {
System.out.println(s[i] + " 是一个文件");
}
}
} else {
System.out.println(path + " 不是一个目录");
}
}
}
输出：
demo.html 是一个文件
test 是一个目录
text.txt 是一个文件
删除文件/文件夹
File类delete方法
import java.io.File;
public class DeleteFile {
public static void main(String[] args) {
String path = "D:\\Desktop\\Project\\java1.8\\testdir\\testdir2\\testdir3";
File f1 = new File(path);
if (f1.isDirectory()) {
String s[] = f1.list();
for (int i = 0; i < s.length; i++) {
File f = new File(path + "\\" + s[i]);
System.out.println(s[i] + "已删除");
f.delete();
}
}
}
}
输出：
demo.html已删除
test已删除
text.txt已删除
文件以及文件夹已经被删除
面向对象
因为在第一天已经了解了类和对象的一些概念，所以今天笔记就没有再次介绍，
继承
概念:
通俗理解就是 父类更通用 子类更具体
例如
羊 --
|-->食草动物---------
兔子 -- 子类 |
|
|-------->动物（父类）
|
老虎-- 子类 |
|-->食肉动物----------
狮子--
虽然食草动物和食肉动物都是属于动物，但是两者的属性和行为上有差别，所以子类会具有父类的一般特性也会具有自身的特性。
this/super
这里对this和super进行一下详细的学习。
// Animal父类
public class Animal {
Animal(){
System.out.println("父类·创建了Animal，无参数");
}
Animal(String name){
System.out.println("父类·创建了含1个参数的Animal，name："+name);
}
public static int[] getNum(){
int[] nums = {1,2,3,4,5};
return nums;
}
}
// AnimalDog子类
public class AnimalDog extends Animal{
AnimalDog(){
super();
// 调用父类的构造方法
System.out.println("子类·无参数构造方法，创造AnimalDog类");
}
AnimalDog(String name){
super(name);
// 调用父类的构造方法
System.out.println("子类·有一个参数构造方法，创造AnimalDog类，name："+name);
}
AnimalDog(String name,int age){
this(name);
// 调用本类构造方法
System.out.println("子类·有两个参数构造方法，创造AnimalDog类，name："+name+"，age："+age);
}
public static void main(String[] args) {
AnimalDog animalDog = new AnimalDog();
AnimalDog animalDog1 = new AnimalDog("小黑");
AnimalDog animalDog2 = new AnimalDog("小黑",2);
int[] num = getNum();
for(int x : num){
System.out.println(x);
}
}
}
public class AnimalDog extends Animal中的extends表示继承自Animal
据我搜索了解似乎没有重写父类方法的话可以不用super....
输出结果：
父类·创建了Animal，无参数
子类·无参数构造方法，创造AnimalDog类
父类·创建了含1个参数的Animal，name：小黑
子类·有一个参数构造方法，创造AnimalDog类，name：小黑
父类·创建了含1个参数的Animal，name：小黑
子类·有一个参数构造方法，创造AnimalDog类，name：小黑
子类·有两个参数构造方法，创造AnimalDog类，name：小黑，age：2
1
2
3
4
5
- super(参数)：调用基类中的某一个构造函数（应该为构造函数中的第一条语句）
- this(参数)：调用本类中另一种形成的构造函数（应该为构造函数中的第一条语句）
- super: 它引用当前对象的直接父类中的成员（用来访问直接父类中被隐藏的父类中成员数据或函数，基类与派生类中有相同成员定义时如：super.变量名 super.成员函数据名（实参）
- this：它代表当前对象名（在程序中易产生二义性之处，应使用 this 来指明当前对象；如果函数的形参与类中的成员数据同名，这时需用 this 来指明成员变量名）
- 调用super()必须写在子类构造方法的第一行，否则编译不通过。每个子类构造方法的第一条语句，都是隐含地调用 super()，如果父类没有这种形式的构造函数，那么在编译的时候就会报错。
- super() 和 this() 类似,区别是，super() 从子类中调用父类的构造方法，this() 在同一类内调用其它方法。
- super() 和 this() 均需放在构造方法内第一行。
- 尽管可以用this调用一个构造器，但却不能调用两个。
- this 和 super 不能同时出现在一个构造函数里面，因为this必然会调用其它的构造函数，其它的构造函数必然也会有 super 语句的存在，所以在同一个构造函数里面有相同的语句，就失去了语句的意义，编译器也不会通过。
- this() 和 super() 都指的是对象，所以，均不可以在 static 环境中使用。包括：static 变量,static 方法，static 语句块。
- 从本质上讲，this 是一个指向本对象的指针, 然而 super 是一个 Java 关键字。
Java不支持多继承但是支持多重继承
//单继承
public class A {...}
public class B extends A {.....}
//--------------------------------------
//多重继承
public class A {..............}
public class B extends A {..............}
public class C extends B {...............}
//----------------------------------------
//不同类继承同一类
public class A{..}
public class B extends A {..}
public class C extends A {..}
//---------------------------------------
//多继承（不支持）
public class A {................}
public class B {................}
public class C extends A，B{........}
// Java不支持多继承
继承关键字
继承可以使用 extends 和 implements 这两个关键字来实现继承，而且所有的类都是继承于 java.lang.Object，当一个类没有继承的两个关键字，则默认继承object（这个类在 java.lang包中，所以不需要 import）祖先类。
extends
implements
使用 implements 关键字可以变相的使java具有多继承的特性，使用范围为类继承接口的情况，可以同时继承多个接口（接口跟接口之间采用逗号分隔）。
这个目前没有理解，等后面学习到接口之后再深入了解
继承特性
- 子类拥有父类非 private 的属性、方法。
- 子类可以拥有自己的属性和方法，即子类可以对父类进行扩展。
- 子类可以用自己的方式实现父类的方法。
- Java 的继承是单继承，但是可以多重继承，单继承就是一个子类只能继承一个父类，多重继承就是，例如 B 类继承 A 类，C 类继承 B 类，所以按照关系就是 B 类是 C 类的父类，A 类是 B 类的父类，这是 Java 继承区别于 C++ 继承的一个特性。
- 提高了类之间的耦合性（继承的缺点，耦合度高就会造成代码之间的联系越紧密，代码独立性越差）。
构造器
子类是不继承父类的构造器（构造方法或者构造函数）的，它只是调用（隐式或显式）。如果父类的构造器带有参数，则必须在子类的构造器中显式地通过 super 关键字调用父类的构造器并配以适当的参数列表。
如果父类构造器没有参数，则在子类的构造器中不需要使用 super 关键字调用父类构造器，系统会自动调用父类的无参构造器。
发表于 2022-4-6 20:32
|
发表于 2022-4-6 23:22
发表于 2022-4-7 11:00
，近期不会在开新帖了
