绪论:

封面暗示的主题是一个收集盒,里面的昆虫可以看作对象,并且放置到盒这个对象当中,而盒对象又放在封面对象当中,封面对象又放在书对象当中。

上帝赋予人类说话的能力,而语言又创造了思想,思想是人类对宇宙的度量。

在头脑中建立一个模型,以加强对这种语言的深入理解),如果遇到了疑问,就将它反馈到头脑的模型中,并推断出答案。

第一章

OOP面向面向程序设计

1.1 所有的编程语言都提供抽象机制,人们所能解决问题的复杂程度取决于抽象的类型和质量

建立机器模型和待解决问题模型之间的联系。

面向对象语言的基本特性,

  1. 万物皆对象
  2. 每个对象由其他对象构成
  3. 每个对象具有类型

对象具有 属性,方法,和唯一的标识

类描述了具有相同属性和行为的对象的集合,一个类就是一个数据类型

java的三个访问修饰符,public(定义的东西谁都可以使用) protected(同一个包或者其他包中的子类访问),default(同一个包中的类访问) private(只能自身类访问,父类修饰的private属性,会被子类继承,但是不可以访问),

组合:使用已经有的类合成新的类,这种概念被称为组合。

多态:

  1. 父类引用指向子类对象
  2. 子类对象的向上转型
Animal animal=new Dog();
Animal animal2=new Cat();
animal.run();

插件 plug-in (插入到浏览器某个地方的一段代码) 罚

第二章:一切皆是对象

String str; str只是一个引用,此时没有和任何对象关联起来,如果用调用该引用的方法就会发生空指针异常

String str="hello world";   //java的特性,创建String对象可以使用简便方式
String str=new String("hello world");

java中的数据存储

  1. 寄存器
  2. 栈:存储基本类型的变量,
  3. 堆:存放所有的对象
  4. 字符串常量池:存储字符串和具有字符串值的常量表达式
  5. 非RAM存储:数据库,或者硬盘当中

基本类型的变量,直接存储值,并置栈中。 int i=1;

基本类型大小最小值最大值包装类
boolean---Boolean
void---Void
char16bitUnicode 0Unicode 2¹⁶-1Character
byte8bits-128127Byte
short16bits-2¹⁵+2¹⁵-1
int32bits-2³¹+2³¹-1Integer
long64bits-2⁶³+2⁶³-1Long
float32bits--Float
double64bits--Double

boolean类型占用的大小并没有明确指定

BigInteger 可以精确表示任意精度的整数值

BigDecimal 可以精确表示任意精度的定点数

java SE5之后提供的自动装箱和自动拆箱;

Character ch= new Character('h');
Character ch= 'h';
char c=ch;

变量的作用域:scope 作用域决定了变量的可见性和生命周期

{
    int x=12;  //only x available
    {
        int y=20; // Both x & y avaliable
    }
    //only x available ,y is out of scope
}

对象的作用域:

{
String str=new String("hello world");
}
//出作用域之后,对象的引用消失了,但是对象本身还在堆中。java的垃圾回收器会自动回收不在使用的对象。

如果成员变量是基本数据类型,java会确保它有一个默认值。如果是对象则为null

基本类型默认值
booleanfalse
char'\u0000(null)'
byte(byte(0))
short(short(0))
int0
long0L
float0.0f
double0.0d

局部变量中,必须手动初始化变量,不然会有编译错误。

static,关键字, 在类中static修饰的方法或者字段,只会生成一次,就是类方法和类字段,所有基于该类创建的对象共用这些静态方法,Animal.i只有一份。

public class Animal{
    static int i=1;
    public static void main(Stirng[] args){
        Animal a=new Animal();
         Animal b=new Animal();
         a.i;
         b.i;引用的是同一份数据
    }
}

非string类型和string类型直接相加的时候,会将非String类型转换为string类型。

赋值,操作符=左边的称为左值,右边的称为右值,左值必须是一个已经命名的变量,右值可以是任意常量,变量或者表达式。

Date d= new Date();
Date c=d;
//此时c和d指向了同一个对象,一般不建议直接赋值对象,而是取出对象的属性。

对象赋值的时候,赋值会将对象的引用赋值。

class Animal{
    int age;
}
public static void main(String[] args) {

    Animal a=new Animal();
    Animal b=new Animal();
    a.age=20;
    b.age=18;

    b=a;  //a和b指向同一个对象
    b.age=a.age;  //如果只是让b和a的属性值相同,不建议直接使用对象赋值的方式。

    System.out.println(b.age);
}

将一个对象传递给方法的时候,是将引用复制一份给形式参数。然后形式参数拿到的是的地址,也就是引用。

算数操作符

/  整除
+=  简写

Random类

Random random = new Random(1); //固定种子,如果没有传递种子,默认当前时间作为种子
int i = random.nextInt(10);

自增

int i=1;
System.out.println(i++);//先输入i然后i自增,
System.out.println(++i);//先自增然后输出自增后的I,

==和 != 对于基本数据类型比较的是值,对于对象比较的是地址,也就是是否是同一个对象的引用。

equals方法默认使用==,可以重写该方法

public boolean equals(Object obj) {
    return (this == obj);
}

逻辑操作符中的短路情况

public static void main(String[] args){
    boolean flag=test(1) && test(2) && test(3);
}
public static boolean test(int i){
    System.out.println(i);
    return i<2;
}

