JAVA笔记

简介

1995年推出

基础核心：Java SE 面向对象，API,JVM ---> Java EE java企业版，用于企业级应用及开发 jsp， ejb 服务
---> Java ME 用于嵌入式开发，安卓手游，移动设备，通信

JDK (JAVA 开发工具包)
JRE（java运行时环境）
JVM (java虚拟机): 源代码文件： XXX.java ---> 经编译器compiler编译 ---> 字节码文件：XXX.class --->
经解释器interpreter解释翻译（jvm就有解释器） ---> 就能执行My Program

JDK安好后，就有JRE，JRE里也包含有JVM

Java开发环境搭建

第一步：安装JDK
第二步：配置环境变量
JAVA_HOME 配置JDK安装路径
PATH 配置JDK命令文件的位置（bin）
CLASSPATH 配置类库文件的位置（lib）

安装验证：cmd ：java javac给出用法提示则没问题

用记事本编写java源代码

使用记事本编辑XXX.java ---> 使用javac命令编译器编译成XXX.class（javac xxx.java） ---> 使用java命令解释器解释(java xxx)（java 命令后不能跟文件后缀） ---> 执行

使用eclipse开发

eclipse是ide工具 ide：集成开发环境（IDE）是一类软件，将程序开发环境和程序调试环境集合在一起，提高开发效率。还有MyEclipse，NetBeans

1.创建java项目 （会生成包）
2.创建程序包 （源代码文件在包下）
3.编写java源程序
4.运行java程序

MyEclipse使用
它是对Eclipse的扩展，是一个十分优秀的用于开发java，javaEE的Eclipse插件集合。

程序的移植

笔记

标识符区分大小写

如何定义 Java 中的方法
所谓方法，就是用来解决一类问题的代码的有序组合，是一个功能模块。

一般情况下，定义一个方法的语法是：

访问修饰符 返回值类型 方法名（参数列表）{
方法体
}

其中：

1、 访问修饰符：方法允许被访问的权限范围， 可以是 public、protected、private 甚至可以省略 ，其中 public 表示该方法可以被其他任何代码调用，其他几种修饰符的使用在后面章节中会详细讲解滴

2、 返回值类型：方法返回值的类型，如果方法不返回任何值，则返回值类型指定为 void ；如果方法具有返回值，则需要指定返回值的类型，并且在方法体中使用 return 语句返回值

3、 方法名：定义的方法的名字，必须使用合法的标识符

4、 参数列表：传递给方法的参数列表，参数可以有多个，多个参数间以逗号隔开，每个参数由参数类型和参数名组成，以空格隔开

Java 中方法的重载

问： 什么是方法的重载呢？
答： 如果同一个类中包含了两个或两个以上方法名相同、方法参数的个数、顺序或类型不同的方法，则称为方法的重载，也可称该方法被重载了。如下所示 4 个方法名称都为 show ，但方法的参数有所不同，因此都属于方法的重载

问： 如何区分调用的是哪个重载方法呢？
答： 当调用被重载的方法时， Java 会根据参数的个数和类型来判断应该调用哪个重载方法，参数完全匹配的方法将被执行。

面向对象

类：类是模子，确定对象将会拥有的特征（属性）和行为（方法）。类的组成：属性和方法。
类的特点：类是对象的类型，具有相同属性的方法的一组对象的集合。

对象是具体实体

属性：对象具有的特征，有什么，每个对象的每个属性都拥有特定值。
方法：对象执行的操作，能干什么
所有java程序都以类class为组织单元

定义一个类的步骤

1.定义类名
2.编写类的属性
3.编写类的方法

public class 类名（首字母要大写）{

//定义属性部分
属性1的类型 属性1；
属性2的类型 属性2；

//定义方法的部分
方法1；
方法1；
}

使用对象步骤：

1.创建对象：

类名 对象名 =new 类名（）；
Telphone phone = new Telphone();

2.使用对象

引用对象的属性：对象名.n属性
phone.scree=5;给scree属性赋值5

引用对象的方法：对象名.方法名（）
phone.sendMessage(); 调用sendMessage（）方法

成员变量和局部变量

