2.Java笔记（已更完面向对象和基础知识）

int a=0;
a++;                                      //a++的实际含义就是a=a+1；
++a;                                      //含义也是a=a+1；
不同之处是++a是先加后用，a++是先用后加。
--同理

单独使用时，在前在后都一样
被使用时，在前在后不一样
- a++的值为a----------(a--的值为a)
- ++a的值为a+1--------(--a的值为a-1)

关系：>、<、>=、<=、==、!=

逻辑：&&、||、!

逻辑运算是建立在关系运算的基础之上的逻辑运算的结果也是boolean型
&&:短路与(并且)，两边都为真则为真，见false则false
||:短路或(或者)，有真则为真，见true则true
!:逻辑非(取反)，非真则假，非假则真

赋值：=、+=、-=、*=、/=、%=

简单赋值运算符：=
扩展赋值运算符：+=、-=、*=、/=、%=
注意:扩展赋值运算符自带强转功能

字符串连接：+

若两边为数字，则做加法运算
若两边出现了字符串，则做字符串连接
任意类型的数据只要和字符串连，结果都会变为字符串类型---同化作用

System.out.println(10+20+""+30); //3030--------String
System.out.println(""+10+20+30); //102030------String
System.out.println(10+20+30+""); //60----------String

条件/三目：boolean?数1:数2

五：分支结构

1、 if.....else

if：

1)语法:
if(boolean){
语句块-------------基于条件执行的语句
}
2)执行过程:
判断boolean的值:
若为true，则执行语句块(整个结束)
若为false，则直接结束

if...else结构：2条路 1)语法:
if(boolean){
语句块1
}else{
语句块2
}
2)执行过程:
判断boolean的值:
若为true，则执行语句块1(整个结束)
若为false，则执行语句块2(整个结束)
3)说明:
语句块1和语句块2，必走其中之一----------2选1

switch...case：多条路

优点：效率高、结构清晰
缺点：只能对整数判断相等
break：跳出switch

六：循环：

1、循环三要素：

循环变量的初始化
循环的条件(以循环变量为基础)
循环变量的改变(向着循环的结束变)

2、循环结构

while结构：先判断后执行，有可能一次都不走

do...while结构：先执行后判断，至少走一次

第1要素与第3要素的代码相同时，使用do...while

for结构：应用率高、与次数相关的循环

  for(要素1;要素2;要素3){
      语句块/循环体---------------反复执行的语句  4
  }

break：跳出循环

continue：跳过循环体中剩余语句而进入下一次循环

3、三种循环结构如何选择：

先看循环是否与次数相关：
- 若相关-------------------------------------直接上for
- 若无关，再看第1要素与第3相互的代码是否相同：
  - 若相同--------------------------------直接上do...while
  - 若不同--------------------------------直接上while

4、嵌套循环：

循环中套循环，常常多行多列时使用，一般外层控制行，内层控制列
执行规则：外层循环走一次，内层循环走所有次
建议：嵌套层数越少越好，能用一层就不用两层，能用两层就不用三层
break只能跳出当前一层循环

五：数组

是一种数据类型(引用类型)
相同数据类型元素的集合
定义：
初始化：------------------初始化的是数组中的元素
访问：--------------访问的是数组中的元素
- 通过(数组名.length)可以获取数组的长度(元素个数)
- 通过下标/索引来访问数组中的元素，下标从0开始，最大到(数组的长度-1)
遍历/迭代：从头到尾挨个走一遍

补充：引用类型数组需要用new个对象来给数组赋值，若想访问应用数组中的对象数据需要用数组元素打点来进行访问

1、数组的复制

System.arraycopy(a,1,b,0,4);
- int[] b = Arrays.copyOf(a,6);
  
  a = Arrays.copyOf(a,a.length+1); //扩容

2、数组的排序

Arrays.sort(arr); //升序排列

（二）面向对象知识

一.类和对象的概念

1.什么是类？什么是对象？

现实生活中是由很多很多对象组成的，基于对象抽出了类
对象：软件中真实存在的单个个体/东西
类：类型/类别，代表一类个体
类是对象的模板/模子，对象是类的具体的实例
类中可以包含：

对象的属性/特征-----------------------------成员变量
对象的行为/动作/功能----------------------方法

成员变量又分为静态变量和实例变量：静态方法属于类通常需要类名来打点，实例变量属于对象需要对象名来打点。

6.一个类可以创建多个对象

2.如何创建类？如何创建对象？

