认识JDK和JRE

JRE (Java Runtime Environment) ：是Java程序的运行时环境，包含 JVM 和运行时所需要的 核心类库 。 JDK (Java Development Kit)：是Java程序开发工具包，包含 JRE 和开发人员使用的工具。 我们想要运行一个已有的Java程序，那么只需安装 JRE 即可。 我们想要开发一个全新的Java程序，那么必须安装 JDK 。

基础语法

命名规则

标识符

指在程序中，我们自己定义内容。比如类的名字、方法的名字和变量的名字等等，都是标识符。

命名规则： 硬性要求

• 标识符可以包含 英文字母26个(区分大小写) 、 0-9数字 、 $（美元符号） 和 _（下划线） 。
• 标识符不能以数字开头。
• 标识符不能是关键字。

命名规范： 软性建议

• 类名规范：首字母大写，后面每个单词首字母大写（大驼峰式）。
• 方法名规范： 首字母小写，后面每个单词首字母大写（小驼峰式）。
• 变量名规范：全部小写。

基本类型

8个基本类型

数据类型	关键字	内存占用	取值范围
字节型	byte	1个字节	-128~127
短整型	short	2个字节	-32768~32767
整型	int（默认）	4个字节	-2的31次方~2的31次方-1
长整型	long	8个字节	-2的63次方~2的63次方-1
单精度浮点数	float	4个字节	1.4013E-45~3.4028E+38
双精度浮点数	double（默认）	8个字节	4.9E-324~1.7977E+308
字符型	char	2个字节	0-65535
布尔类型	boolean	1个字节	true，false

类

入口函数为：main函数

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

类中包括 ：静态代码块，构造方法，成员变量、成员方法、类变量、类方法

执行顺序为：

​ 静态代码 > 构造方法 > 成员方法

​ 静态代码 > 类方法

静态代码在构造函数 和 本类的main方法之前执行，且只执行一次；可以用做初始化静态数据等工作。

PS：main方法可以认为是一个特殊的类方法

默认构造

同C++：

如果你不提供构造方法，系统会给出无参数构造方法。

如果你提供了构造方法，系统将不再提供无参数构造方法。

抽象类，抽象方法

abstract修饰的方法就是抽象方法，抽象方法没有方法体。

如果一个类存在抽象方法，则这个类为抽象类，需要用**abstract **修饰。

抽象类不可以实例化对象，需要一个子类继承这个类，实现所有的抽象方法，才能实例对象。

// abstract修饰的类需要
public abstract class Animal {
	public abstract void run()；
}

public class Cat extends Animal {
    @Override // 标识 方法重写 子类中出现与父类一模一样的方法；（可以用于编译检测）
    public void run() {
        System.out.println("Cat eat ... ");
    }
}

成员变量的默认值：

	数据类型	默认值
基本类型	整数（byte，short，int，long）	0
	浮点数（float，double）	0.0
	字符（char）	'\u0000'
	布尔（boolean）	false
引用类型	数组，类，接口	null

Demo:

$[Person.java]
public class Person {
    // 成员变量
    private String name;
    // 类变量
    public static String nation;
    // 静态代码块
    static {
        System.out.println("Person static !");
        nation = "中国";
    }
    // 类方法
    public static String getNation() {
        return nation;
    }
    // main方法
    public static void main(String[] args) {
        System.out.println("Person main running ... ");
        Person person = new Person();
    }
    // 无参构造
    public Person() {
        System.out.println("无参构造");
    }
    // 有参构造
    public Person(String name) {
        System.out.println("有参构造");
        this.name = name;
    }
    // 成员方法
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}
/*
Person static !
Person main running ... 
无参构造
*/

public class Demo {
    public static void main(String[] args) {
        System.out.println("Demo->main方法执行。。。 ");
        Person person1 = new Person();
        Person person2 = new Person("张三", "男", 18);
    }
}
/*
Demo->main方法执行。。。 
Person static !
中国
无参构造
有参构造
*/

继承

类继承

关键字：extends，Java是单继承的（这点有别C++）。

接口实现

关键字： interface（接口）、 implements（实现）

1. 无法定义成员变量，但是可以定义常量，其值不可以改变，默认使用public static final修饰。
2. 没有构造方法，不能创建对象。
3. 没有静态代码块。

一个类可是实现多个接口

1. 实现所有抽象方法的类才能实例化，如果没没有实例化所有的接口即为抽象类
2. 多个接口存在同一个抽象方法，实现一次即可