1.成员变量 在类中定义，用来描述对象将要有什么。 可被本类的方法使用，也可被其他类的方法使用。
2.局部变量 在类的方法中定义，在方法中临时保存数据。 只能在当前的方法中使用。

区别

作用域不同： 成员变量在整个类内都是可见的。
局部变量仅限于定义它的方法，限于方法的开始和方法的结束。

初始值不同： java会给成员变量一个初始值
java不会给局部变量赋予初始值

在同一方法中，不允许有同名局部变量；
在不同方法中，可以有同名局部变量

两类变量同名时，局部变量具有更高的优先级

构造方法
1.使用new+构造方法 创建一个新的对象
2.构造方法是定义在java类中的一个用来 初始化对象的方法
构造方法与类同名且没有返回值

就是可以创建对象，并可初始化对象的值
创建对象的时候就是执行的（无参的）构造方法

格式： public 构造方法名（）{
//初始化代码
}

当没有指定的构造方法时，系统会自动添加无参的构造方法
当有指定的构造方法时，无论无参还是有参，都不会自动添加无参的构造方法

构造方法也有重载

构造方法不但可以给对象的属性赋值，还可以保证给对象的属性一个合理的值

static使用之静态变量

大家都知道，我们可以基于一个类创建多个该类的对象，每个对象都拥有自己的成员，互相独立。
然而在某些时候，我们更希望该类所有的对象共享同一个成员。此时就是 static 大显身手的时候了！！

Java 中被 static 修饰的成员称为静态成员或类成员。它属于整个类所有，而不是某个对象所有，
即被类的所有对象所共享。静态成员可以使用类名直接访问，也可以使用对象名进行访问。
当然，鉴于他作用的特殊性更推荐用类名访问~~

使用 static 可以修饰变量、方法和代码块。

static使用之静态方法

与静态变量一样，我们也可以使用 static 修饰方法，称为静态方法或类方法。
其实之前我们一直写的 main 方法就是静态方法。
public static void print(){
}

1、 静态方法中可以直接调用同类中的静态成员，但不能直接调用非静态成员。
如果希望在静态方法中调用非静态变量，可以通过创建类的对象，然后通过对象来访问非静态变量。

2、 在普通成员方法中，则可以直接访问同类的非静态变量和静态变量.

3、 静态方法中不能直接调用非静态方法，需要通过对象来访问非静态方法。

Java 中的 static 使用之静态初始化块

Java 中可以通过初始化块进行数据赋值。如：

 

在类的声明中，可以包含多个初始化块，当创建类的实例时，就会依次执行这些代码块。
如果使用 static 修饰初始化块，就称为静态初始化块。

需要特别注意：静态初始化块只在类加载时执行，且只会执行一次，同时静态初始化块只能给静态变量赋值，
不能初始化普通的成员变量。

我们来看一段代码：

 

运行结果：

 

通过输出结果，我们可以看到，程序运行时静态初始化块最先被执行，然后执行普通初始化块，最后才执行构造方法。
由于静态初始化块只在类加载时执行一次，所以当再次创建对象 hello2 时并未执行静态初始化块。

封装

将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问

好处：
只能通过规定的方法访问数据
隐藏类的实例细节，方便修改和实现

封装步骤：修改属性的可见性（设为private）--> 创建getter/setter方法（用于属性的读写）
--> 在getter/setter方法中加入属性控制语句（对属性值的合法性进行判断）

source 下的 Generate Getters and Setters可自动生成

就是隐藏属性，通过方法得到属性


java中的包

包名为全小写字母拼写
作用：管理java文件，解决同名文件冲突。用不同名的包来区分相同文件名的类

定义包：package 包名 必须放在java源程序的第一行，包名间用 . 隔开 eg：com.imooc.Myclass

系统中的包

java.(功能).(类)

java.lang.(类) 包含java语言基础的类
java.util.(类) 包含java语言中各种工具的类
java.io.(类) 包含java输入输出相关功能的类

通过import关键字，在某个文件使用其它文件中的类

import 包.子包.类
import 包.*（包下的全部文件）

java中的访问修饰符

访问修饰符：可以修饰属性和方法的访问范围

private 本类
默认 本类 同包
protected 本类 同包 子类
public 本类 同包 子类 其他