类需要用Class关键字来创建。访问权限只可以用public和默认的（访问权限详细请翻到目录中的访问权限部分）
创建一个对象需要用new来实现。例如我创建了一个学生类Class Student()那么我就创建了一个学生模子，这个模子可以创建出很多的对象，例如张三我们就可以
```
Student 张三=new Student()//此时我们就创建了一个学生对象名字叫张三（在JAVA中可以使用中文来命名，但是不建议建议使用英文的见名知意此处只做演示）
```
ok
如何访问成员：访问静态变量一般需要使用类名打点来访问，访问实例变量一般需要使用对象名打点来访问。

二.方法的相关知识

方法名+参数列表

1. 方法的重载(overload/overloading)：

发生在同一类中，方法名相同，参数列表不同
编译器在编译时会根据方法的签名自动绑定方法

此处补充后面会写到方法的重写。详细记两者的区别。

2. 构造方法：

也被称为构造函数、构造器、构建器 ----------------------- 复用给成员变量赋初值的代码

作用：给成员变量赋初值
与类同名，没有返回值类型(连void都没有)
在创建(new)对象时被自动调用
若自己不写构造方法，编译器默认提供一个无参构造方法，若自己写了构造方法，则不再默认
提供
构造方法可以重载

3.this：

指代当前对象，哪个对象调用方法它指的就是哪个对象
只能用在方法中，方法中访问成员变量之前默认有个this.

this的用法：

this.成员变量名---------------------------访问成员变量
当成员变量与局部变量同名时，若想访问成员变量，则this不能省略
this.方法名()--------------------------------调用方法(一般不用)
this()------------------------------------------调用构造方法(一般不用)

4. null：表示空，没有指向任何对象。

若引用的值为 null ，则该引用不能进行任何点操作了，若操作则发生 NullPointerException 空

指针异常。

5. 抽象方法与抽象类：

抽象方法：

由abstract修饰
只有方法的定义，没有具体的实现(连{}都没有)

抽象类：

由abstract修饰
包含抽象方法的类必须是抽象类
抽象类不能被实例化(new对象)
抽象类是需要被继承的，派生类：

重写抽象方法---------------变不完整为完整

也声明为抽象类------------一般不这么用

抽象类的意义：

封装共有的属性和行为-------------------代码复用

为所有派生类提供统一的类型----------向上造型(代码复用)

可以包含抽象方法，为所有派生类提供统一的入口(向上造型后能点出来)，同时可以达到强制必须重写的目的(相当于制定了一个标准)

三.常量

static final常量：

必须声明同时初始化
由类名打点来访问，不能被改变
建议：常量所有字母都大写，多个单词用_分隔
编译器在编译时会将常量直接替换为具体的数，效率高
何时用：数据永远不变，并且经常使用

四.继承

1.继承的理论和概念

作用：代码复用
通过extends来实现继承
超类/父类：共有的属性和行为派生类/子类：特有的属性和行为
派生类可以访问派生类的+超类的，但超类不能访问派生类的
一个超类可以有多个派生类，但一个派生类只能继承一个超类-----------单一继承
继承具有传递性
java规定：构造派生类之前必须先构造超类

在派生类的构造方法中若没有调用超类的构造方法，则默认super()调用超类的无参构造

方法

在派生类的构造方法中若自己调用了超类的构造方法，则不再默认提供

注意：super()调用超类构造方法，必须位于派生类构造方法的第一行

2super：

指代当前对象的超类对象

super 的用法：

super.成员变量名-------------------------访问超类的成员变量
super.方法名()-----------------------------调用超类的方法-------------------明天下午讲
super()---------------------------------------调用超类的构造方法

2.方法的重写(override/overriding)：重新写、覆盖

发生在父子类中，方法名相同，参数列表相同
重写方法被调用时，看对象的类型-----------------------这是规定，记住就OK
重写需遵循"两同两小一大"原则：

两同：方法名相同参数列表相同

两小：派生类方法的返回值类型小于或等于超类方法的void和基本类型时，必须相等。引用类型时，小于或等于。派生类方法抛出的异常小于或等于超类方法的

一大：派生类方法的访问权限大于或等于超类方法的。

重写：发生在父子类中，方法名相同，参数列表相同

重载：发生在同一类中，方法名相同，参数列表不同

五.多态。

1.多态：多种形态

同一个对象被造型为不同的类型时，有不同的功能
同一类型的引用在指向不同的对象时，有不同的实现----所有抽象方法都是多态的

