（一）java基础2

这次的笔记主要是关于类、对象、接口之类的知识以及两本java推荐书籍。

1.引用

引用的概念：如果一个变量的类型是类类型，而非基本类型，那么该变量又叫做引用。
比如Hero是个类；
那么：
Hero h=new Hero(); //h是新建的这个Hero的引用（相当于c里面的指针）

2.继承

extends：子类继承父类的属性和方法，不用重新再构造

3.方法重载

方法的重载指的是方法名一样，但是参数类型不一样；
这里介绍一种可变数量的参数：
public void attack(Hero h1)
public void attack(Hero h1,Hero h2)
public void attack(Hero h1,Hero h2,Hero h3)
使用以上代码会难免赘述，这时，可以采用可变数量的参数
只需要设计一个方法
public void attack(Hero …heros)
代码展示：

public class ClassAndObject {
public static void main(String[] args) {
Hero h1=new Hero();
h1.name="李白";
Hero h2=new Hero();
h2.name="王昭君";
 
Support s1=new Support();
s1.name="扁鹊";
s1.heal(h1,h2);
}
}

class Hero{
String name;
float hp=0;
}
 
//辅助英雄
class Support extends Hero {
void heal(Hero...heros){ //治疗方法,可变数量的参数
for(Hero each:heros) { //在方法里，使用操作数组的方式处理参数heros即可
each.hp=each.hp+20;
System.out.println(name+"为"+each.name+"加了20点血量");
}
}
}

4.构造方法

通过一个类创建一个对象，这个过程叫实例化；实例化是通过调用构造方法（又叫构造器）实现的

构造方法是类中的一个方法；它的方法名和类名一摸一样，没有返回类型（连void都不能有，什么都不写）；实例化一个对象的时候必须使用构造方法；
Hero h1=new Hero();
这个语句调用了Hero类中的构造方法；这个方法我们并没有写，是哪里来的？
那是因为在创建Hero类的时候默认创建了一个隐式的无参的构造方法，如下：
Public Hero(){ //这里不能写返回类型。函数里里一般也可以什么都不写
}
需要注意的是：**一旦我们手动创建了一个有参的构造方法，又没有提供一个无参的构造方法，那么我们默认的无参构造方法就没有了；**当然和普通的方法一样，构造方法也可以重载；

5.this的使用

this这个关键字，即代表当前对象；
在某个方法中使用，可以通过this.propertyName访问当前对象的属性；可以通过this(parameters)调用构造方法；可以通过this.functionName(parameters)来调用对象中其他的普通方法；

6.访问修饰符

作用范围最小原则。没有必要露出来的尽量不露；
红色字为不能使用的操作

7.static修饰

7.1static修饰属性

当一个属性被static修饰的时候，就叫做类属性，又叫做静态属性；（不和某一个具体的对象有关系，调用的时候可以用ObjectName.property）
如果一个属性声明成类属性，那么该类实例化生成的对象，都共享这么一个值；例如给英雄设置一个类属性叫做“版权" (copyright), 无论有多少个具体的英雄，所有的英雄的版权都属于 Riot Games公司。但是static属性可以在使用的时候被赋值改变，一般搭配final关键字使用。

7.2static修饰方法

同样当用static修饰类中的方法时，这个方法就是类方法，而没有修饰的方法就是对象方法；
类方法： 又叫做静态方法
对象方法： 又叫实例方法，非静态方法
访问一个对象方法，必须建立在有一个对象的前提的基础上
访问类方法，不需要对象的存在，直接就访问

7.3单例模式

单例模式又叫做 Singleton模式，指的是一个类，在一个JVM里，只有一个实例存在。即某个类只能被实例化一次，该如何实现？

7.3.1饿汉式单例模式

GiantDragon 应该只有一只，通过私有化其构造方法，使得外部无法通过new 得到新的实例。
GiantDragon 提供了一个public static的getInstance方法，外部调用者通过该方法获取12行定义的对象，而且每一次都是获取同一个对象。 从而达到单例的目的。
这种单例模式又叫做饿汉式单例模式，无论如何都会创建一个实例
饿汉式单例代码：

public class GiantDragon {
    //私有化构造方法使得该类无法在外部通过new 进行实例化
private GiantDragon(){
}
//准备一个类属性，指向一个实例化对象。 因为是类属性，所以只有一个
private static GiantDragon instance = new GiantDragon();
//public static 方法，提供给调用者获取12行定义的对象
public static GiantDragon getInstance(){
return instance;
}
}

测试代码：

public class TestGiantDragon {
public static void main(String[] args) {
//通过new实例化会报错
//                GiantDragon g = new GiantDragon();
//只能通过getInstance得到对象
GiantDragon g1 = GiantDragon.getInstance();
GiantDragon g2 = GiantDragon.getInstance();
GiantDragon g3 = GiantDragon.getInstance();
//都是同一个对象
System.out.println(g1==g2);
System.out.println(g1==g3);
}
}

7.3.2懒汉式单例模式

懒汉式单例模式与饿汉式单例模式不同，只有在调用getInstance的时候，才会创建实例
懒汉式代码：

public class GiantDragon {
    //私有化构造方法使得该类无法在外部通过new 进行实例化
    private GiantDragon(){        
    }
    //准备一个类属性，用于指向一个实例化对象，但是暂时指向null
    private static GiantDragon instance;
    //public static 方法，返回实例对象
    public static GiantDragon getInstance(){
            //第一次访问的时候，发现instance没有指向任何对象，这时实例化一个对象
            if(null==instance){
                    instance = new GiantDragon();
            }
            //返回 instance指向的对象
        return instance;
    } 
}

测试代码同上；

7.3.3单例模式三元素

• 构造方法私有化
• 静态属性指向实例
• Public static的getInstance方法，返回第二步的静态属性

8.引用之间的转换

• 形式：引用1（包含更少）=引用2（包含更多）
• 子类可以转父类；较高级的（包含方法属性更多的）引用绝对可以转化为较低级的引用；
• 没有继承关系的引用之间不能转换；

9.抽象类

在类中声明一个方法，这个方法没有实现体，是一个“空”方法
这样的方法就叫抽象方法，使用修饰符“abstract"
当一个类有抽象方法的时候，该类必须被声明为抽象类

10.抽象类和接口的区别：

区别1：
子类只能继承一个抽象类，不能继承多个
子类可以实现多个接口
区别2：
抽象类可以定义
public,protected,package,private
静态和非静态属性
final和非final属性
但是接口中声明的属性，即便没有显式的声明，也只能是Public static final的
注: 抽象类和接口都可以有实体方法。 接口中的实体方法，叫做默认方法

11.java推荐书籍

关于辅助书籍，只推荐两本
Core Java 字典
比如学习完了IO的知识，觉得意犹未尽，那么就通过这本字典一样的Java书籍，把IO的知识更丰满的刷一遍，因为已经通过本站做了很多实践操作了，所以这个时候，看这些知识就会触类旁通，比较好消化了。
Effective Java （零食，提升代码质量）
作为初学者，首要任务不是提升质量，而是掌握完成功能的基本手法。这本书就像零食一样，只要主食吃了，你不吃零食也没关系，但是吃点零食会觉得生活质量得到了提升。 本书可以帮你写出更优质的代码，空隙时间可以拿出来看看，不用通看，碰到什么，看什么，一次也不应该看太多，当做有益的课外补充。