this关键字

this关键字代表当前对象
this.属性 操作当前对象的属性
this.方法 调用当前对象的方法

封装对象的属性的时候，经常会使用this关键字

什么是 Java 中的内部类

问：什么是内部类呢？
答：内部类（ Inner Class ）就是定义在另外一个类里面的类。与之对应，包含内部类的类被称为外部类。

问：那为什么要将一个类定义在另一个类里面呢？清清爽爽的独立的一个类多好啊！！
答：内部类的主要作用如下：

1. 内部类提供了更好的封装，可以把内部类隐藏在外部类之内，不允许同一个包中的其他类访问该类

2. 内部类的方法可以直接访问外部类的所有数据，包括私有的数据

3. 内部类所实现的功能使用外部类同样可以实现，只是有时使用内部类更方便

问：内部类有几种呢？

答：内部类可分为以下几种：

成员内部类
静态内部类
方法内部类
匿名内部类


Java 中的成员内部类

内部类中最常见的就是成员内部类，也称为普通内部类。

成员内部类的使用方法：

1、 Inner 类定义在 Outer 类的内部，相当于 Outer 类的一个成员变量的位置，Inner 类可以使用任意访问控制符，
如 public 、 protected 、 private 等

2、 Inner 类中定义的 test() 方法可以直接访问 Outer 类中的数据，而不受访问控制符的影响，如直接访问 Outer 类中的私有属性a

3、 定义了成员内部类后，必须使用外部类对象来创建内部类对象，而不能直接去 new 一个内部类对象，
即：内部类 对象名 = 外部类对象.new 内部类( );

4、 编译上面的程序后，会发现产生了两个 .class 文件

Java 中的静态内部类

静态内部类是 static 修饰的内部类，这种内部类的特点是：

1、 静态内部类不能直接访问外部类的非静态成员，但可以通过 new 外部类().成员 的方式访问

2、 如果外部类的静态成员与内部类的成员名称相同，可通过“类名.静态成员”访问外部类的静态成员；
如果外部类的静态成员与内部类的成员名称不相同，则可通过“成员名”直接调用外部类的静态成员

3、 创建静态内部类的对象时，不需要外部类的对象，可以直接创建 内部类 对象名= new 内部类();
其中，第二个是外部类的 .class 文件，第一个是内部类的 .class 文件，
即成员内部类的 .class 文件总是这样：外部类名$内部类名.class

另外，友情提示哦：

1、 外部类是不能直接使用内部类的成员和方法滴
可先创建内部类的对象，然后通过内部类的对象来访问其成员变量和方法。

2、 如果外部类和内部类具有相同的成员变量或方法，内部类默认访问自己的成员变量或方法，
如果要访问外部类的成员变量，可以使用 this 关键字。

Java 中的方法内部类

方法内部类就是内部类定义在外部类的方法中，方法内部类只在该方法的内部可见，即只在该方法内可以使用。

一定要注意哦：由于方法内部类不能在外部类的方法以外的地方使用，
因此方法内部类不能使用访问控制符和 static 修饰符。

java的继承

是类与类的一种关系 子类，父类
java中继承是间继承，只能有一个父类

好处： 子类有父类所有的属性和方法 private修饰的无效

方法：class 子类 extends 父类{}

java中的方法重写

如果子类对继承父类的方法不满意，是可以重写父类继承的方法的，当调用方法时会优先调用子类的方法。

语法规则：返回值类型，方法名，参数类型及个数 都要与父类继承的方法相同，才叫方法的重写。

继承的初始化顺序：
先初始化父类再初始化子类；
先执行初始化对象中属性，再执行构造方法中的初始化。

final关键字

可修饰类、方法、属性和变量，使用final标识有“最终的”含义。
则类不可继承；
方法不可重写；
该类的属性不会进行隐式的初始化（类的初始化属性必须有值）或在构造方法中赋值（但只能选其一）；
变量的值只能赋一次值，成为常量。

super关键字：

在对象的内部使用，可以代表父类对象
1.访问父类的属性 super.age
2.访问父类的方法 super.eat()

子类的构造过程中必须调用父类的构造方法

