Java学习笔记

1、如何实现在main()方法执行前输出“hello world”
package java_less.jc;
//如何实现在main()方法执行前输出“hello world”
public class test01 {

public static void main(String args[]){
    System.out.println("Hello world 02");
}

static{
    System.out.println("Hello world 01");
}

}

2、Java程序初始化的顺序
package java_less.jc;

//Java程序初始化的顺序是怎样的
/*
父类静态变量=>父类静态代码块
子类静态变量 =>子类静态代码块
父类非静态变量 =>父类非静态代码块
父类构造函数 =>子类非静态变量
子类非静态代码块 =>子类构造函数*/

class Base{
static{
System.out.println(“Base static block 父类静态变量”);
}
{
System.out.println(“Base block 父类非静态代码块 “);
}
public Base(){
System.out.println(“Base constructor 父类非静态代码块”);
}
}

public class Derived extends Base{
static{
System.out.println(“Derived static block 子类静态变量”);
}
{
System.out.println(“Dervied block 子类静态代码块 “);
}
public Derived(){
System.out.println(“Derived constructor 子类非静态变量 “);
}
public static void main(String args[]){
new Derived();
}
}
3、Java中的作用域有哪些？
局部变量
全局变量
1）public 表明该成员变量或方法对所有类或对象都是可见的，所有类或对象都可以直接访问。
2）private 表明该成员变量或方法是私有的，只有当前类对其具有访问权限，除此之外的其他类或者对象都没有访问权限。
3）protected 表明该成员变量或方法对自己及其子类是可见的，即自己和子类具有权限访问。
4）default 表明该成员变量或方法只有自己和与其位于同一包内的类可见。

4、一个Java文件中是否可以定义多个类
class Base{
public void print(){
System.out.println(“Base”);
}
}
public class Derived extends Base{
public static void main(String[] a){
Base e = new Derived();
e.print();
}
}
5、什么是构造函数
是一种特殊的函数，用来在对象实例化时初始化对象的成员变量。
特点：
1）构造函数必须与类的名字相同，并且不能有返回值（返回值也不能为void）
2）每个类可以有多个构造函数。
3）构造函数可以有0个、1个或1个以上的参数
4）构造函数总是伴随着new操作一起调用，且不能由程序的编写者直接调用，必须要由系统调用。
5）构造函数的主要作用是完成对象的初始化工作
6）构造函数不能被继承，因此，它不能被覆盖，但是构造函数能够被重载，可以使用不同的参数个数或参数类型来定义多个构造函数。
7）子类可以通过super关键字来显示地调用父类的构造函数，当父类没有提供无参数的构造函数时，子类的构造函数中必须显示地调用父类的构造函数。
8）当父类和子类都没有定义构造函数时，编译器会为父类生成一个默认的无参数的构造函数，给子类也生成一个默认的无参数的构造函数。

public class Test{
public Test(){
Syste.out.println(“construct”);
}
public void Test(){
System.out.printIn(“call Test”)
}
public static void main(String[] args){
Test a = new Test();
a.Test();
}
}

6、为什么Java中有些接口没有任何方法
游戏程序：
—————start—————–
package java_less.jc;
import java.util.ArrayList;
interface Stuff{}
//矿石
interface Ore extends Stuff{}
interface Weapon extends Stuff{}
interface Rubbish extends Stuff{}

class Gold implements Ore{
public String toString(){
return “Gold”;
}
}
//铜矿
class Gopper implements Ore{
public String toString(){
return “Gopper”;
}
}
//枪
class Gun implements Weapon{
public String toString(){
return “Gun”;
}
}
//榴弹
class Grenade implements Weapon{
public String toString(){
return “Grenade”;
}
}

class Stone implements Rubbish{
public String toString(){
return “Stone”;
}
}

public class test02 {
public static ArrayList collectStuff(Stuff[] s){
ArrayList al = new ArrayList();
for(int i =0;i < s.length;i++){
if(!(s[i] instanceof Rubbish )) //判断对象是否是特定类的一个实例
al.add(s[i]);
}
return al;
}
public static void main(String[] args){
Stuff[] s = {new Gold(),new Gopper(),new Gun(),new Grenade(),new Stone()};
ArrayList al = collectStuff(s);
System.out.println(“The userfull stuff collected is: “);
for(int i = 0;i < al.size();i++){
System.out.println(al.get(i));
}
}
}
————–end————————–
7、Java中的clone方法有什么作用
每一个new语句返回的都是一个指针的引用
package java_less.jc;

