JAVA语言入门学习

常用DOS命令

一、win+r  --》cmd

编译-->  javac  文件名.java

执行 --> java  文件名

二、 dos命令； 

                        （1）切换盘符：c:或d:或e:  大小写没有区别

                        （2）显示具体信息：dir

                        （3）改变当前目录 cd Java

                        （4）cd .代表当前目录  cd ..代表上一层目录

                        （5）清屏：cls   ----》c语言的是Ctrl+l。
                        （6）切换历史已操作命令：上下箭头
                        （7）补全文件目录命令：tab按键     切换相同首字母的文件夹
                        （8）创建目录： md  文件名    删除目录：rd 文件名
                        （9）复制文件命令：copy 文件名.txt   路径\文件名.txt
                        （10）删除文件内容 ：del 文件名  

                        （11）移动文件：move

JAVA语言注释

//下面是一段标准代码
//这是代码的“框子”，当前阶段你可以当做一个模板
//其实这就是一个类，类的名字是Hel1oWorld,这个名字可以随便起，但是一般首字母大写，驼峰命名，见名知意
public class HelloWorld[
//下面是一个main方法，方法的格式是固定的
          public static void main (String [] args)(
        //下面这句话的作用：将双引号中的内容进行原样输出
        /*
       这是多行注释
       每行都可以写
       单行注释和多行注释，按照你自己的需求去使用即可
       */
      System.out.println("hi....java");
      }
}

二、文档注释
/**
文档注释
@author zhaoss
@version1.0
*/
public class HelloWorld{
          /**
         文档注释
          @param name 姓名
          @param age  年龄
          */ 
          public static void main (String [] args)(
      System.out.println("hi....java");
      }
}

初始java

public class HiWorld{
    public static void main(String[] args){
                    Stystem.out.print("姓名:");
        Stystem.out.println("莉莉");
        Stystem.out.print("职业");
        Stystem.out.println("学生");
    }
     }
(1)System.out.print和System.out.println区别联系：
System.out.print：将双引号中内容原样输出，不换行
system.out.println：将双引号中内容原样输出，换行
*/
(2)转义字符 ，
\就是转义字符：作用：将后面普通的字母转换为特殊含义
\n：换行
\t:   空格
*/

标识符

标识符：包，类，变量，方法.....等等，只要是起名字的地方，那个名字就是标识符
标识符定义规则：
1.四个可以（组成部分）：数字，字母，下划线，美元符号$
注意：字母概念比较宽泛，指的是英文字母，汉字，日语，俄语……
但是我们一般起名字尽量使用英文字母
2.两个不可以：不可以以数字开头，不可以使用java中的关键字
3.见名知意：增加可读性
4.大小写敏感：int a;int A;
5.遵照驼峰命名：
类名：首字母大写，其余遵循驼峰命名
方法名，变量名：首字母小写，其余遵循驼峰命名
包名：全部小写，不遵循驼峰命名
 

常量和变量

常量分为两种：
常量通常指的是一个固定的值，例如：1、2、3、'a'、'b'、true、false、"helloWorld”等。
在Java语言中，主要是利用关键字final来定义一个常量。常量一旦被初始化后不能再更改其值。
为了更好的区分和表述，一般将1、2、3、'a’、'b’、true、false、”helloWorld”等称为字面常量，而使用final修饰的Pl等称为符号常量（字符常量）。

字面常量的类型
整型常量 12333
实型常量 3.1415926
字符常量 'a'   -----------------》char单引号
逻辑常量 true false
字符串常量"helloworld"-----》String双引号

注意：逻辑常量就两个值，一个是true,一个是false

变量

变量声明：int 定义整型变量。float定义浮点型变量。

---

注意 ：一定要赋值，不然如上图一样报错尚未初始化。

---

变量赋值：可以直接int age =10；

---

习题

答案都是：20 

变量的作用域

 no表示无法正常输出。

 数据类型

先扩展一个知识点有关于进制转换的，给变量赋值可以为不同进制的。

 各数据类型的变量。

 浮点类型   float 表示6~7位和double表示8位以上

 float是4bit和double是8bit，两者代表的不一样。不能比较