如果子类的构造方法中没有显示调用父类的构造方法，则系统默认调用父类无参的构造方法。
如果显示的调用构造方法，必须在子类的构造方法的第一行。
如果子类构造方法中既没有显示调用父类构造方法，而父类又没有无参的构造方法，则编译出错。
如果自己定义了有参的构造方法，系统就不会帮生成无参的构造方法。

Object类

它是所有类的父类，如果一个类没有使用extends关键字明确标识继承另外一个类，则默认继承object类，object中方法，适合所有子类。

1.toString()方法 返回对象的哈希码（对象地址字符串）
可以重写这个方法，返回对象的属性值 source --> Generate toString()

2.eqials()方法
比较的是对象的引用是否指向同一块内存地址，dog1.equals（dog2）返回值为bool型，比较的是两个对象的内存地址是否相同。
一般情况下比较两个 对象时比较他的值是否一致，所以要进行重写。
new 再次相当于开辟了两个内存区域，所以两个对象的引用肯定不相同。等价于dog==dog2
==可判断两个基本数据类型的数据是否相同，若判断两个引用，比较的也是内存地址

若想判断两个对象的数据的值是否相同：重写equals方法
Source下的Generate hashCode() and equals()

类对象和类的对象
类对象更关注代码，类的对象更关注对象的值的信息
通过类对象可以判断对象的类型

多态

就是对象的多种形态，继承是多态的实现基础
1.引用多态 父类的引用可以指向本类的对象，父类的引用可以指向子类的对象。
Animal obj1 = new Animal();
Animal obj2 = new Dog(); 父类的引用可以指向子类的对象。这就是引用多态！
2.方法多态 创建本类对象时，调用的方法为本类方法
创建子类对象时，调用的方法为子类重写的方法或者继承的方法。这就是方法多态！

引用类型转换

1.向上类型转换（隐式/自动类型转换），是小类型到大类型的转换
2.向下类型转换（强制类型转换），是大类型到小类型
3.instanceof运算符，来解决引用对象的类型，避免类型转换的安全性问题。
if(animal instanceof Dog){} Dog类型能否转为animal类型

Java中的抽象类
语法：抽象类前使用abstract关键字修饰，则该类为抽象类。

作用：限制规定子类必须实现某些方法，但是不关注细节。

抽象方法没有方法体以分号结束。
抽象类定义：abstract class Animal{abstract void grow();}抽象类的抽象方法都需要添加关键字abstract，且顺序为abstract class。
使用规则：
abstract定义抽象类
abstract定义抽象方法，只有声明，不需要实现。抽象方法没有方法体以分号结束。
包含抽象类方法的类是抽象类
抽象类中可以包含普通的方法，也可以没有抽象方法
抽象类不能直接创建，可以定义引用变量

接口

接口可以理解为一种特殊的类，由全局常量和公共的抽象方法所组成。

类是一种具体实现体，而接口定义了某一批类所需要遵守的规范，接口不关心这些类的内部数据，
也不关心这些类里方法的实现细节，它只规定这些类里必须提供某些方法。

是用来约束类的

定义接口
和类定义不同，使用interface关键字

类是单继承的，接口是多继承的

方法

[修饰符]interface 接口名[extends 父接口1，父接口2...]
{
零个到多个常量定义。。。
零个到多个抽象方法的定义。。。
}

接口就是用来被继承、被实现的，修饰符一般建议用public，不能使用private和protected修饰接口

接口定义：
常量： 接口中的属性是常量，即使使定义时不添加，public static final 修饰符，系统也会自动加上
方法： 接口中的方法只能是抽象方法，总是使用，即使定义时不添加public abstract修饰符，系统也会自动加上

一个类可实现一个或多个接口，实现 接口使用implements关键字。

继承父类实现接口的语法：
[修饰符] class 类名 extends 父类 implements 接口1，接口2...
{
类体部分//如果继承了抽象类，需要实现继承的抽象方法；要实现接口中的抽象方法。
}

接口命名，名字前加个大写I

使用接口： 接口在使用过程当中，还经常与匿名内部类配合使用
匿名内部类就是没有名字的内部类，多用于关注实现而不关注实现类的名称。