2.向上造型

超类型的引用指向派生类的对象------前面是超类型，后面是派生类型
能点出来什么，看引用的类型
能造型成为的数据类型：超类+所实现的接口

何时向上造型：

多种角色能干的事都一样的时候，可以将多种角色统一造型到超类数组中，实现代

码复用

3.访问控制修饰符和修饰符：

public：公开的，任何类
private：私有的，本类
protected：受保护的，本类、派生类、同包类
默认的：什么也不写，本类、同包类

说明：

1. java 不建议默认访问权限

2. 类的访问权限只能是 public 或默认的，类中成员的访问权限如上 4 种都可以

3. 访问权限由小到大依次为： private< 默认的 <protected<public

修饰符：

final ：最终的、不能改变的 ----------------- 单独应用几率低

修饰变量：变量不能被改变
修饰方法：方法不能被重写
修饰类：类不能被继承

4.static：静态的

静态变量：

由static修饰
属于类，存储在方法区中，一份
常常通过类名点来访问
何时用：所有对象所共享的数据(图片、音频、视频等)

静态方法：

由static修饰
属于类，存储在方法区中，一份
常常通过类名点来访问
静态方法中没有隐式this传递，所以不能直接访问实例成员，只能直接访问静态成员
何时用：方法的操作与对象无关----方法中不需要访问对象的属性或行为

静态块：

由static修饰
属于类，在类被加载时自动执行，因为一个类只被加载一次，所以静态块也只执行一次
何时用：加载/初始化静态资源(图片、音频、视频等)

5.强制类型转换

强制类型转换，成功的条件只有两种：
- 引用所指向的对象，就是该类型
- 引用所指向的对象，实现了该接口或继承了该类
强转时若不满足如上条件，则发生ClassCastException类型转换异常

建议：在强转之前先通过instanceof来判断引用指向的对象是否是该类

instanceof会返回true或false的结果

如果满足强转成功的条件则返回true，否则返回false

何时需要强转：向上造型后，若想访问的东西在超类中没有，则需要强转

六.内部类

1.成员内部类

类中套类，外面的称为外部类，里面的称为内部类
内部类通常只服务于外部类，对外不具备可见性
内部类对象通常在外部类中创建
内部类中可以直接访问外部类的成员(包括私有的)
内部类中有一个隐式的引用，指向了创建它的外部类对象 ---外部类名.this

2.匿名内部类

若想创建一个类(派生类)的对象，并且对象只被创建一次，此时可以设计为匿名内部类
在匿名内部类中不能修饰外面局部变量的值，因为该变量在此处会默认为final的
内部类有独立的.class

七.接口

是一种数据类型(引用类型)
由interface定义
只能包含常量和抽象方法(所有数据默认都是常量，所有方法默认都是抽象的)
接口不能被实例化
接口是需要被实现/继承的，实现/派生类：必须重写所有抽象方法
一个类可以实现多个接口，用逗号分隔。若又继承又实现时，应先继承后实现。
接口可以继承接口

八.面向对象三大特征总结：

封装：
- 类：封装的是对象的属性和行为
- 方法：封装的是具体的业务逻辑功能实现
- 访问控制修饰符：封装的是具体的访问权限
继承：
- 作用：代码复用
- 超类：所有派生类所共有的属性和行为
  
  接口：部分派生类所共有的属性和行为
  
  派生类：派生类所特有的属性和行为
- 单一继承、多接口实现，具有传递性
多态：
- 所有对象都是多态的，通过向上造型来体现
  
  所有抽象方法都是多态的，通过方法的重写来体现
- 向上造型、强制类型转换、instanceof判断

*内存管理（渐渐补充）

由JVM管理

堆：
- 存储new出来的对象(包括实例变量、数组的元素)
- 垃圾：没有任何引用所指向的对象
  
  垃圾回收器(GC)不定时到内存堆中清扫垃圾，回收过程是透明的(看不到的)，
  
  不一定一发现垃圾就立刻回收，通过调用System.gc()可以建议虚拟机尽快调度GC来回收
- 实例变量的生命周期：
  
  创建(new)对象时存储在堆中，对象被回收时一并被回收
- 内存泄漏：不再使用的对象还没有被及时的回收，严重的泄漏会导致系统的崩溃
  
  建议：不再使用的对象应及时将引用设置为null