字符型 （char）

 

 java中无论字母，数字，符号，中文都是字符类型。char本质上是utf-16编码的。

 注意：转义字符的用法

 字符和编码

 注意：无论你输出的是字面常量。

 面试题测试：

 答案是4：因为ch6为52，但是字符52在ASCII码刚刚好对应4

解释乱码问题

 用记事本选择编码方法的时候一般要选择为ANSI---》获取当前操作系统的编码格式：GBK

布尔类型：要么为ture要么为false

类型转换

 强制转换看左右级别

 特殊情况

 如果范围超过，比如取270，就是要强制转换；

byte b2 =(byte)270;

System.out.println(b2);   输出结果为14；

原因是byte是占一个字节，int占四个字节，超出部分，直接去掉。

 练习题

当常量被final修饰时候，这个常量就不能被更改。

当要自己设置输入值r：拿来一个扫描器（导入包），建立一个扫描器，让扫描器扫描一个录入的int数据类型。

 scanner的深入使用

import java.util.scanner
public class TestVar{
public static void main(String[] args){
   //键盘录入学生的信息：年龄；身高，姓名，性别；
  Scanner cs =new Scanner(System.in);  //扫描器
  //键盘录入年龄；（接收int类型数据）
  System.out.print("请录入年龄：");
  int age  = cs.nextInt(); 

  //键盘录入身高；（接收double类型数据）
  System.out.print("请录入身高：");
  double height  = cs.nextDouble();

  //键盘录入姓名；（接收字符串--》String类型数据）
  System.out.print("请录入姓名：");
  String name  = cs.next();
  
  //键盘录入性别；（接收字符---》char类型数据） 因为API中没有明确接收char类型的类，要利用字符串/转换一下
   System.out.print("请录入性别：");
   String sexStr  = cs.next();
   char sex =sexStr.charAt(0); //0代表索引值就是一个字符串"abc" 下标表示012,0代表取第一个字符a
   //上面两句可以合为一句表示：char sex= cs.next.charAt(0);
   System.out.println("该学生的信息为：姓名是："+name+",年龄是："+age+",身高是："+height+
",性别是："+sex);
   }
}

 上面是一个初步的java认识，下面算是正式进入学习，会分类比较细，主要以练习题目代码为主，一个合格的程序员，代码最少要敲2万行以上。

---

运算符

算数运算符（+，-，*，%，++(自增)，--(自减)）

/ 除法运算符：表示两个数相除运算

% 取余运算符：用来求余数的

public class TestVer2{
    public static void main(String[] args){
//打印结果
        System.out.println(12/3); //4
        System.out.println(12%5);  //2
        System.out.println(12/3.0); //4.0
        System.out.println(12%5.0); //2.0
    }
}

练习：实现功能：任意给出一个四位数，求出每位上的数字。

import java.util.scanner;
public class TestOpen1{
    public static void main(String[] args){
    //实现功能：给一个数字，输出每一位数字。
    //扫描器读取屏幕
    scanner sc =new scanner(system.in);
    System.out.print("请输入一个4位数字");
    int num =sc.nextInt();
    
    //1.求出每位上的数字；
    //个位数；
    int num1 =num%10;  
    System.out.print("个位数："); 

    //十位数
    int num2 =num/10%10;   //1234---->123---->3
    System.out.print("十位数：");

    //百位数
    int num3 =num/100%10;   //11234--->12--->2
    System.out.print("百位数：");    


    //千位数
    int num4 =num/1000;     //1234---->1
    Syetem.out.print("千位数：");
    
  }
}

/ 加法运算符：表示正数，相加，拼接操作

 /++(自增)，--(自减)运算符

 无论这个变量是否参与到运算中去，只要用++运算符，这个变量本身就是加1操作。只是对这个运算结果会产生影响

练习

这道题比较复杂，搞懂这个就说明会了，下面是解题思路 。

赋值运算符（=） 

用一个题目去深入了解这个运算符。

交换两个数字：

