Java SE 笔记搬运

本科过过两遍Java SE，但是由于考研等不可抗力因素很久未接触代码，因工作需求这里将四年前的Java笔记重新整理搬运，方便Java学习。

——————————————————————————————————————————————————————————————

继承

/*

私有化的成员能不能被继承？私有化的成员不能被继承

* 那么如果去使用父类中私有化的成员: 通过继承父类的公有化方法区访问

*

* 注意:除了私有化的成员都可以被继承

*

* 问题:创建子类对象的时候 父类做了什么事情? 父类在创建子类对象之前先创建了对象

* 那么请问,为什么创建子类对象之前要先创建父类对象？

* 为了对父类成员的引用...

* 那么如何去引用父类对象的 super

*

* 父类如果没有无参构造器 只有有参 那么 子类里面分无参构造并不能够访问父类的无参构造会报错

* (除非在子类的无参构造里面去调用父类的有参构造器)

*

* 父类构造函数会不会被继承? 父类的构造函数不会被继承 super() 调用父类的无参构造

* 构造函数不存在继承

*

* 问题: 1.父类和子类如果同时出现相同的成员(变量和方法) 怎么确定调用的是父类还是子类的成员(变量和方法)

* 结论1:如果父类和子类同时出现相同的成员变量名,那么优先使用子类自己的

* 结论2:如果同时出现相同的方法名时,还有优先使用子类自己的(不考虑静态方法)

 

问题:父类有show 子类有show方法 请问 子类继承了父类的show方法嘛?

没有继承父类 show方法

如果子类和父类的方法名参数列表返回类型一致 表名子类重写了父类的方法

 

问题: 静态方法能不能被重写？可不可以被继承？

 

静态方法是属于类成员不能被重写(多态)

 

但是可以被继承

 

super 表示父类对象 super() 表示对父类对象的无参构造器的引用

 

this 表示当前对象 this() 表示引用当前对象的无参构造器

 

a.子类使用有参构造创建对象的时候 如果子类的有参构造器里面没有super(参数...)那么就意味着

默认的去访问父类的无参构造器

b.如果想要通过子类的有参构造器去给父类的成员变量进行赋值,那么要在子类的有参构造器里面添加指向父类

的有参构造器 super(参数列表);

 

 

*/

继承的好处:

1.提高了代码的复用性

---多个类中有相同的成员可以放到一个类中

2.提高了代码的维护性

--- 如果功能的代码需要修改 那么只需要修改一处即可

3.让类与类之间产生了关系,是多态的前提

--- 是好处也是弊端: 类与类之间的耦合性更强了

 

高内聚:就是自己能完成某件事的能力 （如果能在一个类中完成就尽量在一个类里面完成）

低耦合:降低类与类之间的关系

 

不好:使用继承打破了封装性

---如果想要父类的属性 在调用者和里面 创建父类对象调用公共的访问方法去访问

---但是在子类里面不需要创建父类对象就可以直接去调用父类的公共的访问方法区调用父类的属性

 

什么时候使用继承？(使用继承的注意事项)

1.多个类中有相同的成员可以放到一个类中

2.不能为了部分的功能去继承

class Fu{

test(){

 

}

show(){

 

}

... 有是个

}

class Son extends Fu{

//只想用其中一个

 

}

创建对象时的内存操作

```text

在创建的对象的时候内存做了哪些事

Car s = new Car();

 

1 加载Car类文件到栈内存，开辟空间。

 

2 在栈内存为s开辟空间

 

3 在堆内存为Car对象开辟空间

 

4 给Car的成员变量分配默认值

 

5 如果成员变量有给定值则用给定值覆盖默认值

 

6 通过构造方法给成员变量赋值

 

7 把Car对象在堆内存的地址值赋给s变量

 

```

 static

 

/**

* static 关键字

* @param args

*

* class文件只会被加载一遍

*

* class文件在内存中加载的时候 被static 修饰的成员立即加载 static修饰的成员叫 类成员

*

* static 修饰的成员 优先于对象存在、

*

* static 修饰的成员被所有的对象共享

*

* 静态的方法只能调用静态成员

*

* 非静态的可以任意调用

*

*/

静态方法

静态的内存空间是固定的，相对来说更省资源。创实例的创一个实例就要开辟一个新内存，耗费资源

静态方法属于类所有，类实例化前即可使用；

非静态方法可以访问类中的任何成员，静态方法只能访问类中的静态成员；

因为静态方法在类实例化前就可以使用，而类中的非静态变量必须在实例化之后才能分配内存；

static内部只能出现static变量和其他static方法!而且static方法中还不能使用this等关键字，因为它是属于整个类；

