java学习笔记

1. 构造代码块：

作用：给对象进行初始化，对象一建立就运行，而且优先于构造函数执行和构造函数的区别：构造代码块是给所有进行统一初始化，而构造函数是给对应对象进行初始化，必需与对象的参数一致，但构造代码块与对象参数无关。

2. 构造函数

当对象的参数与构造函数的参数一致时，对象一建立，对应的构造函数就运行，不需要调用，且只运行一次。但也可以建立其他方法，,且其他方法可以执行多次，只要调用即可，方便后面对该构造函数中参数的更改。构造函数一旦私有化，就不能创建参数与之对应的对象，应为对象不能进行相应的初始化。

3. this指针

this:区分局部变量和成员变量同名的情况，指的是当前对象，代表所在函数所属对象的引用，那个对象在调用this所在函数，this就代表谁。this只是对象的引用，当定义函数功能时，该函数内部要用到调用该函数的对象时，这时用this来表示这个对象，但凡本类功能内部使用到了本类对象，用this关键字。

构造函数间相互调用，用this（参数）；即this语句，this指的是当前对象的构造函数，且不能用在一般函数中。类中一般函数相互调用，直接用函数名即可，但构造函数的调用必需用this（参数）语句，且this语句只能放在构造函数的第一行。

构造函数私有化时，可进行构造函数的调用，初始化中还有更细节的初始化，应先执行更细节的初始化，在执行外层的初始化。
this代表本类对象的引用，且默认为this，super代表父类的引用，子类成员与父类同名时，若想访问父类变量，用super关键字。

4. static关键字

用于修饰成员变量和成员函数，不能修饰局部变量，静态修饰的内容被所有对象所共享，当多个对象拥有相同的数据时，此时被修饰的成员可以被类直接调用，即class.member。特有内容随着对象存储，而共性内容随着类存储，随着类的消失而消失，被所有对象共享，优先于对象存在，静态数据存在于共享区（方法区）
，与方法放于同一片内存。要依据实际需求使用。

静态方法只能调用静态变量和静态方法，因为此时没有对象，所以只能访问静态属性和静态方法，非静态既能访问静态也能访问非静态。静态方法中不能定义this和super关键字，因为静态优先于对象存在，而this和super代表对象。如：static country = china。

当函数内部没有访问到非静态（特殊）数据时，那么该函数定义成静态，所以静态函数一般与静态属性一起存在。一般工具类中的函数都是静态的，此时创建该工具类没意义，但可以创建对应对象，直接类名.函数名（），为了更为严谨，通常将构造函数私有化，不让改类创建对象。

5. 函数重载

函数名，返回类型相同，参数不同。

String[] args = new String[0];java MainDemo haha hehe heihei:jvm将三个元素传给String[] args。

6. set classpath

即指定文件，如未设定，默认当前路径。

7. 静态代码块

static{}

静态代码块随着类的加载执行，并优先于主函数执行，且只执行一次（即使是创建了多个对象也只执行一次），只要类加载就会执行，用于给类进行初始化，但一般用对象进行初始化，而构造函数给对象进行初始化。只要创建一个非空的对象，类就会执行，因为回调用默认构造函数。

8.,构造函数的执行：

Person p = new Person();

1. 先找到.class文件并加载到内存。
2. 执行该类中的static代码块，如果有的话，给person.class进行初始化。
3. 在堆内存中开辟内存空间，分配内存地址。
4. 在堆内存中建立对象的特有属性，并进行默认初始化。
5. 对属性进行显示初始化。
6. 对对象进行构造代码初始化。
7. 对对象进行对应的构造函数初始化。
8. 将内存地址赋给栈内存中的p变量。

9. 单例设计模式

为了禁止某个类创建对象，可将构造函数私有化。如：

