java基础

1. 面向过程：当需要实现一个功能的时候，每一个具体的步骤都要亲立亲为，详细处理每一个细节。
2. 面向对象：当需要实现一个功能的时候，不关心具体实现的步骤，而是找一个已经具有该功能的人来帮我做事。（偷懒）
3.  面向过程：强调步骤  面向对象：强调对象
4. 面向对象的三大特征：封装、继承、多态
5. 什么是类 ？

类：是一组相关属性和行为的集合。可以看成是一类事物的模板，使用事物的属性特征和行为特征来描述该 类事物。

1. 属性：就是该事物的状态信息。
2. 行为：就是该事物能够做什么。
3. 什么是对象

对象：是一类事物的具体体现。对象是类的一个实例（对象并不是找个女朋友），必然具备该类事物的属性 和行为。

1. 类与对象的关系

类是对一类事物的描述，是抽象的。

对象是一类事物的实例，是具体的。

类是对象的模板，对象是类的实体

1. 成员变量（属性）、成员方法（行为）
   
   
   
   11、注意事项：

1. 成员变量是直接定义在类当中的，在方法的外边
2. 成员方法不要写static关键字

1. 通常情况下，一个类不能直接使用，需要根据类创建一个对象，才能使用。（导包，创键，使用）
2. 导包：也就是指出使用的类在什么位置
   import 包名称.类名称;

注意：对于和当前类在同一个包的情况，可以省略导报语句不写

创建 ：类名称 对象名 = new 类名称（）；

  使用：
使用成员变量 ： 对象名.成员变量名

使用成员方法 ： 对象名.成员方法名（参数）

1. 当一个对象作为参数，传递到方法当中时，实际上传递进去的时对象的地址值。
2. 局部变量与成员变量的区别

1. 定义位置不同

局部变量：在方法的内部

成员变量：在方法的外部，直接写在类中

1. 作用范围不同

局部变量：只有在方法当中才可以使用，出了方法就不能再用

成员变量：整个类通用

1. 默认值不同

局部变量：没有默认值，如果想要在使用，必须手动进行赋值

成员变量：如果没有赋值，会有默认值，规则和数组一样。

1. 方法的参数就是局部变量，参数在方法调用的时候，必然会被赋值的。
2. 封装性在java当中的体现：1.方法就是一种封装2.关键字private 也是一种封装
3. 注意一旦使用了private进行修饰，那么本类当中依然可以访问，但是出了本类范围之外既不能再直接访问了。
4. 间接访问成员变量就是定义一对Getter/Setter方法。

必须叫setXXX或者getXXX命名规则

对于getter来说不能有参数，返回值类型和成员变量对应

对于setter来说不能有反水之，参数类型和成员变量对应

1. 对于基本数据类型当中的boolean值，getter方法一点要写成isXXX的形式，而setXXX规则不变
2. 当局部变量和类的成员变量重名的时候，根据“就近原则”，优先使用局部变量。如果想要使用本类中的成员变量名就需要使用this.成员变量名。
3. 通过谁调用的方法，谁就是this
4. 构造方法：是专门用来创建对象的方法，当我们通过new来创建对象的时候，其实就是在调用构造方法。

 Public 类名称（参数类型 参数名称）{

方法体；

}

注意事项：  1.构造方法的名称必须与类名称完全一样。、

2.构造方法不要写返回值类型，连void都不写

3.构造方法不能return 一个具体的返回值

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

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

 构造方法是可以重载的，既可以定义参数，也可以不定义参数。

1. 标准类：4个组成部分

1. 所有的成员变量都要使用private关键字来修饰
2. 为每一个成员变量编写一对Gettere/Setter方法
3. 编写一个无参数的构造方法
4. 编写一个全参数的构造方法

这样的标准的类叫做：java Bean

1. Code---Generate--Getter/Setter
2. API:应用程序接口（好多类，好多方法）
3. Scanner:键盘输入
4. 只有java.lang包下的内容不需要导包，其他的包都需要import语句。
5. 引用类型的一般使用步骤：

1. 导包
2. 创建
3. 使用

1. System.in代表从键盘进行输入
2. 获取键盘输入的一个字符串：String str = sc.next();
3. 没有名字的对象就叫匿名对象 new 类名称（）；
4. 匿名对象只能使用唯一的一次，下次再用不得不在创建新对象。

使用建议：如果确定有一个对象只需要使用唯一的一次，就可以使用匿名对象

Random类

1. 导包（util）、创建(Random r = new Random())、使用(r.nextint()范围是所有范围)
2. Random获取一个随机的int数字（参数代表了范围，左闭右开区间）例如：【0，2），也就是0到二
3. r.nextint(n)+1  表示范围是从1到n
4.  数组有一个缺点，一旦创建，程序运行期间长度不可以改变ArrayList
5. ArrayList集合的长度可以改变
6. 对于ArrayList<E> 其中<E>表示泛型。

泛型：也就是装在集合当中的所有元素，全都是统一什么类型

注意：泛型只能是引用类型，不能是基本类型

