JavaSE初步学习笔记

PS:个人用来随时记录学习的过程，格式比较混乱，仅供个人参考与复习知识点

Dos命令行，课程中常见的命令

Dir:列出当前目录下包含的文件

Md:在当前目录下创建文件

Rd:在当前目录下删除指定文件夹(文件必须是空的)

Cd:进入下一级目录

Cd..:一级一级向上层目录返回

Cd/:直接回退到根目录

Del:删除文件时使用。Del+文件夹名  是删除该文件夹中的内容

Del+空格+*.后缀名 删除当前文件夹中指定类型的文件

Exit:退出dos命令行

“+”运算符两侧的操作数中只要有一个是字符串(String)类型，系统会将另外一个操作数转化为字符串后再进行连接。

Int c=12;

System.out.println(“c=”+c);

当进行打印时，无论任何类型，都自动转化为字符串进行打印

逻辑运算符

!—逻辑非  &--逻辑与  |--逻辑或  ^--逻辑异或  &&--短路与  ||--短路与

逻辑与短路与在运算结果上没有差别，但是在运算过程中有差别。在短路与中第一个值为false，后面的值就不再判断，因为此时整个表达式的值已经确定下来为false。但是逻辑与仍然会计算后面的值。逻辑或与短路或同理。

逻辑异或为当两个值不同时为真，相同时为假。

Switch语句（条件语句补充）

1.     小心case穿透，推荐使用break语句

2.     多个case可以合并到一起

3.     Default可以省略，但不推荐省略

4.     Switch

5.     Java中switch语句只能探测int类型的值

什么什么是什么什么-----继承关系

什么什么是什么什么的一部分-----聚合关系

组合是严格的聚合关系

实现关系

父类有方法，交给子类去实现，子类不同的方法，这种关系称为实现关系

面向对象：1.在问题中分析有什么类，有什么对象

2.考虑类的属性和方法

3.考虑类和类之间的关系

成员变量可以使用Java语言中任何一种数据类型（包括基本类型和引用类型）。

再定义成员变量时可以对其初始化，如果不对其进行初始化，Java使用默认的对其初始化。如下

Byte 0

Short 0

Int 0

Long 0L

Char ‘\u0000’

Float 0.0F

Double 0.0D

Boolean false

所有引用类型 null

成员变量的作用范围为整个类体

Java面向对象基本概念—引用

1.     Java语言中除基本类型之外的变量都称之为引用类型

2.     Java中的对象是通过引用对其操作的。

由一块小的内存区（栈空间）的内存区（堆空间中）

如何在内存中区分类和对象

1.     类是静态的概念，代码区

2.     对象是new出来的，位于堆内存，类的每个成员变量在不同的对象中都有不同的值（除了静态变量）而方法只有一份，执行的时候才占用内存。

约定俗成的命名规则

1.     类名的首字母大写

2.     变量名和方法名的首字母小写

3.     运用驼峰标识

非静态方法是针对每个对象进行调用 method前面没有static标识符的

Package和import需要注意的几点

1.     如果要把一个类放入到包中，第一句话写package package后面想跟多少层包就跟多少层包。需要注意的是，编译出来的class文件必须位于正确的目录下面，即要和包的层次完全一致

2.     如果要在另外一个包中使用创建好的类，必须把名字写完整。否则会被认为是在用裸体类。通过import来引入包。Import后加包名

3.     寻找时默认从当前目录开始往下查找，会访问classpath环境变量，挨个查找，查找不到就没有。否则，直接在再没有配置classpath的情况下直接按照原来的classpath查找，这样是查找不到的。

4.     Package import总结

a)      如果想讲一个类放入包中，在这个源文件第一句话写package

b)      必须保证该类的class文件位于正确目录下

i.           该类的源码可能会产生影响

ii.           删除或转移到另外的目录

c)      另外的类想访问的话:

i.           写全名

ii.           引入

1.       *

2.       具体类名

iii.           访问位于同一个包中放入类不需要引入

d)      必须class文件的最上层包的父目录位于classpath下

e)      执行一个类需要写全包名

Java.lang中的类使用不需要使用import，其他类都需要import语句引用

Java打包语句 java -cvf 包名.jar 需要的打包的文件名

继承中的构造方法

1.     子类的构造过程中必须调用其基类的构造方法

2.     子类可以在自己的构造方法中使用(argument_list)调用基类的构造法方法

a)      使用this(argument_list)调用本类的另外的构造方法

b)      如果调用super，必须写在子类构造方法的第一行

3.     如果子类的构造方法中没有显示地调用基类构造方法，那么系统默认地调用基类无参数的构造方法

4.     如果子类构造方法中既没有显示地调用基类构造方法，而基类中有没有无参数的构造方法，则编译出错

对象转型(casting)

1.     一个基类的引用类型变量可以“指向”其子类的对象

2.     一个基类的引用不可以访问其子类对象新增加的成员（属性和方法）

3.     可以使用引用变量instanceof类名来判断引用类型所“指向”对象是否属于该类或该类放入子类

4.     子类的对象可以当作基类放入对象来使用称作向上转型（upcasting），反之称为向下转型（downcasting）

动态绑定和多态

1.动态绑定是指”在执行期间（而非编译期间）判断所引用对象的实际类型，根据其实际的类型调用其实际的方法“

多态产生的条件：

1.     要有继承

2.     要有重写

3.     父类引用指向子类对象