class Single{    private Single(){}    private static Single s = new Single();    public static Single getInstance(){        return s;    }}class SingleDemo{    public static void main(Sting[] args){        Single ss = Single.getInstance();//通过类名调用，此时不能用new创建对象。    }}

10. 聚合和组合：

• 聚合：球队与球员。
• 组合：联系更紧密，手与身体。

11. 函数覆盖、重载、重写:

• 覆盖：当子类与父类有相同的函数时，称为函数的覆盖（重写），此时默认执行子类的函数，如果想调用父类的方法，用super.function()。当子类沿袭父类，也沿袭了父类的功能到子类中，但是子类虽然具备该功能，但是功能内容不同时，此时没必要定义新功能，而是使用覆盖特性，保留父类的功能定义，并重写功能内容。一般用于旧功能的升级，避免改变源代码。还可以用于程序功能的扩展，若要沿袭父类的功能，用super.function();子类若想覆盖父类，必需保证子类权限大于或等于父类权限，否则编译失败。静态只能覆盖静态。
• 重载：只看同名函数的参数列表，不管返回值类型。
• 重写：子父类方法要一模一样，返回值类型也必需相同，如果子父类中同名函数参数列表相同，但返回值类型不同，则编译失败。

12，继承

继承时，创建子类对象时，先加载父类，再加载子类。

13. super关键字/子类的实例化过程

super语句只能在构造函数中使用，且子类构造函数的第一行默认有一条隐示语句super();但super（参数）；却不能隐示。当父类中没有空参数构造函数时，必需手动加上super（参数）；，否则编译失败。因为在调用父类时，必需先了解父类构造函数中的初始化动作。如果要访问父类中指定的构造函数，可以通过手动定义super语句的方式指定。且super(参数)；只能放在构造函数的第一行，先访问父类的构造函数，否则编译失败。

子类中的所有构造函数都会访问父类中的空参数构造函数。因为子类每一个构造函数的第一行都有一句隐示super();当父类中没有空参数的构造函数时，子类必需手动通过super语句或者this语句形式来指定要访问的父类的构造函数。子类的构造函数第一行也可以手动指定this语句来访问本类中的构造函数子类中至少会有一个构造函数会访问父类中的构造函数。

. 14.final 关键字（最终）

应对继承对封装性的挑战。final修饰的类不能被继承，final修饰的方法不能被复写，但该方法仍能被调用。final既可以修饰成员变量，也可以修饰局部变量，但该变量的值不能再改变。一般用于增强阅读性，突出该数据的作用，被final修饰的变量全部大写，多个单词用下划线（_)连接。用在成员时，一般用static final，用来共享。内部类定义在类中的局部位置是，只能访问该局部被final修饰的局部变量。类修饰符有final，public，要区分类修饰符与成员修饰符。

. 15. 抽象方法

抽象方法必需存放于抽象类中，表示看不懂的类和看不懂的方法，抽象方法（如abstract void function();区分function(){})和抽象类必需被abstract关键字修饰，且抽象类不能由new创建对象，因为调用抽象方法没意义。

抽象类中的抽象方法要被使用，必需由子类复写其中的所有抽象方法，再建立子类对象调用。如果子类只覆盖了部分抽象方法，那么该子类还是一个抽象类，不能再创建对象。抽象方法是强迫子类去复写其功能。抽象类中可以定义非抽象方法，能直接被子类对象使用，且不需要被复写。

abstract只能修饰类和方法，不能修饰属性。抽象类中也可以一个抽象方法也没有，母的是不让该类创建对象。

16，abstract和final

lang包中的System类，有一个long currentTimeMillion（）方法,返回与1970年1月1日的时间差，单位ms。
强制某个方法被复写（abstract）和某个方法不被复写（final）