import java.util.Scanner;
public class TestOpen2{
    public static void main(String[] args){
    //任意给出两个数字，交换两个数并且输出；
    Scanner sc=Scanner(System.in);
    int num1=sc.nextInt();
    int num2=sc.nextInt();
    
     System.out.println("交换前："+num1+"\t"+num2);
    //交换
    /*错误代码
    num1 =num2;
    num2 =num1;
    */
    
    //解决办法；
    //引入一个中间变量；
    int t;
    t=num1;
    num1=num2
    num1=t;

    //输出交换前的两个数字；
 
   System.out.println("交换后："+num1+"\t"+num2);
    }
}

扩展运算符(+=,-=,*=,/=)

 面试题

 关系运算符(>，<，>=，<=，==，!=)

 逻辑运算符(&，&&，|，||)

三元运算符(a?b:c)

 

 位运算符(了解)

 3<<2 (3左移2位)

 

 面试题：4乘以8最快的方式：4<<3

 运算符的优先级

流程控制

流程控制语句是用来控制程序中各语句执行顺序的语句，可以把语句组合成能完成一定功能的逻辑模块。分为3类，顺序，选择（也称分支），循环结构。

顺序结构(先执行a，再执行b)

不是重点，忽略不计。

选择结构(如果.....否则)

if语句单分支

if(布尔类型){ 返回true执行里面的语句}

import java.util.Scanner;
public class TestOpen2{
    public static void main(String[] args){
   //给出3个数字（1-6），对三个数字求和计算，根据和的大小来分配不同奖品。
   Scanner sc = new Scanner(System.in); 
   //键盘输入3个数字
    int num1=sc.nextInt();
    int num2=sc.nextInt();
    int num3=sc.nextInt();
   //求和int num=num1+num2+num3;
   int sum =0;
   sum+=num1;
   sum+=num2;
   sum+=num3;
    System.out.println("和为:"+sum);
 
   //根据和判断奖品：
     if(sum>=14){
       System.out.println("一等奖");
      }
      if(sum>=10&&sum<14){
       System.out.println("二等奖");
      }
      if(sum>=6&&sum<10){
       System.out.println("三等奖");
      }
       if(sum<6){
       System.out.println("四等奖");
      }
   }
}

 if语句多分支

import java.util.Scanner;
public class TestOpen2{
    public static void main(String[] args){
   //给出3个数字（1-6），对三个数字求和计算，根据和的大小来分配不同奖品。
   Scanner sc = new Scanner(System.in); 
   //键盘输入3个数字
    int num1=sc.nextInt();
    int num2=sc.nextInt();
    int num3=sc.nextInt();
   //求和int num=num1+num2+num3;
   int sum =0;
   sum+=num1;
   sum+=num2;
   sum+=num3;
    System.out.println("和为:"+sum);
 
   //根据和判断奖品：利用一个多分支
   //else 隐藏了一个条件，与上面分支表达式相反。
     if(sum>=14){
       System.out.println("一等奖");
      }else if(sum>=10){  //隐藏了sum<14
       System.out.println("二等奖");
      }else if(sum>=6){   //隐藏了sum<10
       System.out.println("三等奖");
      }else{               //隐藏了sum<6
       System.out.println("四等奖");
      }
   }
}

if语句双分支

import java.util.Scanner;
public class TestOpen2{
    public static void main(String[] args){
   //给出3个数字（1-6），对三个数字求和计算，根据和的大小来分配不同奖品。
   Scanner sc = new Scanner(System.in); 
   //键盘输入3个数字
    int num1=sc.nextInt();
    int num2=sc.nextInt();
    int num3=sc.nextInt();
   //求和int num=num1+num2+num3;
   int sum =0;
   sum+=num1;
   sum+=num2;
   sum+=num3;
    System.out.println("和为:"+sum);
 
   //根据和判断奖品：利用一个双分支
   //else 隐藏了一个条件，与上面分支表达式相反。
    if(sum>=10){
       System.ou.println("中奖");
    }else{
       System.ou.println("没中奖");
    }


//if-else双分支可以条件运算符进行替换：System.ou.println(sum>=10?"中奖了":"没中奖");
 
   }
}

随机数(依靠一个Math类生成随机数)

Math.random()------->[0.0 , 1.0)