当调用父类对象中被重写的方法时，实际当中new的是谁的对象就调用谁的方法

动态绑定能够使可扩展性达到极致

抽象类：

1.     用abstract关键字来修饰一个类时，这个类叫做抽象类；用abstract来修饰一个方法时，该方法叫做抽象方法。

2.     含有抽象方法的类必须被声明为抽象类，抽象类必须被继承，抽象方法必须被重写。

3.     抽象类不能被实例化

4.     抽象方法只需声明，而不需要实现

Final关键字

1.     final的变量的值不能被变改变

a)      final的成员变量

b)      final的局部变量（形参）

2.     final的方法不能够被重写

3.     final的类不能够被继承

1.     内存分析贯穿始终

2.     对象和类的概念

3.     类（对象）之间的练习

4.     面向对象设计思想

5.     Class

6.     New

a)      引用的概念

b)      构造方法的概念

7.     方法重载

a)      构造方法重载

8.     This

9.     Static

10.  Package & import

11.  Private default protectedpublic

12.  Extends

13.  Overwrite

14.  Final

15.  Object

a)      ToString

b)      Equals

16.  Upcasting / dynamic binding./late

17.  Abstract class

18.  Interface

a)      Implements

Catch

利用错误类型的对象来返回一些信息：

1.     getMessage() 方法，用来得到有关异常事件的信息。

2.     printStackTrace()方法，用来跟踪异常事件发生时执行堆栈的内容。

任何方法都可以将无法处理的错误进行throw。在方法开始声明可能抛出的异常的时候用throws而不是throw。

编写自己的exception的时候extends自于Exception

Catch错误的时候，先逮小的，再逮大的

String类的常见构造方法：

1.     String(String original)

a)      创建一个String对象为original的拷贝

2.     String(cahr[] value)

a)      用一个字符数组创建一个String对象

3.     String(char[] value,int offset,int count)

a)      用一个字符数组从offset项开始的count个字符序列创建一个String对象

基础包装类（四类八种）查询API文档

//递归方法列出文件目录下的文件

import java.io.*;

public class FileList {

publicstatic void main(String[] args) {

Filef = new File("e:/java_code/day06");

System.out.println(f.getName());

tree(f,1);

}

privatestatic void tree(File f, int level) {

StringpreStr = "";

for(inti = 0;i < level;i++) {

preStr+="    ";

}

File[]childs = f.listFiles();//列出当前目前目录下的孩子们

for(inti = 0 ;i < childs.length;i ++) {

System.out.println(preStr+ childs[i].getName());

if(childs[i].isDirectory()){

tree(childs[i],level + 1);

}

}

}

}

Enum定义的时候只能直接给出列出来的值，而不能通过int值来访问Enum中的值，与C不同。

File//代表文件名，而非文件里的内容

Array读快改慢

Linked改快读慢

Hash两者之间

1.     PrintWriter和PrintStream有自动的flush功能

2.     PrintWriter和PrintStream的输出操作不会抛出异常

3.     PrintWriter和PrintStream都属于输出流，分别对应字符和字节

IO总结：

1.     Inputstream/Outputstream

2.     Reader/Writer

3.     FileInputStream/FileOutputStream

4.     FileReader/FileWriter

5.     BufferedInputStream/bo

6.     BufferedReader/BufferedWriter

7.     Bytearrayinputstream/butearrao

8.     Inputstreamreader/outputstreamwriter

9.     Datainputstream/out

10.  PrintStream/PrintWriter

11.  Objectinputstream/out

进程:进程一个静态的概念

线程：进程里面有一个主线程，线程是进程里面的多路径执行过程

在支持多线程的操作系统中，一个CPU在某一个时间点上只支持一个线程的执行

从接口做一个线程比直接从Thread类继承做线程要好一些，因为具有更多的灵活性。继承只能继承一个类。

线程new 出来之后没有启动start，也是死线程

Sleep / join / yield

睡眠 / 加入 / 退让

死锁：五个哲学家吃饭问题

把锁的粒度加粗

生产者与消费者经典案例

面试：Wait sleep区别

1.     Wait(Object)时别的线程可以访问锁定对象

a)      调用wait方法的时候必须锁定该对象

2.     Sleep(Thread)时别的线程也不可以访问锁定对象

线程总结：

1.     线程/进程的概念

2.     创建和启动线程的方式

3.     Sleep

4.     Join

5.     Yield

6.     Synchronized

7.     Wait

8.     Notify/notifyAll

OSI参考模型：

1.     物理层

2.     数据链路层

3.     网络层

4.     传输层

5.     会话层

6.     表示层

7.     应用层

TCP/IP参考模型

1.     物理+数据链路层

2.     网络层/IP层

3.     传输层

4.     应用层

一台机器上一个端口号占两个字节，可以表示65536个应用程序

TCP/UDP端口号是分开的

能够从Frame继承重写自己的MyFrame就尽量多用，因为自己写的能够定义更多的成员变量，更加灵活

Frame的缺省布局管理器是BorderLayout/ Panel的缺省布局管理器是FlowLayout

内部类：

1.     好处：

a)      可以方便地访问包装类的成员

b)      可以更清楚的组织逻辑，防止不应该被其他类访问的类进行访问

2.     何时使用：

3.     该类不允许或不需要其他类进行访问时

每次需要重画的时候自动调用paint方法

Repaint->update()->paint()   //update实现双缓冲