1. 备注：从JDK1.7开始，右侧的尖括号内部可以不写内容，但是<>本身还是要写的。
2. 扩展：直接打印得到的不是地址值而是内容。若内容是空，得到的是空的中括号
3. 常用方法：add,get,remove

Math类

1. Abs（double num）绝对值的方法
2. Ceil(double num):向上取整、floor(double num):向上取整
3. Long round(double num):四舍五入
4. Math.PI：代表近似的圆周率常量

继承

1. 继承是多态的前提，若果没有继承就没有多态
2. 继承主要解决的问题就是：共性抽取
3. 父类也可以叫做基类、超类
4. 继承关系的特点：

1. 子类可以拥有父类的“内容”
2. 子类还可以拥有自己专有的内容

1. 在继承关系中，子类就是一个父类，也就是说子类可以被当作父类看待
2. 在父子类的继承关系中，如果成员变量重名，则创建子类对象时，访问有两种方式：

直接：通过子类对象访问成员变量

等号左边是谁，就优先用谁，没有则向上找

间接：通过成员方法访问成员变量

该方法属于谁，就优先用谁，没有则向上找

1. 注意

局部变量： 直接写成员变量名

本类的成员变量：this.成员变量名

父类的成员变量：super.成员变量名

1. 在父子类的继承关系中，创建子类对象，访问成员方法的规则：创建的对象是谁，就优先用谁，如果没有则向上找。

注意事项：无论是成员变量还是成员方法，若没有都是向上找父类，绝对不会向下找子类的。

1. 重写：（Override）在继承关系中，方法的名称一样，参数列表也一样。
2. 重写与重载的区别

重写：方法的名称一样，参数列表也一样。（Override）

重载：方法的名称一样，参数列表不一样。（Overlood)

1. 方法的覆盖重写特点：创建的是子类对象，则优先用子类方法。
2. @Override：写在方法前面，用来检测是不是有效的正确覆盖重写
3. 子类方法的返回值必须小于等于父类方法的而返回值范围
4. 子类方法的权限必须（大于等于）父类方法的权限修饰符

提示：public > protected >(default) > private

备注：（default）不是关键字default，而是什么都不写留空

1. 继承关系中，父子类构造方法的访问特点：

1. 子类构造方法当中有一个默认隐含的“super（）”调用，所以一定是先调用的父类构造，后执行的子类构造
2. 子类构造可以通过super关键字来调用父类重载构造
3. Super的父类构造调用，必须是子类构造方法的第一个语句，不能是一个子类构造调用多次super构造

总结：子类必须调用父类的构造方法，不写则赠送super()，写了则用写的指定的super调用，super只能有一个,还必须是第一个。

Super关键字

1. 关键字的用法有三种：

1. 在子类的成员方法中，访问父类的成员变量
2. 在子类的成员方法中，访问父类的成员方法
3. 在子类的构造方法中，访问父类的构造方法

1. this关键字的作用

1. 在本类的成员方法中，访问本类的成员变量
2. 在本类的成员方法中，访问本类的另一个成员方法
3. 在本类的成员方法中，访问本类的另一个构造方法
4. 注意：this(...)调用也必须是构造方法的第一个语句，唯一一个。

1. this和super两种构造调用不能同时使用
2. Java继承三个特点

1. 一个类的直接父类只能有唯一一个（单继承）
2. Java语言可以多级继承
3. Object是整个继承体系中的祖宗类
4. 一个子类的直接父类是唯一的，但是一个父类可以拥有很多个子类

抽像的概念

1. 例如：计算图形的方法（抽象方法）（因为不够具体：比如说正方形）
2. 如果父类当中的方法不确定如何进行{}方法体实现，那么这就应该是一个抽象方法
3. 抽象方法：就是加上cbstract关键字，然后去掉大括号，直接分号结束
4. 抽象类：抽象方法所在的类必须是抽象类，在class之前写上abstract即可。
5. 如何使用抽象类和抽象方法？
   1. 不能直接创建new抽象类对象
   2. 必须使用一个子类来继承抽象父类
   3. 子类必须覆盖重写抽象父类当中所有的抽象方法

覆盖重写（实现）：子类去掉父类中abstract关键字，然后补上方法体的大括号

1. 创建子类对象进行使用

6、抽象类中不一定包含抽象方法，但是有抽象方法的类一定是抽象类

接口类

1.接口就是一种公共规范标准

2.格式：public interface 接口名称 {

// 抽象方法

// 默认方法

// 静态方法

 // 私有方法

}

3.接口是一种引用数据类型，最重要的内用就是其中的：抽象方法

4.注意事项：

1.接口当中的抽象方法，修饰符必须是两个固定的关键字：public abstract

2.这两个关键字的修饰符，可以选择性地省略

3.抽象方法是没有方法体的直接是小括号结束

5.使用步骤

  1.接口不能直接使用不许有一个“实现类”来实现接口

2.格式：public class 实现类名称 implements 接口名称{

}

  3.接口的实现类必须覆盖重写（实现）接口中所有的抽象方法

   实现：去掉abstract关键字，加上方法体大括号

4.创建类的对象使用

6、如果实现类并没有覆盖重写接口中所有的抽象方法，那么这个实现类自己就必须是抽象类

