《疯狂Java讲义》读书笔记2

数据结构，对单链表的总结：

http://t.csdn.cn/xtSLW

这两天看了很久的链表，感觉之前学习的很浅，没有完全理解链表的构成，这两天数据结构的作业都是关于链表的，就花时间整理了一下。

在四月二号有学姐讲课，内容是 JavaFX 和面向对象，时间很紧，我还只学到继承，多态也看了，但是还没用代码实现，看的很慢。还是得用到代码上，总是会有些东西看懂了，但是下一秒写代码就不会了，还是得多花点时间。

 类和对象的思维导图： 

一个源文件只能指定一个包，即只能包含一个 package 语句，如果没有显性指定 package 语句，则处于默认包下。

同一个包下的类可以自由访问，无需加包前缀：

package com.ittht.day04;

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

package com.ittht.day04;

public class HelloTest {
    public static void main(String[] args) {
        var h=new Hello();//直接访问同一个包下的类，无需加包名
    }
}

父包和子包存在某种逻辑关系，但在用法上不存在任何关系，如果父包中的类要使用子包的类，则必须使用子包的全面，不能省略父包的部分。

使用 import 语句来导入指定类，使用这些类时就可以省略包前缀。

（在两个不同的包下定义 Apple 类和 AppleTest 类）

package com.ittht.day03;

public class Apple {
    public void apple(){
        System.out.println("Apple");
    }
}

package com.ittht.day04;

import com.ittht.day03.Apple;

public class AppleTest {
    public static void main(String[] args) {

        com.ittht.day03.Apple a=new com.ittht.day03.Apple();
        Apple aa =new Apple();//直接调用它要加上前面的import语句
        aa.apple();
        a.apple();
    }
}

如果没有构造器，系统会回这个类提供一个无参的构造器，这个构造器的执行体为空，无论如何，Java 都需要一个构造器。

构造器重载：对于自定义的构造器，最好还定义一个无参的构造器：

ConstructorTest 类：

package com.ittht.day04;

public class ConstructorTest {
    public String name;
    public int age;
    
    
    //自定义构造器，包含两个参数
    public ConstructorTest (String name,int age){
        this.name=name;
        this.age=age;
    }
    //最好再定义一个无参的构造器
    public ConstructorTest(){
        
    }

    public static void main(String[] args) {
        ConstructorTest tx=new ConstructorTest("讲义",15);
        System.out.println(tx.name);
        System.out.println((tx.age));
    }
}

如果系统包含多个构造器，其中一个构造器 A 的执行体中完全包含另一个构造器 B，不可以直接调用（但是对于两个方法来说可以调用），可以在结构体 A 中用 this 关键字来调用相应构造器。

Orange 类：

package com.ittht.day04;

public class Orange {
    public String name;
    public String color;
    public double weight;
    
    
    //无参构造器
    public Orange(){}
    
    
    //两个参数构造器
    public Orange(String name,String color){
        this.name=name;
        this.color=color;
    }

    
    //三个参数构造器
    public Orange (String name,String color,double weight){
        this(name,color);
        this.weight=weight;
    }
}

类的继承：

子类可以获得父类的全部成员变量和方法，但是不能获得父类的构造器。

Fruit 类和其子类 Apple类：

package com.ittht.day04;

public class Fruit {
    public int weight ;
    public void ifo(){
        System.out.println("我是一个水果，重"+weight+"g");
    }
}

package com.ittht.day04;

public class Apple extends Fruit{
    public static void main(String[] args) {
        Apple a=new Apple() ;
        a.weight=56;
        a.ifo();
    }
}

重写父类的方法：

大部分时候子类是以父类为基础，但是有时候某个子类的特征和大多数父类下包含的子类不一样，所以父类中的一部分内容用不上，所以需要重写父类的方法。

Bird 类及其子类 Ostrich 类：

package com.ittht.day04;

public class Bird {
    public void fly(){
        System.out.println("飞翔");
    }
}

package com.ittht.day04;

public class Ostrich extends Bird{
    public void fly(){
        System.out.println("奔跑");
    }

    public static void main(String[] args) {
        Ostrich b=new Ostrich();
        b.fly();
    }
}

 super 限定：

在子列方法中通过 super 显式调用自己重写的方法，也可以调用 Bird 类中被覆盖的 fly（）方法，调用 super 也不能出现在 static 修饰的方法中（因为static 修饰的是一个类，不是对象）（其中 this 也不能出现在 static 修饰的方法中）

BaseClass 类和 SubClass 类

package com.ittht.day05;
class BaseClass{
    public int a=5;
}
public class SubClass extends BaseClass{
    public int a=7;
    public void assessOwner(){
        System.out.println(a);//访问的是子类的实例变量：7
    }
    public void assessBase(){
        System.out.println(super.a);//访问的是父类被子类覆盖的实例变量a：5
    }

    public static void main(String[] args) {
        SubClass sc=new SubClass();
        sc.assessOwner();
        sc.assessBase();

    }
}

在方法中访问名为 a 的实例变量，没有显式指定调用者是谁，查找 a 的顺序是：

1.查找该方法中是否有名为 a 的局部变量；

2.查找当前类中是否包含名为 a 的成员变量；

3.查找 a 的直接父类中是否包含包名为 a 的成员变量，一次上溯所有父类，如果都没有就会出现编译错误。 

对于 Parent 类及其子类 Derived 类和公共类 HideTest 类：

在子类中与附列同名的实例变量不会被完全覆盖，下面的例子可以证明：（因为在可以在 d变量中可以显式访问父类中被覆盖的实例变量）

package com.ittht.day05;
class Parent{
    public String name="lisi";
}
class Derived extends Parent{
    private String name="wli";
}
public class HideTest {
    public static void main(String[] args) {
        Derived d=new Derived();
        //下面的调用会出问题，因为不能调用d中私有的变量name
        //System.out.println(d.name);//将private改为public就可以调用了
        
        //但是可以通过d显式地向上转型，访问其父类的name
        System.out.println(((Parent)d).name);//括号不能少！
    }
}

 调用父类的构造器：

子类不会获得父类的构造器，但子类利用调用父类构造器中的初始化代码，用 super 来调用（与构造器中调用另一个重载的构造器类似，用 this 来调用）

package com.ittht.day05;
class Base{
    public double size;
    public String name;
    public Base(double size,String name){
        this.name=name;
        this.size=size;
    }
}
public class Sub extends Base{
    public String color;
    public Sub(String name,String color ,double size){
        super(size,name);//通过super调用父类构造器的初始化过程
        this.color=color;
    }

    public static void main(String[] args) {
        Sub k=new Sub("black","table",5.5);
        System.out.println(k.color+"   "+k.name+"    "+k.size);
    }
}