Java札记1

• 类是抽象的，概念的，代表一类事物，比如人类，猫类···
• 对象是具体的，实际的，代表一个事物
• 类是对象的模板，对象是类的一个个体，实例

package 包名
class 类名 extends 父类 implement 接口名{
成员变量；
构造方法；
成员方法；
}

对象-如何创建对象
创建一个对象有两种方法
1.先声明再创建
1.1对象声明
类名 对象名
1.2对象创建
对象名 = new 类名（）

2.一步到位法
类名 对象名 = new 类名（）

对象-如何访问（使用）对象的成员变量
对象名.变量名

java中的包概念相当于就是一个文件夹。

无参的构造方法，如果不写，就会默认提供一个，和普通方法一样，构造方法也可以重载。

构造方法作用：在实例化多个对象的时候需要写多个属性的时候，直接在创建对象的时候调用构造方法初始化对象，可以节省工作量。

this这个关键字，相当于普通话里的“我”

小明说 “我吃了” 这个时候，“我” 代表小明
小红说 “我吃了” 这个时候，“我” 代表小红
“我”代表当前人物

this这个关键字，相当于普通话里的“我”
this即代表当前对象。

如果要在一个构造方法中，调用另一个构造方法，可以使用this() 。

不写返回类型的时候，只有在构造方法上面能用，普通方法必须写返回类型。构造方法是用来初始化一个对象的，并为为实例变量赋予合适的初始值。因此构造方法不需要返回类型。

如果一个变量是基本类型
比如 int hp = 50;
我们就直接管hp叫变量
=表示赋值的意思。
如果一个变量是类类型
比如 Hero h = new Hero();
我们就管h叫做引用。
=不再是赋值的意思
=表示指向的意思
比如 Hero h = new Hero();
这句话的意思是
引用h，指向一个Hero对象。

包: package ，把比较接近的类，规划在同一个包下。

1. 属性通常使用private封装起来
2. 方法一般使用public用于被调用
3. 会被子类继承的方法，通常使用protected
4. package用的不多，一般新手会用package,因为还不知道有修饰符这个东西

再就是作用范围最小原则
简单说，能用private就用private，不行就放大一级，用package,再不行就用protected，最后用public。 这样就能把数据尽量的封装起来，没有必要露出来的，就不用露出来了

当一个属性被static修饰的时候，就叫做类属性，又叫做静态属性
当一个属性被声明成类属性，那么所有的对象，都共享一个值
与对象属性对比：
不同对象的 对象属性 的值都可能不一样。
比如盖伦的hp 和 提莫的hp 是不一样的。
但是所有对象的类属性的值，都是一样的

如果一个属性声明成类属性，那么所有的对象，都共享这么一个值 。类属性，类似于全局变量，任何地方修改了这个属性，那么其他使用这个属性的地方都会修改。
通俗点讲就是大家都在一个水塘里取水，其中一个人往水塘里加盐了，那么其他人的水也会变咸~

访问类属性有两种方式
1. 对象.类属性
teemo.copyright
2. 类.类属性
Hero.copyright

这两种方式都可以访问类属性，访问即修改和获取，但是建议使用第二种 类.类属性 的方式进行，这样更符合语义上的理解。如果一个属性，每个英雄都不一样，比如name，这样的属性就应该设计为对象属性，因为它是跟着对象走的，每个对象的name都是不同的

如果一个属性，所有的英雄都共享，都是一样的，那么就应该设计为类属性。比如血量上限，所有的英雄的血量上限都是 9999，不会因为英雄不同，而取不同的值。 这样的属性，就适合设计为类属性。

继承的概念是建立在属性是实例属性(其他不同的说法：对象属性、非静态属性)的基础之上的。 所以对于类属性，谈不上继承的概念。
严格的说，是叫做能够访问到父类的类属性，但是性质上不叫做继承。

类方法： 又叫做静态方法

对象方法： 又叫实例方法，非静态方法

访问一个对象方法，必须建立在有一个对象的前提的基础上
访问类方法，不需要对象的存在，直接就访问

对象属性初始化有3种
1. 声明该属性的时候初始化
2. 构造方法中初始化
3. 初始化块

package charactor;

public class Hero {
    public String name = "some hero"; //声明该属性的时候初始化 
    protected float hp;
    float maxHP;

    {
        maxHP = 200; //初始化块
    }   

    public Hero(){
        hp = 100; //构造方法中初始化

    }

}

类属性初始化有2种
1. 声明该属性的时候初始化
2. 静态初始化块

package charactor;

public class Hero {
    public String name; 
    protected float hp;
    float maxHP;

    //物品栏的容量
    public static int itemCapacity=8; //声明的时候 初始化