class 类名 [extends 父类名] implements 接口名1,接口名2,接口名3... {
	// 重写接口中抽象方法【必须】
	// 重写接口中默认方法【不重名时可选】
}

接口之间可以继承

1. 一个接口可以继承一个接口，并添加自己的方法
2. 一个接口也可以继承多个接口

public interface 接口名 extends 接口名1,接口名2,接口名3... {
}

**默认方法 & 静态方法 **

默认方法：使用 default 修饰，不可省略，供子类调用或者子类重写。
静态方法：使用 static 修饰，供接口直接调用。
public interface InterFaceName {
	public default void method() {
		// 执行语句
	}
	public static void method2() {
		// 执行语句
	}
}

私有方法和私有静态方法 私有方法：使用 private 修饰，供 接口中 的默认方法或者静态方法调用。

**类型转换 **

基础类型 ：基础类型之间的转换，如char类型转为int;为强制转换

int a = (int) word

向上转型 ：子类类型向父类类型向上转换的过程 ,如用一个父类引用指向一个子类对象 ；为默认转换

父类类型 变量名 = new 子类类型();
如：Animal a = new Cat();

向下转型 ：父类类型向子类类型向下转换的过程， 为强制转换

子类类型 变量名 = (子类类型) 父类变量名;
如:Cat c =(Cat) a;

判断类型

向下转型存在危险；

方式一：

用instanceof 判断类型。

// 基础类型不能这么处理
if (animal instanceof Cat)
{
    Cat c =(Cat) animal;
}

方式二：

用isInstance 判断

String str = "abcd";
//自身类.class.isInstance(自身实例或子类实例)  返回true 
System.out.println(String.class.isInstance(str)); //true;

方式三：

用isAssignableFrom

![Java内存](Java内存.png)String str = "abcd";
// 自身类.class.isAssignableFrom(自身类或子类.class)  返回true
System.out.println(String.class.isAssignableFrom(str.getClass())); //true;

this 和super

在Java中我们也会遇到一些问题，如在子类构造中调用父类的构造函数；在子类调用父类的方法；获得当前对象的引用。。

super ：代表父类的存储空间标识(可以理解为父亲的引用)。 this ：代表当前对象的引用(谁调用就代表谁)。

用法一：访问成员

this.成员变量 ‐‐ 本类的
super.成员变量 ‐‐ 父类的
this.成员方法名() ‐‐ 本类的
super.成员方法名() ‐‐ 父类的	

用法二：访问成员

this(...) ‐‐ 本类的构造方法
super(...) ‐‐ 父类的构造方法

子类的每个构造方法中均有默认的super()，调用父类的空参构造。手动调用父类构造会覆盖默认的super()。 super() 和 this() 都必须是在构造方法的第一行，所以不能同时出现。

稍微复杂一些的语法

内部类

将一个类A定义在另一个类B里面，里面的那个类A就称为内部类，B则称为外部类

class 外部类 {
	class 内部类{
	}
}

访问特点

内部类可以直接访问外部类的成员，包括私有成员。 外部类要访问内部类的成员，必须要建立内部类的对象。

内部类仍然是一个独立的类，在编译之后会内部类会被编译成独立的.class文件，但是前面冠以外部类的类名 和 $ 符号 。

比如，Person$Leg.class

public class Person {
	private boolean live;

    public class Leg {
        public void run() {
            if (live) {
                System.out.println("running .... ");
            } else {
                System.out.println("dead");
            }
        }
    }
    public Person() {
        this.live = true;
    }
    public Person(boolean live) {
        this.live = live;
    }
    public boolean isLive() {
        return live;
    }
    public void setLive(boolean live) {
        this.live = live;
    }
}

public class Demo {
    public static void main(String[] args) {
        Person person = new Person();
        Person.Leg leg1 = person.new Leg();
        leg1.run();
    }
}

匿名内部类

内部类的简化写法。它的本质是一个 **带具体实现的 ** 父类或者父接口的 匿名的 子类对象。 开发中，最常用到的内部类就是匿名内部类了。

要素：

1. 父类 或 父接口
2. 子类实现

new 父类名或者接口名(){
    // 方法重写
    @Override
    public void method() {
    // 执行语句
    }
};  

public interface Eat {
    public abstract void eat();
}
public class Demo {
    public static void main(String[] args) {
        Eat eat = new Eat() {
            @Override
            public void eat() {
                System.out.println("eat fruit");
            }
        };
        eat.eat();
    }
}