Math.random()*6------->[0.0 , 6.0)右边是开区间只能取到5.9,

(int)(Math.random()*6)------[0 , 5]              (int)(Math.random()*6)+1------[1 , 6]    

public class TestOpen3{
    public static void main(String[] args){
   //随机生成一个0到1的数字
    int num1=(int)(Math.random()*6)+1;//范围是1到6；
    int num2=(int)(Math.random()*6)+1;
    int num3=(int)(Math.random()*6)+1;
    int num=num1+num2+num3;
            System.out.println(num1);
            System.out.println(num2);
             System.out.println(num3);
    System.out.println(num);
   if(num>14){
      System.out.println("中奖");
     }else{
       System.out.println("中奖");
        }
   }
}

练习[36,92] ------->[0~56]+36         (int)(Math.random()*57)+36

分支结构练习题1

import java.util.Scanner;
public class TestOpen4{
    public static void main(String[] args){
    Scanner sc =new Scanner(System.in);
    System.out.print("请输入会员积分：");
    //先判断键盘录入数据是不是int类型的
     if(sc.hasNextInt()==true){
      //是int类型数据，将这个int类型的数据接收；
     
   
       int score= sc.nextInt();
      if(score>=0){
         if(score>8000){
                 System.out.print("该会员享受的是：0.6");
             }else if(score>=4000){
                 System.out.print("该会员享受的是：0.7");
             }else if(score>=2000){
                 System.out.print("该会员享受的是：0.8");
             }else{
                 System.out.print("该会员享受的是：0.9");   
             }
         }else{ 
              System.out.println("对不起你录入的积分是负数，不符合要求");
             }
   }
   else{
       //不是int类型
      System.out.println("你输入的不是int类型")
     }
   } 
}

分支结构练习题2

练习：
小朋友搬桌子：
年龄大于7岁，可以搬桌子；
如果年龄大于5岁，性别是男，可以搬桌子；
否则不可以搬动桌子，提示：你还太小了

import java.util.Scanner
public class TestOpen5{
  public static void main(String[] args){
   //录入小朋友年龄
    Scanner cs =new Scanner(System.in);
    System.out.println("请输入年龄");
    int age=cs.nextInt();
    
    //根据年龄判断
    if(age>=7){
           System.out.println("yes");
      }else if(age>=5){
           System.out.println("请输入性别，男：1  女：0");
           int sex =cs.nextInt();
           if(sex=1){//男
             System.out.println("yes");
           }else{//女
            System.out.println("no");
           }     
        }else{  //age<5
             System.out.println("no,年龄太小");
           }
   }

}

或者可以直接输入字符串，用chatAt(0)取输入的第一个字符

switch分支

因为会执行后面所有代码，为了防止代码的穿透效果，在每个分支加上break。

 循环结构

while循环

底层重复执行代码，提高了程序员编写效率

public class TestOpen4{
    public static void main(String[] args)
    //功能：1+2+3+4+5
    int num=1;//定义一个变量  【1】条件初始化
    int sum =0;//定义一个求和变量，用来接收和；
    while(num<=5){    【2】条件判断
      sum+=num;        【3】循环体
      num++;            【4】迭代
      }
    //输出和
   System.out.println(sum);

}

练习题 

do--while循环

此循环和while差不多

两者的区别 

 for循环

三者循环结构是一样的效率。

关键字 

break

break标签可以制定跳出的循环

 counter

 return

循环练习题

1

2 

 

 循环嵌套 

1.乘法口诀表

先看看编程思路，由简单到深入1

 倒乘法口诀

2.打印形状

上面长方形升级一下，把每行*前面多一些空格，显得美观。

 打印平行四边形

 第1行空8格，第2行空7格，第3行空6格。故空格数=9-行数。

 打印三角形

外循环，空格不用变，先分析*数和行数关系

 

 菱形，由上面三角形和下面三角形组成。

 空心菱形

在菱形加个if判断就可以，保留开始和结尾的*数，其余为空格。

 菱形打印扩展，另一种方式。

先由一个正方形改变，总结出起始位置，结束位置，两个位置中间就是输出*号，其余空格。size用来确定起始位置和结束位置。还可以自己设置菱形大小。

 