abstract class GetTime{    public final void getTime(){        long strat = System.currentTimeMillion();        runCode();        long end = System.currentTimeMillion();        return (end-strat);    }    //子类对象只需覆盖runCode()方法即可    public abstract void runCode(){        for(;;)    }}class SubTime extends GetTime{    //子类对象只需覆盖runCode()方法即可。    public abstract void runCode(){        for(;;)    }    SubTime st = new SubTime();    st. getTime();}

17，设计模式：

模板方法设计模式，定义功能时，功能的一部分确定，另一部分不确定，而确定的部分在使用不确定的部分，那么这时就将不确定的部分暴露出去，但暴露的
部分不一定要抽象，由其子类来完成。

18,接口

相当于是一个特殊的抽象类，此抽象类中的方法全部为抽象方法，那么该类通过接口的形式来表示。接口中的方法全部为抽象方法。

接口中的常见定义，格式特点：
+ 常量，抽象方法
+ 接口中的成员都有固定修饰符。
+ 变量（全局常量）：public static final
方法：publlc abstract function();
+ 接口中的成员全是public,但常量前面的public static final或publlc abstract可以省去，jvm默认会加上，但建议写上。方法要么{}结尾，要么abstract修饰，即以；结束。

• 一个interface编译后也会生成一个class文件。
  ！接口不能创建对象，因为接口中有抽象方法要被子类复写。子类对接口中的抽象方法全部覆盖后，子类才可以实例化对象。否则子类是一个抽象类，不能实例化对象。覆盖接口中的方法时，权限必须是public(与抽象类的区别）。

• 接口可以被多实现。

• 当既有继承又有实现时，先继承后实现。
• 接口之间也可以相互继承，但不能实现。且接口之间可以多继承，因为都没有方法体，即用多实现的方式来实现。

19. 多态

事物存在的多种表现形态，即父类变量可以指向子类对象(父类的引用指向了自己子类的对象），父类引用也可以接受本类对象，只是另外一个名称而已。如同一函数在子类和父类中同时存在，同名函数在一个类中多次出现。

多态提高了代码的扩展性，但使用的前提是，必需是类与类之间必须有某种关系，且必需有覆盖，只能使用父类引用访问父类
中的成员。多态中存在自动的向上转型。

用多态创建的对象Animal a = new Cat()只能使用父类的方法，但子类中可以不用复写（父类中此方法非抽象），否则编译失败（ClassCastException类型转换异常），若要使其具有子类的特殊方法，就要使用强制类型转换(cat)c;此后c仍是Animal,但(Cat)c是cat。

Person p = new Students();//此时p调用的方法任然是子类的方法，但父类中也必需有该方法，且被子类覆盖。

多态中成员函数（非静态）的特点：
+ 编译时期：参阅引用型变量所属的类（父类）中是否有调用的方法。如果没有，编译失败。
+ 运行时期：参阅对象所属的类中是否有调用的方法，如果没有，运行父类的方法，否则运行自己的方法。
+ 静态成员函数的特点：无论编译还是运行，都参考左边。
+ 成员函数的特点：编译看左边，运行看右边。
+ 成员变量的特点：无论编译还是运行，都参考左边。

class DuoTai{    Cat c = new Cat();    function(c);//Cat c = new Animal();    //父类引用接受本类对象    public static void function (Animal a){    a.eat();    }}

20. instanceof关键字

判断某个对象是否是某种类 object instanceof ClassName,返回boolean类型

21, equal方法
Object类中的equals（object）方法：用于比较两个对象的地址值是否相同
用法：o1.eqals(o2),返回布尔类型值。若要自定义比较方法，建议覆盖equals()方法

Class A{    public boolean equals(Object obj){        if(p instanceof A)            return p.num == a .num;        return false;    }}

22, Object类中的toString()方法

相当于getClass（）.getName()+’@’+Integer.toHexString(obj.hashCode())。
用法：

• obj.toString(),返回该对象的字符串表示，即该对象所属的类+@+该对象的地址值（哈希值）。
• Integer.toHexString(obj.hashCode())只返回哈希值。
• Object类中的getClass()方法：一般要复写该方法，建立自己的自定义比较方法，因为返回的哈希值无实际意义。

23. 内部类（内置类，嵌套类）

在类的里面，建立内部类，放在与成员平行的位置。与其他类的定义无区别。内部类还可以建立在局部，可以访问外部类的成员，用Outer.this.x；且局部内部类不能被成员修饰符修饰。局部内部类可以直接访问外部类的成员，但是不可以访问他所在成员的变量，要想访问，该变量必需被final修饰。内部类要访问其外部类的成员（包括私有成员），可以不用建立其外部类的对象而直接访问，省略了OuterClassName.this.x,必要时自己加上。而外部类要想访问内部类，必需先建立内部类对象。若要直接访问内部类的成员，方法为

OuterClassName.InnerClassName in = new OuterClassName().InnerClassName();in.method();

且内部类可以私有化，被private修饰。当内部类被static修饰后，只能直接访问外部类中的static成员。

new Outer.Inner().function();//访问静态内部类中的非静态方法Outer.Inner.function()//访问静态内部类中的静态方法

当内部类中定义了静态成员，该内部类必须是static。当外部类中的静态方法访问访问内部类时，内部类也必须是static

24.打包（必须有package关键字）

• 存放于当前目录下
  
  • 编译时，javac -d . javaname.java。
    运行时：java packagename.ClassName
• 存放于指定目录下：
  编译时：javac -d C:\myclass javaname.java
  运行时：set classpath = C:\myclass 回车，然后java packagename.ClassName
  包与包之间相互访问，必须设定classpath,此外，被访问的类必须用public修饰，且被访问的成员也要被public修饰。包中的未被public修饰的类和变量不能被外部文件访问。

25. jar包

选项包括:

• -c 创建新的归档文件
• -t 列出归档目录
• -x 从档案中提取指定的 (或所有) 文件
• -u 更新现有的归档文件
• -v 在标准输出中生成详细输出
• -f 指定归档文件名
• -m 包含指定清单文件中的清单信息
• -e 为捆绑到可执行 jar 文件的独立应用程序,指定应用程序入口点。
• -0 仅存储; 不使用情况任何 ZIP 压缩
• -M 不创建条目的清单文件
• -i 为指定的 jar 文件生成索引信息

• -C 更改为指定的目录并包含其中的文件
  如果有任何目录文件, 则对其进行递归处理。清单文件名, 归档文件名和入口点名称的指定顺序与 ‘m’, ‘f’ 和 ‘e’ 标记的指定顺序相同。

• 示例 1: 将两个类文件归档到一个名为 classes.jar 的归档文件中:

       jar cvf classes.jar Foo.class Bar.class

• 示例 2: 使用现有的清单文件 ‘mymanifest’ 并将 foo/ 目录中的所有文件归档到 ‘classes.jar’ 中:

       jar cvfm classes.jar mymanifest -C foo/。

创建jar包：
先切换到所在目录，然后jar -cf jarname.jar packname1 packname2 ….
若想使用jar包中的class文件，set classpath = C:\myclass\jar.jar。然后java classname即可。

将jar包中的目录用txt文件列出，用jar -tf jar.jar >C:\1.txt
将dos中的目录在文件中显示，用dir >C:\2.txt

26. jar包双击执行

    jar -cvfm jarname.jar txtname.txt package

将主函数添加进去。注意双击执行jar文件时该文件所在目录不能有中文

27.eclipse的使用

不要带中文，空格！
+ Bad version number 编译，运行版本错误
+ F5:F6:跳入，F7跳出
+ 快捷键
+ Alt+/ 内容助理
+ Ctrl+1 快速修复
+ Ctrl+shift+O 导包
+ Ctrl+shift+f 格式化代码块
+ Alt+方向键 向前向后
+ 添加注释 Ctrl+shift+/
+ 去除注释 Ctrl+shift+\
+ F2 查看方法说明
+ window中有重置透视图
+ ctrl+shift+x 编程大写
+ ctrl+shift+y 变成小写
+ ctrl+Alt+向下键 复制多行代码
+ Alt+向上/向下 移动代码
+ Ctrl+t 查看类的继承关系
+ ctrl+鼠标放上
+ ctrl+shift+t 查看类的源代码
+ ctrl+shift+l 查看所有的快捷键

28. 操作集合和数组的增强for循环

for(变量类型 变量 ：需迭代的数组或集合){    System.out.println(num);}

29,可变参数

function (参数类型 变量；参数类型 …nums){
int sum = 0;
for(int i : nums){
sum+=i;
}
System.out.println(sum);
}

30 .static getLocalHost()方法

返回本地主机，打印主机名和地址。非静态方法
+ getHostAddress():返回 IP 地址字符串（以文本表现形式）。
+ getHostName(): 获取此 IP 地址的主机名。
+ getByName(String host): 在给定主机名的情况下确定主机的 IP 地址。
+ class DatagramSocket中的send(DatagramPacket p) 方法,从此套接字发送数据报包。 p指的是数据包。

32,发送数据的方法:

1. ，建立udpsocket服务

    DatagramSocket ds = new DatagramSocket();

1. 提供数据，并将数据封装到数据包中,通过DatagramPocket类创建数据包。

Byte[] buf = "udp ge men lai le".getBytes(); //创建数据DatagramPacket dp = new DatagramPacket(buf,buf.length,InetAddress.getByName("10.22.36.137"),10000);//打包数据

1. 通过socket服务的发送功能，将数据包发送出去

ds.send(dp);

1. 关闭资源

ds.close();

33. 接收数据的方法

1. 定义Udpsocket服务,建立端点
2. 定义一个数据包，因为要存储接收到的字节数据，因为数据包对象中有更多功能可以提取字节数据中的不同信息

byte [] buf = new byte[1024];DatagramPacket dp = new DatagramPacket(buf,buf.length);

1. 通过socket服务中的receive方法将收到的数据存入已定义好的数据包中

ds.receive(dp);

1. 通过数据包对象的特有功能，将这些不同的数据取出，打印在控制台上

String ip = dp.getAddress().getHostAddress();String data = new String(dp.getData(),0,dp.getLength());int port = dp.getPort();System.out.println(ip+":"+data+":"+port);

1. 关闭资源ds.close();