    static{
        itemCapacity = 6;//静态初始化块 初始化
    }

    public Hero(){

    }

    public static void main(String[] args) {
        System.out.println(Hero.itemCapacity);
    }

}

执行顺序：地方初始化–》块初始化–》构造方法
最开始是声明的地方初始化
接着是初始化块进行初始化，无论这个块放在构造方法之前还是之后。
最后才是执行构造方法。
属性初始化顺序我认为应该依次是：静态属性初始化（无论如何应该都是先做）->初始化块->构造方法初始化->主函数中对象的初始化（可能没有）。

单例模式顾名思义，就是只有一个实例啊，在如下场景会用到
1. 希望一个对象重复使用，这样通过单例模式，就总是使用这么同一个对象，免去了每次都生成新的对象的开销
在实践项目一本糊涂账的界面类就用到了这种设计：
http://how2j.cn/k/hutubill/hutubill-mainpanel/726.html#step2794
2. 有的类，就应该只有一个实例，比如地球Earth这个类，从语义上讲，就应该只有一个实例，多个实例与事实不符。

首先要理解进程(Processor)和线程(Thread)的区别
进程：启动一个LOL.exe就叫一个进程。 接着又启动一个DOTA.exe，这叫两个进程。
线程：线程是在进程内部同时做的事情，比如在LOL里，有很多事情要同时做，比如”盖伦” 击杀“提莫”，同时“赏金猎人”又在击杀“盲僧”，这就是由多线程来实现的。

Thread.sleep(long millis)和Thread.sleep(long millis, int nanos)静态方法强制当前正在执行的线程休眠（暂停执行），以“减慢线程”。
当线程睡眠时，它睡在某个地方，在苏醒之前不会返回到可运行状态。
当睡眠时间到期，则返回到可运行状态。

创建多线程三方法
1. 继承Thread类
2. 实现Runnable接口
3. 匿名类的方式
注： 启动线程是start()方法，run()并不能启动一个新的线程

重写方法的规则：

1、参数列表必须完全与被重写的方法相同，否则不能称其为重写而是重载。

2、返回的类型必须一直与被重写的方法的返回类型相同，否则不能称其为重写而是重载。

3、访问修饰符的限制一定要大于被重写方法的访问修饰符（public>protected>default>private）

4、重写方法一定不能抛出新的检查异常或者比被重写方法申明更加宽泛的检查型异常。例如：

父类的一个方法申明了一个检查异常IOException，在重写这个方法是就不能抛出Exception,只能抛出IOException的子类异常，可以抛出非检查异常。

而重载的规则：

1、必须具有不同的参数列表；

2、可以有不责骂的返回类型，只要参数列表不同就可以了；

3、可以有不同的访问修饰符；

4、可以抛出不同的异常；

重写与重载的区别在于：

重写多态性起作用，对调用被重载过的方法可以大大减少代码的输入量，同一个方法名只要往里面传递不同的参数就可以拥有不同的功能或返回值。

用好重写和重载可以设计一个结构清晰而简洁的类，可以说重写和重载在编写代码过程中的作用非同一般.

继承了父类但是不重写的话，你就会有和父类一样的内容。
当这些方法里，有一个a方法，你不想用a里面的东西，只时候你可以重写a，在子类里改掉a方法里的东西。
比如你继承了父亲的容貌（属性），但是你父亲要做运动（方法），他选择跑步（方法里的内容），你不想跑步但也想做运动，这时候你选择游泳（这就是重写方法）。
重写就是 子类跟父类方法名一致，代码内容不同，就是重写或覆盖。

---

在类中声明一个方法，这个方法没有实现体，是一个“空”方法
这样的方法就叫抽象方法，使用修饰符“abstract”
当一个类有抽象方法的时候，该类必须被声明为抽象类.
抽象类可以没有抽象方法.
抽象类和接口的区别
区别1：
子类只能继承一个抽象类，不能继承多个
子类可以实现多个接口
区别2：
抽象类可以定义
public,protected,package,private
静态和非静态属性
final和非final属性
但是接口中声明的属性，只能是
public
静态
final的
即便没有显示的声明
注: 抽象类和接口都可以有实体方法。 接口中的实体方法，叫做默认方法.
抽象类这样写new Hero();就会报错， 这就叫做直接实例化。
所谓的间接就是另外设计一个子类，继承这个抽象类，然后实例化子类。

内部类分为四种：
非静态内部类
静态内部类
匿名类
本地类

包的三大作用

1.区分相同名字的类

2.当类很多时，可以很好地管理类

3.控制访问范围

变量就是申请内存来存储值。也就是说，当创建变量的时候，需要在内存中申请空间。

Java的两大数据类型:

内置数据类型
引用数据类型