空心菱形就只需要在起始位置，结束位置打印*号。

 

 3.三重循环

同上，三重循环可以解决三元一次方程组的问题。

练习题

 因为3只小鸡1文钱，z应该是3的倍数，所以要把z除3中，余数不是0的去掉。

其实三元问题可以优化成二元方程。实际编程中比较少看到三元问题。

方法的定义/调用/重载

 

 方法提取

 对上述练习题猜数提取为一个方法。

 面试题（两数交换）

判断下面习题是否成功，并且主要探究是什么原因，为什么不成功。

程序一定是从main中开始执行，开辟一个栈空间，依次执行，其中调用chang方法后，a，b，赋值给num1，num2.在执行changnum的方法，然后changnum方法调用后要释放内存，其中改变的是num1，num2的值，而a，b，没有改变值。

方法的重载 

下面是方法的重载，直观感受。 

定义 ：可以同时使用，不重复，不冲突。

数组的引入

单纯的求值中，无法求出每个学生的成绩。 

 数组的初步认识

 

 

 对数组内存存取的分析。

数组遍历方式

 

数组三种初始化方式

静态初始化   动态初始化  默认初始化

数组的应用 

1.最值问题

原理：打擂原理，设置一个擂主（一般是第一个），其他人上去比较。

可以利用方法对上述题目进行优化 

分析内存原理

2.查询问题 

查询索引 

 对上述查询索引提取方法，

3.添加功能 

逻辑原理

 

 对上述题目提取方法

 

4.删除功能 

一个返回字符串的类Arrays.toString();对数组遍历，返回一个好看的字符串。但是前提要导包，不然会报错。

删除指定位置上的元素。

 优化一下

 再优化成通用规律

删除指定元素 

详细main方法讲解

 手动传入实参

可变参数

上述方法只是一个方法，不构成重载，所以只有第一个是对的。现在想解决这问题，设置一个方法，参数可变。当然只是部分，如果输入2.5，不符合int类型，就会报错。

 注意：4.可变参数和其他一起的时候一定要放最后面。自己写代码的时候，建议不要使用。

数组_Arrays工具类的使用

 数组的复制

二维数组

 代码与内存原理

遍历二维数组

 

 

 二维数组初始化方式

静态初始化

动态初始化

 

 默认初始化

 

 IDEA使用的方法

了解当前主流开发编程工具。

 详细使用方法在另一篇文章，不在此篇章赘述。

---

---

---

 面向对象

先搞定面向过程和面向对象的区别。注意：单纯在这讲区别，是无法彻底理解。它是一个长期的渐变，需要自己慢慢体会。

 

 经典案例：人把大象装进冰箱。

类和对象的关系

 面向对象的三个阶段

创建类

创建对象 

 

局部变量和成员变量的区别 

 局部变量一定要初始化才能打印出来，成员变量有默认值。

 

构造器 

 

 构造器的作用：不是为了创建对象，因为在调用构造器之前，这个对象就已经创建好了，并且有属性默认的初始化值，调用构造器的目的是给属性赋值的。但是我们一般不会在构造器中进行初始化操作，因为那样就写死了。注意系统会自动分配空构造器给你，但是有时会出错。

构造器的重载

 

内存分析

1.

 2.

---

---

---

---

this的使用

this关键字用法:
(1) this可以修饰属性:
总结:当属性名字和形参发生重名的时候，或者属性名字和局部变量重名的时候，都会发生就近原则，所以如果我要是直接使用变量名字的话，就指的是离的近的那个形参或者局部变量，这时候如果我想要表示属性的话，在前面要加上: this.修饰。 

 this修饰方法:

总结:在同一个类中，方法可以互相调用，this.可以省略不写。|

 (3) this可以修饰构造器:

总结:同一个类中的构造器可以相互用this调用，注意:this修饰构造器必须放在第一行

 

static修饰属性 

static可以修饰:属性，方法，代码块，内部类。
static修饰属性;

 static修饰属性总结:

(1)在类加载的时候一起加载入方法区中的静态域中

(2)先于对象存在