class Obj{
public void setStr(String str){
this.str = str;
}
private String str = “default value”;
public String toString(){
return str;
}
}
public class TestRef{
private Obj oObj = new Obj();
private int aInt = 0;
public Obj getAObj(){
return oObj;
}
public int getAInt(){
return aInt;
}
public void changeObj(Obj inObj){
inObj.setStr(“changed value”);
}
public void changeInt(int inInt){
inInt = 1;
}
public static void main(String[] args){
TestRef oRef = new TestRef();
System.out.println(“**引用类型*******************”);
System.out.println(“调用changeObj()前：” + oRef.getAObj());
oRef.changeObj(oRef.getAObj());
System.out.println(“调用changeObj()后：” + oRef.getAObj());
System.out.println(“****************基本数量类型**“);

System.out.println("调用changeInt()前：" + oRef.getAInt());
oRef.changeInt(oRef.getAInt());
System.out.println("调用changeInt()后：" + oRef.getAInt());
}

}
结果：
**引用类型*******************
调用changeObj()前：default value
调用changeObj()后：changed value
****************基本数量类型**
调用changeInt()前：0
调用changeInt()后：0
结果不一样的原因：Java在处理基本数据类型（例如：int、char、double等）时，都是采用按值传递(传递的是输入参数的复制)的方式执行，除此之外的其他类型都是按引用传递(传递的是对象的一个引用)的方式执行。

对象除了在函数调用时是引用传递，在使用“=”赋值时也采用引用传递：
class Obj{
private int aInt = 0;
public int getAInt(){
return aInt;
}
public void setAInt(int int1){
aInt = int1;
}
public void changeInt(){
this.aInt = 1;
}
}
public class TestRef{
public static void main(String[] args){
Obj a = new Obj();
Obj b = a;
System.out.println(“b转变前:” + b.getAInt());
b.changeInt();
System.out.println(“a:” + a.getAInt());
System.out.println(“b:” + b.getAInt());
}
}

在实际编程中，经常会遇到从某个已有的对象A创建出另外一个与A具有相同状态的对象B并且对B的修改不会影响到A的情况
使用Clone()方法的步骤:
1)实现clone的类首先需要继承Cloneable接口。Cloneable接口实质上是一个标识接口，没有任何接口方法。
2)在类中重写Object类中的clone()方法
3)在clone方法中调用super.clone.无论clone类的继承结构是什么，super.clone()都会直接或间接调用java.lang。Object类的clone()方法。
4)把浅复制的引用指向原型对象的克隆体。

浅复制实例：
package java_less.jc;
class Obj implements Cloneable{
private int aInt = 0;
public int getAInt(){
return aInt;
}
public void setAInt(int int1){
this.aInt = 1;
}
public void changeInt(){
this.aInt = 1;
}
public Object clone(){
Object o = null;
try{
o = (Obj)super.clone();
}catch(CloneNotSupportedException e){
e.printStackTrace();
}
return o;
}
}

public class TestRef{
public static void main(String[] args){
Obj a = new Obj();
Obj b = (Obj)a.clone();
b.changeInt();
System.out.println(“a:” + a.getAInt());
System.out.println(“b:” + b.getAInt());
}
}

深复制：
package java_less.jc;
import java.util.Date;
class Obj implements Cloneable{
private Date birth = new Date();
public Date getBirth(){
return birth;
}
public void setBirth(Date birth){
this.birth = birth;
}
public void changeDate(){
this.birth.setMonth(4);
}
public Object clone(){
Obj o = null;
try{
o = (Obj)super.clone();
}catch(CloneNotSupportedException e){
e.printStackTrace();
}

o.birth = (Date)this.getBirth().clone();
return o;
}

}
public class TestRef{
public static void main(String[] args){
Obj a = new Obj();
Obj b = (Obj)a.clone();
b.changeDate();
System.out.println(“a=” + a.getBirth());
System.out.println(“b=” + b.getBirth());
}
}

浅复制(Shallow Clone)：被复制对象的所有变量都含有与原来对象相同的值，而所有对其他对象的引用仍然指向原来的对象。
深复制(Deep Clone)：被复制对象的所有变量都含有与原来对象相同的值，除去那些引用其他对象的变量。

什么是反射机制
反射机制：Java语言中一个非常重要的特性，它允许程序在运行时进行自我检查，同时也允许对其内部成员进行操作。
功能：
1、得到一个对象所属的类
2、获取一个类的所有成员变量和方法
3、在运行时创建对象
4、在运行时调用对象的方法
5、在运行时动态地创建类的对象
三种方法可以获取到class类
1）class.forName(“类的路径”)
2)类名.class
3)实例.getClass()

package java_less.jc;

class Base{
public void f(){
System.out.println(“Base”);
}
}

class Sub extends Base{
public void f(){
System.out.println(“Sub”);
}
}

public class TestRef{
public static void main(String[] args){
try{//使用反射机制加载类
Class c = Class.forName(“java_less.jc.Sub”);
Base b = (Base)c.newInstance();
b.f();
}catch(Exception e){
e.printStackTrace();
}
}
}

