Java学习（JDK8）-第7天-----基础收尾，面向对象开头
本帖最后由 xiaotian1339 于 2022-4-6 23:29 编辑# 自学Java-0基础到框架(JDK8)-day07
> 今天对基础知识进行收尾，然后开始进行面向对象的学习
## 正则表达式
### 语法
> 在其他的语言中`\\`表示插入一个普通的反斜线
>
> 在Java中`\\`表示插入一个正则表达式的反斜线
>
> 可以简单的理解在 Java 的正则表达式中，两个 `\\` 代表其他语言中的一个 \，这也就是为什么表示一位数字的正则表达式是 `\\d`，而表示一个普通的反斜杠是 `\\`。
示例：
```java
public class RegexTest {
public static void main(String[] args) {
System.out.println("\\");
System.out.println("\\\\");
}
}
```
输出：
```java
\
\\
```
其他的字符基本与其他语言相同，不过方法可能不同，这个目前没学太懂，后面慢慢补充吧~
---
## IO流
!(https://s1.ax1x.com/2022/04/06/qjF1fA.png)
---
### 创建一个文件并向文件中写数据
FileOutputStream类
!(https://s1.ax1x.com/2022/04/06/qjYtGn.png)
### 从文件读取数据
FileInputStream类
!(https://s1.ax1x.com/2022/04/06/qjY3Vg.png)
---
示例：
```java
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");
}
}
}
```
输出：
```java
Bc (乱码)
```
**发现只要强转为Byte格式就可以了**
```java
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");
}
}
}
```
输出:
```java
66990
```
---
第二种方式+注释
示例
```java
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");
// 捕获异常
}
}
}
```
输出：
```java
Hello, world!
你好，Java
```
---
## File操作
### 创建目录
- **mkdir( )**方法创建一个文件夹，成功则返回true，失败则返回false。
> 失败表明File对象指定的路径已经存在，或者由于整个路径还不存在，该文件夹不能被创建。
- **mkdirs()**方法创建一个文件夹和它的所有父文件夹。
---
mkdir
```java
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
```
!(https://s1.ax1x.com/2022/04/06/qjNRHO.png)
---
mkdirs
```java
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
```
!(https://s1.ax1x.com/2022/04/06/qjaFSA.png)
创建了testdir3并创建了父文件夹testdir2
---
### 读取目录文件
File类list方法
我在testdir3目录下创建了text.txt和demo.html和test文件夹
```java
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);
if (f.isDirectory()) {
System.out.println(s + " 是一个目录");
} else {
System.out.println(s + " 是一个文件");
}
}
} else {
System.out.println(path + " 不是一个目录");
}
}
}
```
输出：
```java
demo.html 是一个文件
test 是一个目录
text.txt 是一个文件
```
---
### 删除文件/文件夹
File类delete方法
```java
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);
System.out.println(s + "已删除");
f.delete();
}
}
}
}
```
输出：
```java
demo.html已删除
test已删除
text.txt已删除
```
文件以及文件夹已经被删除
---
## 面向对象
> 因为在第一天已经了解了类和对象的一些概念，所以今天笔记就没有再次介绍，
### 继承
概念:
> - 继承是java面向对象编程技术的一块基石，因为它允许创建分等级层次的类。
>
> - 继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。
通俗理解就是 **父类更通用 子类更具体**
例如
```text
羊 --
|-->食草动物---------
兔子 -- 子类 |
|
|-------->动物（父类）
|
老虎-- 子类 |
|-->食肉动物----------
狮子--
虽然食草动物和食肉动物都是属于动物，但是两者的属性和行为上有差别，所以子类会具有父类的一般特性也会具有自身的特性。
```
#### this/super
这里对this和super进行一下详细的学习。
```java
// 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;
}
}
```
```java
// 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....
输出结果：
```java
父类·创建了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不支持多继承但是支持多重继承**
> ```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** 关键字调用父类构造器，系统会自动调用父类的无参构造器。 java的构造函数只认List不认List里面的T这个感觉不太爽 好像很厉害 小白不懂 反斜杠 是转义字符。很多特殊字符需要转义就得用反斜杠 最近也在自学java刚开始接触 java.util.Scanner 向楼主看齐 tanzhiwei 发表于 2022-4-6 21:40
java的构造函数只认List不认List里面的T这个感觉不太爽
我是小白，我也不懂{:1_907:} 学习学习 支持一下，激励学习！ @xiaotian1339 同学你能不能按照版规要求，把学习贴合并到一个帖子或者通过回复更新内容，不要短时间发多个主题了，如果提醒没有只能强制执行了。 本帖最后由 xiaotian1339 于 2022-4-7 15:13 编辑
Hmily 发表于 2022-4-7 11:00
@xiaotian1339 同学你能不能按照版规要求，把学习贴合并到一个帖子或者通过回复更新内容，不要短时间发多个 ...
谢谢版主的提醒，不过这个板块里我看好多”第X天XXX“的，只提醒我一人不太管用把:loveliness::loveliness::loveliness:为什么非要揪着我不放捏{:1_885:}，近期不会在开新帖了
页:
[1]
2