(3)访问方式:对象名.属性名类名.属性名(推荐)

static修饰属性的应用场景:

某些特定的数据想要在内存中共享，只有一块--》这个情况下，就可以用static修饰的属性

 

 属性分为两种: 静态属性(类变量)static string school        非静态属性(实例变量)id

static修饰方法

 

代码块

[1]类的组成;属性，方法，构造器，代码块，内部类
[2]代码块分类:普通块，构造块，静态块，同步块(多线程)
[3]代码:
普通块:在方法中

 注意时刻保持空构造器。

总结: (1) 代码块执行顺序: 最先执待静态块，只在类加载的时候执行一次，所以一般以后实战写项目:创建工厂，数据库的初始化信息都放入静态块。 一般用于执行一些全局性的初始化操作。

再执行构造块，(不常用)

再执行构造器，

再执行方法中的普通块。

包_import详解

[1]生活案例:
邮寄快递:中国.北京.通州区.****小区.5号楼.3单元.101房.赵珊珊
历史:常山赵子龙
[2]包的作用:
为了解决重名问题(实际上包对应的就是盘符上的目录)
解决权限问题

包名定义

(1)名字全部小写。

(2)中间用.隔开。

(3)一般都是公司域名倒着写:comjdcom.msb

(4)加上模块名字: comjd.login com.jd.register

(5)不能使用系统中的关键字:nul,con,cpm1---com9..... 

(6)包声明的位置一般都在非注释性代码的第一行:

导包 

 

在Java中的导包没有包含和被包含的关系:
设置目录平级的格式(不是包含和被包含的显示)

 

面向对象三大特性

封装 

通过例子来熟悉私有封装。

 上面的代码，对于属性age来说，我加了修饰符private，这样外界对它的访问就受到了限制，现在我还想加上其他的限制条件，但是在属性本 身上没有办法再加了，所以我们通过定义方法来进行限制条件的添加。

进行封装: (1)将属性私有化，被private修饰--》加入权限修饰符 一旦加入了权限修饰符，其他人就不可以随意的获取这个属性 (2)提供public修饰的方法让别人来访问/使用 (3)即使外界可以通过方法来访问属性了，但是也不能随意访问，因为咱们在方法中可以加入限制条件。

实际开发中，方法一般会写成 setter, getter方法: 可以利用IDEA快捷键生成:alt+insert -->getter and setter:

加深练习

字符串等于输入的值用equals

 

加入有参构造

 加入构造器后，限制可能不全面，所以需要复用。

四个权限修饰符：

 

继承

 

 代码演示

 

 继承的好处:提高代码的复用性
父类定义的内容，子类可以直接拿过来用就可以了，不用代码上反复重复定义了
需要注意的点:
父类private修饰的内容，子类实际上也继承，只是因为封装的特性阻碍了直接调用，但是提供了间接调用的方式，可以间接调用。

继承的内存分析

 方法的重写

方法重载和重写的区别:

重載:在同一个类中，当方法名相同，形参列表不同的时候多个方法构成了重载

重写:在不同的类中，子类对父类提供的方法不满意的时候，要对父类的方法进行重写。

super修饰属性方法

 在特殊情况下，当子类和父类的属性重名时，你要想使用父类的属性，必须加上修饰符super.，只能通过super.属性来调用。
在特殊情况下，当子类和父类的方法重名时，你要想使用父类的方法，必须加上修饰符super.，只能通过super.方法来调用。
在这种情况下, super.就不可以省略不写。

super修饰构造器

其实我们平时写的空构造器的第一行都有:super() -->作用:调用父类的空构造器，只是我们一般都省略不写。

如果构造器中已经显示的调用super父类构造器，那么它的第一行就没有默认分配的super。

在构造器中，super调用父类构造器和this调用子类构造器只能存在一个，两者不能共存: 因为super修饰构造器要放在第一行，this修饰构造器也要放在第一行:

 继承条件下的执行方法。以后写代码构造器的生成可以直接使用IDEA提供的快捷键: alt+insert

 object类

toString()方法

 

 

 总结:toString的作用就是对对象进行“自我介绍”，一般子类对父类提供的toString都不满意，都要进行重写。