静态方法效率上要比实例化高，静态方法的缺点是不自动进行销毁，而实例化的则可以做销毁；

静态方法和静态变量创建后始终使用同一块内存，而使用实例的方式会创建多个内存。

主要区别：静态方法在创建对象前就可以使用了，非静态方法必须通过new出来的对象调用。

静态方法可以通过 类名::方法名直接调用。普通方法需要创建一个实例，也就是new一个对象，然后通过 对象名->方法名的方式来调用

静态类只能包含静态成员，否则会抛出编译错误；然而非静态类既可以包含非静态成员也可以包含静态成员

静态类是不能实例化,之所以不能实例化,是因为静态类会导致C#编译器将该类同时标记为abstract和sealed,并且编译器不会在类型中

生成一个实例的构造函数，从而导致静态类不能实例化；非静态类可以，并且静态成员的访问只能通过类来进行访问，因为静态成员是属于类的。

 

static方法不能被重写

抽象or接口

/**

抽象类和接口的区别:

成员区别:

抽象类 可以有成员变量,常量,有抽象方法,也可以有非抽象方法

接口:只有抽象方法(jdk1.8之前)和常量

 

抽象类只能单继承,接口可以多继承也可单继承

<一个类可以实现多个接口 但是只能继承一个抽象类(除了内部类)>

 

 

*/

内部类

/**

内部类好处:

(为什么我们要使用内部类)

1.内部类的方法可以访问该类定义所在作用域中的数据包括被私有化的数据(内部类的成员方法能访问外部类的一切成员)

2.内部类可以对同一个包中的其他类隐藏起来

3.内部类可以解决java单继承的缺陷(待会代码演示)

4.当我们想要调用一个方法却不想写大量的代码的时候,我们可以使用匿名内部类来实现

 

内部类在实际开发可能引起的问题:

1.可能会造成程序的内存泄漏

异常

```java

/**

如果程序出现异常 那么我们如何去处理

printStackTrace的堆栈跟踪功能显示出程序运⾏到当前类的执⾏流程

▷ 异常堆栈信息

▷ 异常类型

▷ 出现异常的位置

▷ 在哪个⽅法中抛出了异常

 

try{}catch(异常类型）{}

try{}finally{}

 

*/

```

io流

//为什么要关闭资源？释放内存；保存数据完整性 因为在多线程的情况下 如果多个线程对同一个文件进行操作,那可能会

//造成数据丢失或者错误的问题

 

//首先确定要读取的文件

File file = new File("Readme.md");

InputStream fio = new FileInputStream(file);

//int line=fio.read();

byte [] bytes=new byte[(int)file.length()];

fio.read(bytes);

 

String s=new String(bytes);

System.out.println(s);

fio.close();

 

//往文件里面写入数据

OutputStream outputStream=new FileOutputStream(file,true); //表示追加

outputStream.write("\n".getBytes());

outputStream.write("半圆".getBytes()); //写入数据的时候会造成之前数据被覆盖

outputStream.close();

 

//将a文件里面的内容复制到b文件里面去,写完之后考虑如果是图片或者是视频呢,如何进行复制

File file1 = new File("a.md");

InputStream fio = new FileInputStream(file1);

 

byte [] bytes=new byte[(int)file1.length()];

fio.read(bytes);

fio.close();

 

File file2 = new File("b.md");

OutputStream outputStream=new FileOutputStream(file2,true);

outputStream.write(bytes);

outputStream.close();

复制文件

/**

复制多级文件夹及其子目录和子目录下面的文件

public static void CopyDirectory(File srcFile,File targetFile) throws IOException { //复制文件夹

//如果只是复制子目录呢

if(srcFile.isDirectory()){//如果起始文件是文件夹

File file=new File (targetFile,srcFile.getName());

file.mkdirs(); //创建多级目录

 

File[] files=srcFile.listFiles(); //找到目标下面所有的文件

for (File f:files) {

CopyDirectory(f,file); //使用循环重复调用本方法 如果存在多级目录

}

 

}else{ //如果传递过来的不是文件夹 而是文件

File file=new File(targetFile,srcFile.getName());//获取文件名 targetFile目标文件夹

if(!file.exists()){

file.createNewFile();

}

//读取文件数据

InputStream inputStream1=new FileInputStream(srcFile);

OutputStream outputStream=new FileOutputStream(file);

byte[] bytes=new byte[(int)srcFile.length()];

inputStream1.read(bytes);

inputStream1.close();

 

outputStream.write(bytes);

outputStream.close();

 

}

 

}

*/

线程生命周期

 

 

 单例模式

传说中的单例模式，基本就是在特殊情况下只允许创建一个对象。注意这里getInstance是静态方法，想要调用属性user19，所以user19必须是静态属性。