栈：
- 存储正在调用的方法中的局部变量(包括方法的参数)
- 调用方法时，会在栈中为该方法分配一块对应的栈帧，栈帧中存储局部变量(包括方法的参数)，
  
  方法调用结束时，栈帧被自动清除，局部变量一并被清除。
- 局部变量的生命周期：
  
  调用方法时存储在栈中，方法结束时与栈帧一并被清除
方法区：
- 存储.class字节码文件(包括静态变量、所有方法)
- 方法只有一份，通过this来区分具体的调用对象

（三）常用流以及其相关知识

一.File~

1.File：File file=new File("路径"）

声明方法2：File file=new File(file,"路径");将路径指向到file文件中

使用File时要使用路径，路径可以使用绝对路径，也可以使用相对路径。（推荐使用相对路径，使用相对路径来说代码移植性比较好，具有良好的跨平台性）。

./指当前目录，取决于运行环境，在用IDEA运行Java时，这里指定的当前目录就是当前程序所在的项目目录。

File常用方法：

length():返回一个long值，代表当前文件所占用的磁盘数。
canRead（）：判断是否可读。
canWrite():：判断是否可写。
isHidden()：判断文件是否被隐藏。
createNewFile():创建一个文件，如果创建文件所指向目录不存在则会抛出异常：java.io.FileNotFoundException。
mkdir():创建一个文件夹。
mkdirs():创建以文件夹，如果指定目录不存在则会自动生成目录。
delete()：删除文件或者文件夹，如果被删除文件夹中有子目录或者文件则删除失败。
exists（）：判断所指向文件夹或者目录是否存在。
isFile：判断是不是一个文件。
isDirectory()：判断当前File表示的是否为一个目录
listFiles()：获取File表示的目录中的所有子项
listFiles(FileFilter filter)：获取File表示的目录中满足filter过滤器要求的所有子项

二.流的概念

2.1.io流相关概念：

IO流分别有输入流和输出流两种，输入I为input输入流，O为Output输出流。
输入:用来读取数据的,是从外界到程序的方向,用于获取数据.
输出:用来写出数据的,是从程序到外界的方向,用于发送数据.

java将IO比喻为"流",即:stream. 就像生活中的"电流","水流"一样,它是以同一个方向顺序移动的过程.只不过这里流动的是字节(2进制数据).所以在IO中有输入流和输出流之分,我们理解他们是连接程序与另一端的"管道",用于获取或发送数据到另一端.。

2.2 JAVA中定义了两个超类（抽象类）：

java.io.InputStream:所有字节输入流的超类,其中定义了读取数据的方法.因此将来不管读取的是什么设备(连接该设备的流)都有这些读取的方法,因此我们可以用相同的方法读取不同设备中的数据
java.io.OutputStream:所有字节输出流的超类,其中定义了写出数据的方法.

2.3 JAVA将流分为两类分别为节点流和处理流：

节点流：又称为低级流，节点流的另一端是明确的，是实际读写数据的流，读写一定建立在节点流的基础上进行。
处理流：又称为高级流，高级流不能独立存在必须连接到其他流上来进行使用，目的是当数据流过当前流是对数据进项加工和处理，来简化我们对数据的操作。

实际应用中,我们可以通过串联一组高级流到某个低级流上以流水线式的加工处理对某设备的数据进行读写,这个过程也成为流的连接,这也是IO的精髓所在.

三.文件流

文件流是一组低级流，用来读写文件数据的流，用于连接程序与文件（硬盘）负责读与写文件数据。

3.1文件输出流:java.io.FileOutputStream

文件输出流常用构造器

FileOutputStream fos=FileOutputStream(String filename);
FileOutputStream fos=FileOutputStream(File file);
/*上述两种构造器都会在创建时将该文件创建出来(如果该文件不存在才会这样做)，自动创建
该文件的前提是该文件所在的目录必须存在，否则会抛出异常。**/

懒惰的草莓

关注

2
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
2.Java笔记（已更完面向对象和基础知识）

现实生活中是由很多很多对象组成的，基于对象抽出了类对象软件中真实存在的单个个体/东西类类型/类别，代表一类个体类是对象的模板/模子，对象是类的具体的实例类中可以包含对象的属性/特征成员变量对象的行为/动作/功能方法成员变量又分为静态变量和实例变量静态方法属于类通常需要类名来打点，实例变量属于对象需要对象名来打点。6.一个类可以创建多个对象封装类封装的是对象的属性和行为方法封装的是具体的业务逻辑功能实现访问控制修饰符封装的是具体的访问权限。......
复制链接

扫一扫