package 有什么作用
package com.pkg;
public class TestPackage{
public static void main(String[] args){
System.out.println(“Hello world”);
}
}

如何实现类似于C语言中函数指针的功能
回调：在Windows系统中，开发人员想让系统动态链接库（Dynamic Link Library）DLL调用自己编写的一个方法，于是利用DLL当中回调函数的接口来编写程序，通过系统传递一个函数的指针来被调用，这个过程就称为回调。
回调函数一般用于截获消息、获取系统信息或处理异步事件。

package java_less.jc;

interface IntCompare{
public int cmp(int a,int b);
}

class Cmp1 implements IntCompare{
public int cmp(int a,int b){
if(a>b)
return 1;
else if(a < b)
return -1;
else
return 0;
}
}

class Cmp2 implements IntCompare{
public int cmp(int a,int b){
if(a > b)
return -1;
else if(a < b)
return 1;
else
return 0;
}
}
public class TestRef{
public static void insertSort(int[] a,IntCompare cmp){
if(a != null){
for(int i=1;i

}

——–Java反射机制———————————————
Mainboard.java
package main.java.com.zyf.test;

/**
* Created by zyf on 2016/8/4.
*/
public class Mainboard {

public void run() {
    System.out.println("main board run....");
}

public void usePCI(PCI p) {//PCI p = new SouncCard();
    if (p != null) {
        p.open();
        p.close();
    }
}

}

NetCard.java
package main.java.com.zyf.test;

/**
* Created by zyf on 2016/8/4.
*/
public class NetCard implements PCI {

@Override
public void open() {
    System.out.println("net open");
}

@Override
public void close() {
    System.out.println("net close");
}

}

PCI.java
package main.java.com.zyf.test;

/**
* Created by zyf on 2016/8/4.
*/
public interface PCI {

public void open();
public void close();

}

ReflectTest.java
package main.java.com.zyf.test;
import java.io.File;
import java.io.FileInputStream;

import java.util.Properties;

/*
* 电脑运行。
*/
public class ReflectTest {

/**
 * @param args
 * @throws Exception
 */
public static void main(String[] args) throws Exception {

    Mainboard mb = new Mainboard();
    mb.run();
    //每次添加一个设备都需要修改代码传递一个新创建的对象

// mb.usePCI(new SoundCard());
//能不能不修改代码就可以完成这个动作。
// 不用new来完成，而是只获取其class文件。在内部实现创建对象的动作。

    File configFile = new File("pci.properties");

    Properties prop = new Properties();
    FileInputStream fis = new FileInputStream(configFile);

    prop.load(fis);

    for(int x=0; x<prop.size(); x++){

        String pciName = prop.getProperty("pci"+(x+1));

        Class clazz = Class.forName(pciName);//用Class去加载这个pci子类。

        PCI p = (PCI)clazz.newInstance();

        mb.usePCI(p);
    }
    fis.close();
}

}

SoundCard.java
package main.java.com.zyf.test;

/**
* Created by zyf on 2016/8/4.
*/
public class SoundCard implements PCI {
public void open(){
System.out.println(“sound open”);
}
public void close(){
System.out.println(“sound close”);
}

}

–&和&& | 和|| 区别—-
&&:
和&运算的结果是一样的。但是运算过程有点小区别。

        &：无论左边的运算结果是什么，右边都参与运算。
        &&：当左边为false时，右边不参与运算的。


    ||:
        和|运算的结果是一样的。但是运算过程有点小区别。

        |：无论左边的运算结果是什么，右边都参与运算。
        ||：当左边为true时，右边不参与运算的。
    */

---

\n:回车符
\t:制表符
\b:退格
\r:按下回车键

window系统中的回车是:\r\n

数据内存空间的划分：
1、寄存器（cpu）
2、本地方法区(调用系统底层内容)
3、方法区
4、栈内存：存储的都是局部变量，而且变量所属的作用域一旦结束，该变量就自动释放。
5、堆内存：存储是数组和对象（其实数组就是对象）凡是new建立在堆中。
特点：
1、每一个实体都有首地址值。
2、堆内存中的每一个变量都有默认的初始值，根据类型的不同而不同。整数是0，小数0.0或者0.0f，boolean false char ‘\n0000’
3、垃圾回收机制。

——-成员变量和局部变量的区别：—————–
1，
成员变量定义在类中，整个类中都可以访问。
局部变量定义在函数，语句，局部代码块中，只在所属的区域有效。

2，
成员变量存在于堆内存的对象中。
局部变量存在于栈内存的方法中。

3，
成员变量随着对象的创建而存在，随着对象的消失而消失。
局部变量随着所属区域的执行而存在，随着所属区域的结束而释放。

4，
成员变量都有默认初始化值。
局部变量没有默认初始化值。

匿名对象。没有名字的对象。
new Car();//匿名对象。其实就是定义对象的简写格式。
Car c = new Car();
c.run();
new Car().run();

    1，当对象对方法仅进行一次调用的时候，就可以简化成匿名对象。
    new Car().num = 5;
    new Car().color = "green";
    new Car().run();
    2，匿名对象可以作为实际参数进行传递。

private:私有，是一个权限修饰符。用于修饰成员。
私有的内容只在本类中有效。

注意：私有仅仅是封装的一种体现而已。

构造函数：
1、函数名与类名相同。
2、不用定义返回值类型。
3、没有具体的返回值。
作用：
给对象进行初始化。

注意：
1、默认构造函数的特点。
2、多个构造函数是以重载的形式存在的。

构造函数：构建创造对象时调用的函数。作用：可以给对象进行初始化。
创建对象都必须要通过构造函数初始化。

一个类中如果没有定义过构造函数，那么该类中会有一个默认的空参数构造函数。
如果在类中定义了指定的构造函数，那么类中的默认构造函数就没有了。

一般函数和构造函数什么区别呢？

构造函数：对象创建时，就会调用与之对应的构造函数，对对象进行初始化。
一般函数：对象创建后，需要函数功能时才调用。

构造函数：对象创建时，会调用只调用一次。
一般函数：对象创建后，可以被调用多次。

什么时候定义构造函数呢？

在描述事物时，该事物一存在就具备的一些内容，这些内容都定义在构造函数中。

构造函数可以有多个，用于对不同的对象进行针对性的初始化.
多个构造函数在类中是以重载的形式来体现的。

细节：
1，构造函数如果完成了set功能。set方法是否需要。
2，一般函数不能直接调用构造函数。
3，构造函数如果前面加了void就变成了一般函数。
4，构造函数中是有return语句的。

当成员变量和局部变量重名，可以用关键字this来区分。

this : 代表对象。代表哪个对象呢？当前对象。
this就是所在函数所属对象的引用。
简单说：哪个对象调用了this所在的函数，this就代表哪个对象。

this也可以用于在构造函数中调用其他构造函数。

注意：只能定义在构造函数的第一行。因为初始化动作要先执行。

static的特点：
1，static是一个修饰符，用于修饰成员。
2，static修饰的成员被所有的对象所共享。
3，static优先于对象存在，因为static的成员随着类的加载就已经存在了。
4，static修饰的成员多了一种调用方式，就可以直接被类名所调用 。 类名.静态成员 。

5，static修饰的数据是共享数据，对象中的存储的是特有数据。

成员变量和静态变量的区别？
1，两个变量的生命周期不同。
成员变量随着对象的创建而存在，随着对象的被回收而释放。
静态变量随着类的加载而存在，随着类的消失而消失。

2，调用方式不同。
成员变量只能被对象调用。
静态变量可以被对象调用，还可以被类名调用。

3，别名不同。
成员变量也称为实例变量。
静态变量称为类变量。

4，数据存储位置不同。
成员变量数据存储在堆内存的对象中，所以也叫对象的特有数据.

静态变量数据存储在方法区(共享数据区)的静态区，所以也叫对象的共享数据.

静态使用的注意事项：
1，静态方法只能访问静态成员。(非静态既可以访问静态，又可以访问非静态)
2，静态方法中不可以使用this或者super关键字。

3，主函数是静态的。

主函数特殊之处：
1，格式是固定的。
2，被jvm所识别和调用。

public:因为权限必须是最大的。
static:不需要对象的,直接用主函数所属类名调用即可。
void：主函数没有具体的返回值。
main:函数名，不是关键字，只是一个jvm识别的固定的名字。

String[] args:这是主函数的参数列表，是一个数组类型的参数，而且元素都是字符串类型。

静态什么时候用？
1，静态变量。
当分析对象中所具备的成员变量的值都是相同的 。这时这个成员就可以被静态修饰。
只要数据在对象中都是不同的，就是对象的特有数据，必须存储在对象中，是非静态的。
如果是相同的数据，对象不需要做修改，只需要使用即可，不需要存储在对象中，定义成静态的。

2，静态函数。
函数是否用静态修饰，就参考一点，就是该函数功能是否有访问到对象中的特有数据。
简单点说，从源代码看，该功能是否需要访问非静态的成员变量，如果需要，该功能就是非静态的。
如果不需要，就可以将该功能定义成静态的。当然，也可以定义成非静态，
但是非静态需要被对象调用，而仅创建对象调用非静态的

没有访问特有数据的方法，该对象的创建是没有意义。

静态代码块。
随着类的加载而执行。而且只执行一次。
作用：

用于给类进行初始化。

“`