//output,不会输出3因为发生了短路,test(2)中已经确定的表达式的结果
1
2

3.9.1指数记数法

1.39e-43f
1.39e2

初始化与清理

5.1构造器确保初始化

public class Animal {
    private String name;
    public Animal(){
        System.out.println("对象创建");
    }

    public static void main(String[] args) {
        Animal animal = new Animal();
        System.out.println(animal.name);

    }
}

类的成员变量如果不进行手动初始化,所有的对象都会被初始化为null new Animal();在创建对象的时候,将会为对象分配存储空间,并调用相应的构造器,

构造器是一种特殊类型的方法,没有返回值,这与返回值为空不同,new 表达式确实返回了对象的引用,但构造器本身没有任何返回值

5.2方法重载

相同的词可以表达不同的含义即为重载,也就是方法名相同,却有着不同的方法体

5.2.1区分重载的方法

每一个重载的方法都有一个独一无二的形参列表,用来区分每个方法。 下面的两个run()就是参数顺序不同而重载的方法,但不建议这样做,会使代码难以维护。

public class Hero {
    public Hero(){
    }
    public void run(int distance,String name){
        System.out.println(name+" "+distance);
    }
    public void run(String name,int distance){
        System.out.println(name+" "+distance);
    }

    public static void main(String[] args) {
        Hero hero = new Hero();
        hero.run(200,"李白");
        hero.run("关羽",100);
    }
}
output
李白 200
关羽 100

5.2.2涉及基本类型的重载

5.2.3 返回值不可以区分方法

不可以通过返回值区分重载方法,下面的两个方法会发生编译错误,提示已经定义过了方法

private static void test() {

}
private static int test(){
    return 1;
}

因为你再使用方法的时候不一定会用到返回值,这样是没有办法区分方法的,所以编译器会报错。

test();       这里并没有使用返回值

5.3 默认构造器

如果类中没有构造器,编译器会自动创建一个无参构造器,如果已经自定义了带参构造器,则编译器不会自动创建构造器,所以一般情况下,已经创建的带参构造器,也要创建一个无参构造器

public class Demo {
    public static void main(String[] args) {
        Demo demo = new Demo();
        System.out.println(demo);
    }
}
output:
com.aa.think_in_java.fifth.Demo@16f6e28

5.4this关键字

编译器如何知道是那个对象调用的方法呢

public class Demo {
    public static void main(String[] args) {
        Animal dog =new Animal();
        Animal cat = new Animal();
        dog.run();
        cat.run();
    }
}
class Animal{
    public void run(){
        System.out.println("running");
    }
}

只有一个run()方法,编译器如何知道是那个对象调用的方法呢,编译器内部将对象的引用传给了run()的第一个参数,就像下面这样。

Animal.run(dog);
Animal.run(cat);

本类的方法中,调用其他方法

this关键字,在类的方法中,调用本类中的另一个方法直接调用即可,编译器自动添加了this,下面的代码编译器内部是this.eat()

class Animal{
    public void run(){
        System.out.println("running");
        eat();
    }
    public void eat(){
        System.out.println("eating");
    }
}

返回值是this

返回当前对象的引用,使用this,此时的this指的是调用方法的对象的引用,也叫链式编程

public class Demo {
    public static void main(String[] args) {
        new Age().increment().increment().increment().print();
    }
}
class Age{
    int i=0;
    Age increment(){
        i++;
        return this;
    }
    void print(){
        System.out.println(i);
    }
}
output:
3

构造器中使用this

构造器中使用this()调用其他重载的构造器和 构造器参数中使用 this区分类成员变量和形式参数,普通方法中使用不能使用this()调用其他构造函数

调用其他构造器时,this()只能使用一次,并且必须放在第一行

public class Demo {
    public static void main(String[] args) {
        Person person = new Person("李白", 20);
        System.out.println(person);
    }
}
class Person{
    String name;
    int age;
    Person(){}
    Person(String name,int age){
        this(age);
        this.name=name;
    }
    Person(int age){
        this.age=age;
    }
}

将当前对象传递给其他方法

public class Main {
    public static void main(String[] args) {
        new Person().eat(new Apple());
    }
}

class Person{
    public void eat(Apple apple){
        Apple peeledApple=apple.getPeeled();
        System.out.println("吃苹果...");
    }
}

class Apple {
    public Apple getPeeled(){
        return Peeler.peel(this);    //将当前对象传递给其他方法
    }
}

//剥皮器
class Peeler{
    //剥皮方法
    public static Apple peel(Apple apple){
        // remove peel
        return apple;
    }
}
output
吃苹果.....

5.4.2 static

static修饰的属性或方法,是类属性,类方法,(和其他语言中的全局函数类似)

5.5 对象清理和垃圾回收

finalize(); 87页待整理

5.6成员初始化

public class Main5_5 {
    boolean bool;
    char c;
    byte b;
    short s;
    int i;
    long l;
    float f;
    double d;
    Date date;
    public void print(){
        System.out.println(bool);
        System.out.println(c);
        System.out.println(b);
        System.out.println(s);
        System.out.println(i);
        System.out.println(l);
        System.out.println(f);
        System.out.println(d);
        System.out.println(date);
    }
    public static void main(String[] args) {
        new Main5_5().print();
    }
}
output   //char的值为0所以显示空白
false
 
0
0
0
0
0.0
0.0
null