Java逍遥游记读书笔记<一>

前言

必须先来一句，这是入门级别，高手勿喷~

写Android的时候总有一些语句不是很理解，其实大部分是Java的内容，所以想系统的学下Java。

这本书——《Java逍遥游记》是在图书馆偶然看到的，被横放在书架上，看来是被人翻过直接丢那里了，索性拿来看一看。

很基础的一本书，废话很多，比如孙悟空想学编程什么什么的，但可以理解作者的一片苦心。既然如此水，那就把它借回来想快速扫一下以增加成就感，用一种查漏补缺的态度，看到哪里不会就记下来，最终目标就是这本书就作废了，对我有价值的东西都在笔记上，所以就有了这几篇笔记。

Anyway，一千个人眼中有一千个哈姆雷特，我记下的东西不一定适合所有人，这里面既有Java的内容，也有些是我在学C++的时候的一些遗漏（语言都是相通的~），所以抱着交流学习的态度的同时更多的是对自己知识的归纳整理。若这些东西对你有用，那便是极好的。

HelloWorld

一、前提：已安装好Jdk(Java Development Kit)。

二、配置环境变量：

新建环境变量JAVA_HOME:F:JDK      (这是我的路径)

编辑path变量：添加%JAVA_HOME%in;

编辑CLASSPATH变量：C:UsersAdministratorDesktop;

有必要解释下ClassPath变量，你通过javac编译出来的.class文件必须放置在ClassPath中任意路径中，才能运行成功，比如我把Hello.class放在桌面，那么为了运行成功，我就在ClassPath中添加桌面的路径C:UsersAdministratorDesktop;否则会出现

错误：找不到或无法加载主类

运行cmd

定位到Hello.java所在位置

键入javac Hello.java

键入 java Hello (注意没有.class)

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

 

程序入口main函数

必须是public，static，void，String数组参数,缺一不可。

public static void main(String[] args){}

 

Java的编译与运行

Java源文件结构

每个Java源文件可以有多个类的定义，但最多只能有一个类是public的，而且该源文件必须以public类的名字命名。

(注：Java中类的定义后面分号不是必须的)

 

public class Test{}

class Sample1{}

class Sample2{}

包的引入

假如com.java.school里有一些类，同时还有一个文件夹classes，那么

import com.java.school.*;

只会引入school根目录下的所有类(*表示所有)，而不会引入classes目录下的类。若还想继续引用classes下的类，则应当这样写。

import com.java.school.*;
import com.java.school.classes.*;

编程规范

• 类：所有单词首字母大写。如Monkey、SmartMonkey
• 方法和变量：首字母小写，其余单词首字母大写。如add、listAll
• 包：全部小写。如com.java.school.classes
• 常量：全部大写，若多个单词则加下划线隔开。如final String COLOR_OF_MONKET = “red”;

 

实例变量和静态变量（类变量）

• 无论你创建了多少实例，类的静态变量在内存中只有一个，被类的所有实例共享。
• 静态变量可以通过实例名访问，也可以通过类名被访问。
• 每创建一个实例，系统就会为实例变量分配一次内存。
• 实例变量只能通过实例名访问。

具体看下例子就可以懂了。

public class Person
{
    public int id = 0;        //Java支持在声明时初始化 
    
    public static int sum = 0;    //Java支持在声明时初始化 
    
    public Person()
    {
        id++;
        
        sum++;
    }
    
    public static void main(String[] args)
    {
        Person p1 = new Person();

        Person p2 = new Person();
        
        System.out.println(p1.id);        //输出1
        
        System.out.println(p2.id);        //输出1
        
        System.out.println(Person.sum);    //输出2 静态变量可以通过类名访问
    }
}

Person.java

操作符& |

&&和&都是与操作，那么有什么区别呢？

public class Test
{
    public static void main(String[] args)
    {
        int a = -1, b = -1;
        if ((a = 0) == 1 && (b = 1) == 1)
        {}
        System.out.println(a);    //输出0赋值成功
        System.out.println(b);    //输出-1赋值失败
        
        a = -1;    b = -1;
        if ((a = 0) == 1 & (b = 1) == 1)
        {}
        System.out.println(a);    //输出0赋值成功
        System.out.println(b);    //输出1赋值成功
    }
}

可以看到，当第一条件判断为false的时候，&&是不会继续执行、判断第二个条件的，但&会。|也同理。

 

==操作符与equals()方法

这个已经被坑过很多很多次了。String的比较全部用equals()不能用==就一定不会错……

若是基本类型，如int,double,string等等，用==就可以比较相等。

若是引用类型，如String,Integer或自己写的类等等，用==比较的是是否同一个对象（内存地址是否相同），但我们一般要比价的是内容，所以应该有equals()方法。

public class Test
{
    public static void main(String[] args)
    {
        String s1 = "123", s2 = "123";
        
        String s3 = new String("123"), s4 = new String("123");
        
        String s5 = s3;
        
        System.out.println(s1 == s2);        //true
        
        System.out.println(s3 == s4);        //false
        
        System.out.println(s3 == s5);        //true
        
        System.out.println(s3.equals(s4));    //true
        
        Integer i1 = new Integer(1), i2 = new Integer(1);
        
        System.out.println(i1 == i2);        //false
        
        System.out.println(i1.equals(i2));    //true
    }
}

必要时可以覆盖equals()方法

public class Student
{
    public String name;
    
    public int age;
    
    public boolean equals(Object o)
    {
        if (this == o)
            return true;
        if (!(o instanceof Student))        //判断是否Student的实例
            return false;
        
        final Student student = (Student)o;    //强制类型转换
        
        return this.name.equals(student.name);
    }
    
    public Student(String name, int age)
    {
        this.name = name;
        
        this.age = age;
    }
    
    public static void main(String[] args)
    {
        Student m1 = new Student("Norcy", 22), m2 = new Student("Fiona", 21), m3 = new Student("Norcy", 23);
        
        System.out.println(m1.equals(m2));    //false
        
        System.out.println(m1.equals(m3));    //true
    }
    
}

注意，在重写equals方法时，要注意满足离散数学上的特性：
1.自反性：对任意引用值X，x.equals(x)的返回值一定为true
2.对称性：对于任何引用值x,y,当且仅当y.equals(x)返回值为true时，x.equals(y)的返回值一定为true
3.传递性：如果x.equals(y)=true, y.equals(z)=true,则x.equals(z)=true
4.一致性：如果参与比较的对象没任何改变，则对象比较的结果也不应该有任何改变
5.非空性：任何非空的引用值X，x.equals(null)的返回值一定为false

instanceof操作符

判断一个对象是否为一个类的实例。

假如s1是Student类的实例，那么对于表达式“s instanceof XXX”,当XXX为以下值的时候，表达式的值为true.

• Student
• Student的直接父类或间接父类（即祖先）
• Student类实现的接口的名字（接口是什么，以后再学）

4种访问控制级别

public 　　　对外公开

protected 　向子类和同一个包中的所有类公开

默认 　　　　向同一个包中的所有类公开

private 　　  只有类本身可以访问，不对外公开

 

访问级别：public > protected > default > private

若一个子类与父类在不同包，则这种情况属于不同包，不属于子类。

访问级别	同类	同包	子类	不同包
public	√	√	√	√
protected	√	√	√	—
默认	√	√	—	—
private	√	—	—	—