equals()方法

 

 

 总结:
equals作用:这个方法提供了对对象的内容是否相等的一个比较方式，对象的内容指的就是属性。
父类Object提供的equals就是在比较==地址，没有实际的意义，我们一般不会直接使用父类提供的方法，而是在子类中对这个方法进行重写。

比较两个不同类型的对象。

用eclipes生成equals方法---》hashcode

用idea生成equals方法。

类与类的关系

类和类可以产生关系:将一个类作为另一个类中的方法的形参。

另一种调用。

 

Mom后面有个初始值null，要改成一个具体的对象。

 总结：类和类可以产生关系的下面两种方法。
(1)将一个类作为另一个类中的方法的形参
(2)将一个类作为另一个类的属性

多态

多态跟属性无关，多态指的是方法的多态，而不是属性的多态。

子类向上抽取名字称为泛化。父类向下抽取称为继承。

案例：

 什么是多态: 多态就是多种状态:同一个行为，不同的子类表现出来不同的形态， 多态指的就是同一个方法调用，然后由于对象不同会产生不同的行为。多态的好处: 为了提高代码的扩展性。符合面向对象的设计原则:开闭原则。 开闭原则:指的就是扩展是开放的，修改是关闭的。

注意:多态可以提高扩展性，但是扩展性没有达到最好，以后我们会学习反射 。

final修饰符

修饰变量

 修饰方法

修饰类

抽象类的抽象方法

[1]抽象类和抽象方法的关系: 抽象类中可以定义0-n个抽象方法。

[2]抽象类作用: 在抽象类中定义抽象方法，目的是为了为子类提供一个通用的模板，子类可以在模板的基础上进行开发，先重写父类的抽象方法，然后可以扩 展子类自己的内容。抽象类设计避免了子类设计的随意性。

面试题:

(1)抽象类不能创建对象，那么抽象类中是否有构造器? 抽象类中一定有构造器。构造器的作用给子类初始化对象的时候要先super调用父类的构造器。

(2)抽象类是否可以被final修饰? 不能被final修饰，因为抽象类设计的初衷就是给子类继承用的。要是被final修饰了这个抽象类了，就不存在继承了，就没有子类。

接口

JDK1.8之前

注意:修饰符可以省略不写，IDE会帮你自动补全，但是初学者建议写上，防止遗忘。

JDK1.8之后

 

内部类_成员内部类 

内部类分为成员内部类和局部内部类

局部内部类(位置:方法内，块内，构造器内)

成员内部类(静态的，非静态的)

成员内部类

 

内部类_局部内部类

面对对象项目

异常

异常:Exception:在程序的运行过程中，发生了不正常的现象，阻止了程序的运行，我们称之为发生异常。

处理异常：if_else处理

(1)代码臃肿，业务代码和处理异常的代码混在一起。 (2)可读性差 (3)程序员需要花费大量的经历来维护这个漏洞 (4)程序员很难堵住所有的漏洞。

 

注意: (1) try中如果出现异常，然后用catch捕获成功的话，那么try中后续的代码是不会执行的。 (2)如果catch捕获异常成功，那么try-catch后面的代码该执行还是执行没有影响。

 异常的处理方式。

 

 finally作用

多重

分类

 

throw与throws区别

总结: throw和throws的区别: (1)位置不同: throw:方法内部 throws:方法的签名处，方法的声明处 (2)内容不同: throw+异常对象(检查异常，运行时异常) throws+异常的类型(可以多个类型，用，拼接) (3)作用不同: throw:异常出现的源头，制造异常。 throws:在方法的声明处，告诉方法的调用者，这个方法中可能会出现我声明的这些异常。然后调用者对这个异常进行处理: 要么自己处理要么再继续向外抛出异常 

异常练习

 重载与重写异常的规则

重载同一方法名，不同形参列表。与异常没有关系。

自定义异常

如果继承的是运行时异常，那么在使用的时候无需额外处理
如果继承的是检查异常，那么使用的时候需要try-catch捕获或者throws向上抛。

常用类

包装类

 日期类

 

日期练习

jdk新增日期时间API的原因

Math类

Random类

String类