7、接口里默认方法的基本格式

 Public default 返回值类型 方法名称（参数列表）{

方法体

}

1. 接口的默认方法可以通过接口的实现类对象直接调用
2. 接口的默认方法也可以被接口的实现类覆盖重写
3. 从java8开始，接口当中允许定义静态方法

格式：

Public static 返回值类型 方法名称（参数列表）{
方法体

}

1. 不能通过接口实现类的对象来调用接口当中的静态方法
2. 正确用法：通过接口的名称，直接调用其中的静态方法
3. 从java9开始，接口当中允许定义私有方法

私有方法：普通私有方法和静态私有方法

1. 普通私有方法

     格式： private 返回值类型 方法名称（参数列表）{
方法体；

}

  静态私有方法：

格式： private static 返回值类型 方法名称（参数列表）{
方法体；

}

1. 接口当中也可以定义“成员变量”，但是必须使用 public static final 三个关键字

   格式：public static final 数据类型  常量名称 = 数据值；

   一旦使用final关键字进行修饰，就说明不可以改变

   接口当中的常量必须进行赋值，不能不赋值

   接口中常量的名称，使用完全大写的字母（shift+F6），用下划线进行分割

接口名称直接.就行

1. 总结

1. 使用接口时要注意：

1.接口时没有静态代码块或者构造方法的

2.一个类的直接类父类是唯一的，但是一个类可以同时实现多个接口

3.如果是实现类所实现的多个接口中，存在重复的抽象方法，那么只需要覆盖重写一次即可。

4.如果实现类并没有覆盖重写了所有接口当中的抽象方法，那么实现类就一定是一个抽象类

5.如果是实现类所实现的多个接口中，存在重复的默认方法，实现类一定要对冲突的方法默认重写

6.有一个类直接父类当中的方法和直接接口的默认方法冲突，一定是优先父类的默认方法。

18、类与类之间是单继承的，直接父类只有一个

   1.类与接口之间是多实现的，一个类可以实现多个接口

   2.多个父接口当中的默认方法如果重复，那么子接口必须进行默认方法的覆盖重写（必须带着default关键字）

多态

1. 一个对象拥有多种形态，这就是对象的多态性
2. Multi(多态)
3. 代码当中体现多态性就一句话：父类引用指向子类对象

   格式： 父类名称 对象名= new 子类名称（）；

接口名称 对象名= new 实现类名称（）；

1. 访问成员变量的两种方式：

1. 直接通过对象名称访问成员变量：看的等号左边是谁，优先用谁，没有则向上找
2. 间接通过成员方法访问成员变量：看该方法属于谁，优先用谁，没有则向上找

1. 成员方法的访问规则

  看new的是谁，就优先用谁，没有则向上找

1. 注意：（成员方法）编译看左边，运行看右边

         （成员变量）编译看左边，运行看左边

1. 多态的好处：无论等号右边new的时候换成哪个子类对象，等号左边调用方法都不会变化
2. 对象的向上转型：

  格式：父类对象 对象名 = new 子类名称（）；

  含义：右侧创建一个子类对象，把它当作父类对象来看待使用

  注意：向上转型一定是安全的（从小范围转向为大范围）

  弊端：对象一旦转型为父类，那么就无法调用子类原本持有的内容

  解决方法：用对象的向下转型（还原）

1. 对象的向下转型

  格式： 子类名称 对象名 = （子类名称） 父类对象;

  含义：将父类对象还原成为本来的子类对象

1. java.long.Class.Exception 类转换异常
2. 如何知道一个父类的引用对象本来是什么子类？

格式：对象 instanceof 类名称

者将会得到一个boolean值结果，也就是判断前面的对对象能不能当作后面类型的实例

Final关键字的用法

1. 常见的四种方法：

1. 可以用来修饰一个类
2. 可以用来修饰一个方法
3. 还可以用来修饰一个局部变量
4. 还可以用来修饰一个成员变量

1. 当final 关键字用来修饰一个类时

   格式 ： public final class 类名称 {

//....

}

含义：当前这个类不能有任何的子类（太监）

注意：一个类如果是final，那么其中所有的成员方法都无法进行覆盖重写

1. final可以用来修饰一个方法，这个方法就是最终方法，不能被覆盖重写

   格式：修饰符 final返回值类型 方法名称（参数列表）{

//方法体

}

1. 注意：对于类、方法来说abstract关键字和final关键字不能同时使用，因为矛盾。
2. 还可以用来修饰一个局部变量，那么这个变量就不能进行更改。“一次赋值，终生不变”
3. 对于基本数据类型来说，不可变说的是变量当中的数据不可以改变。

对于引用数据类型来说，不可变说的而是变量当中的地址值不可改变，但是值可以改变

1. final还可以用来修饰一个成员变量，那么这个变量也照样是不可以改变

 注意：由于成员变量具有默认值，所以用了final 之后必须手动赋值，不会再给默认值啦。

对于final的成员变量，要么使用直接复值，要么通过构造方法赋值。

必须保证类当中的所有重载的构造方法，都最终会对final的成员变量进行赋值