Java基础，笔记！



数据的输入
利用扫描仪Scanner进行数据输入

 （1）放在类声明之前，引入扫描仪
     imprort java.util.Scanner;
 （2）声明一个新的扫描仪
     Scanner in;
 （3）赋值
     in =new Scanner(System.in)（in是固定的）
     Scanner input=new Scanner(System.in);
  (4)使用扫描仪
     整型数据输入：in.nextInt()来接收
     双精度小数输入：in.nextDouble()
     字符串输入：in.next()
import java.util.Scanner;(这个包中包含了接口)
public class teke{
 public static void main(String []args){
  Scanner k=new Scanner(System.in);
  System.out.println("请输入你的名字：");
  String name=k.next();
  System.out.println("请输入你的年龄：");
  int age=k.nextInt();
  System.out.println("名字："+name);
  System.out.println("年龄："+age);
}
}
boolean(布尔)类型两个字节
boolean类型的值:
   真：true
   假：false
public class teke{
 public static void main(String[]args){
       int a=2;
 int b=2;
 boolean flag;
 flag=a!=b;
 System.out.println(flag);
  } /*输出false*/
}
逻辑运算符：与&& 或|| 非！
import java.util.Scanner;
public class teke{
 public static void main(String[]args){
  Scanner in=new Scanner(System.in);
  System.out.println("请输入java成绩");
  double java=in.nextDouble();
  System.out.println("请输入sql成绩");
  double sql=in.nextDouble();
  if(!(java>90)&&sql>90){
  System.out.println("奖励");
             }
              System.out.println("测试"); 
}
}
逻辑运算符只能对boolean类型的数据进行操作

equals判断字符串
sex.equals("男")
  sex.hashCode("男");哈希码是否相同
分支结构：
switch() case default
switch中只能执行字符的和整型

闰年：此年能被4整除&&不能被100整除||能被400整除的年份

Random产生随机数
格式：import java.util.Random;
      Random xx=new Random();
      int number=xx.nextInt(10);
列如：
（2:）
 import java.util.Random;
public class take{
 public static void main(String[]args){
      Random k=new Random();
  int number=k.nextInt(10);//表随机数的范围为0到10
  System.out.println("随机数为"+number);
    
   }
}
(2)：
public class random_1{
 public static void main(String[]args){
  System.out.println(Math.random()*10);//可产生double型的数值
 }
}
//支持多线程，多线程是为了使得多个线程并行的工作以完成多项任务，以提高系统的效率。线程是在同一时间需要完成多项任务的时候被实现的。
 
i++先使用后对自身加1
++i先自身加1后使用

累加用while

循环体内声明的变量叫局部变量只对循环体有用
对全局没用
do while
列如：
   do{
   循环操作
   }
  while（循环条件）;
while
列如:
 while(循环条件){
 循环操作
 }

eclipse是开源的
myeclipse适用于企业

src存源文件
对十进制取摸1234567%10的值为7
将数值取反：
while(number!=0){
  int temp;
  temp=number%10;//取数值的最后一个数开始，取个位上的数
  System.out.print(temp);
  number=number/10;//取除最后一个数
 }
因为temp为整型所以temp只会记录整数不会有小数

for循环：
for（参数初始化；条件判断；更新循环变量）{
循环操作；
}
while 和 for 的对比：
 int i=0;
 /*while(i<100){
  System.out.println(i+"好好学习");
  i++;
 }*/
 //for循环
 for( i=0;i<100;i++){
  System.out.println(i+"好好学习o");
 }
输入的数值内，有那些数相加为输入的值列如：
import java.util.*;
public class A4_16 {
public static void main(String[]args){
 System.out.println("请输入一个整数");
 Scanner k=new Scanner(System.in);
 int number=k.nextInt();
    for(int i=0,j=number;i<=j;i++,j--){
     System.out.println(i+"+"+j+"="+(i+j));
    }
}
}
(daske 密码luoluo)

continue 表示继续下一次循环
列如：
import java.util.*;
public class conn{
 public static void main(String[]args){
     Scanner k=new Scanner(System.in);
  while(true){//表示条件成立
   System.out.println("请输入密码");
   int number=k.nextInt();
   if(number!=123)
   {
    continue;
    }
    break;
   } 
  System.out.println("密码正确");
  }
 }

while 先判断，再执行          }用于循环次数不确定的情况下
do_while 先执行，后判断

for 先判断，后执行：用于循环次数确定的情况下

java的内存：
1、jum java虚拟机，在安装jdk时就有了，虚拟机是通过软件来实现的
2、java编译后的class文件就是放在java虚拟机上运行的
3、栈区（stacksegment）存在函数的参数值，局部变量，在超过这个变量的作用域是就会被系统自己动释放掉存在于jum内存中。
优点：存取速度比堆快
缺点：存在栈中的数据大小 与生存期必须是确定的，无灵活性
4、堆区（heapsegment）存放由new创建的对象和数组，jum不定时查看这个对象，如果没有引用指向对象就回收
例如：
Scanner k=new Scanner (System.in);
优点：可以动态分配jum内存
缺点：要在运行时分配jum内存 速度慢
5、静态区
6、代码区

栈内存：存放了基础类型如：int，double和引用内存如：scanner k
堆内存：存放new出的对象
声明数组： int[] a;
分配空间 a=new int[5];
若int型没有赋值 则它的默认值为0.

数组的声明： 
1、使用数组的方式
 int arr[];
 arr=new int[5];
 arr[0]=90;
2、使用数组的方式
 int[] arr=new int[5];
 arr[0]=90;
3、使用数组的方式
 int[] arr={23,3,43,5} ;
  int[] arr=new int[]{23,2,4};

进行升序排列：
  用java.util.Arrays类
  java.util包提供了许多存储数据的结构和有用的方法
  Arrays类提供了许多方法操纵数组，列如：排序，查询
  Arrays类的sort（）方法：对数组进行升序排列
  Arrays.sort(数组名);

降序：
 例如：
 arrays.sort(arr);
 for(i<arr.length-1;i<=0;i--)

数组的赋值：

public class A5_10 {
public static void main(String[]args){
 int[] arrA={2,4,3,5,7,34};
 int[] arrB=new int[arrA.length];
 for(int i=0;i<arrA.length;i++){
  arrB[i]=arrA[i];
 }
 for(int i=0;i<arrA.length;i++){
 System.out.print(arrB[i]);}
}
}
查找算法：
（A5_11）
插入排序：
import java.util.Scanner;
public class A5_12 {
 public static void main(String[]args){
  Scanner k=new Scanner(System.in);
  int[] arr={18,22,23,24 };
  System.out.println("请输入你要插入的数值");
  int num=k.nextInt();
  arr[arr.length-1]=num;
  for(int i=arr.length-1;i>0;i--)
  {
   if(arr[i]<arr[i-1]){
    int temp=arr[i];
    arr[i]=arr[i-1];
    arr[i-1]=temp;
  }else{
   break;
  }
   }
  for(int i=0;i<arr.length;i++){
   System.out.println(arr[i]);
  }
 }
}
插入排序是从最后一个数开始比较的
冒泡排序是从第一个数开始比较的
两两比较：
public class A5_13 {
public static void main(String[]args){
 int[] arr={23,12,34,32,11,37};
 for(int i=0;i<arr.length-1;i++){
  for(int k=0;k<arr.length-1;k++){
   if(arr[k]>arr[k+1]){
    int temp=arr[k];
    arr[k]=arr[k+1];
    arr[k+1]=temp;
   }
  }
 }
 for(int i=0;i<arr.length;i++){
 System.out.println(arr[i]);
 }
}
}

选择排序比冒泡排序简便：
一一比较，从前往后
A5-15

二维数组，就是数组的数组。
int arr[][]={{1,2},{3},{7,33,32}} 32的下标是2,2

一维数组：
int[] arr=new int[6]//一维数组
int[][] arr=new int[5][7]//二维数组

二维数组可以看成以数组为元素的数组。
int arr[][]={{2,1,4,5},{32,34,55}};

java中多维数组的声明和初始化一样，应按从高维到低维的顺序进行，列如：
int a[][]=new int[2][];//有两个一维数组
a[0]=new int[2];//第一个一维数组可以存放两个数
a[1]=new int[4];//第二个一维数组可以存放四个数
int t[][]=new int[][4];//非法

stack相当于栈内存存放局部变量的
heap相当于堆内存new

程序执行过程：

1.load到内存区        2.找到main方法开始执行 :内存      3.执行过程中的内存管理
|程序|:硬盘------------》|代码|《-------------------|操作系统码|---------------》1.|heap：       |new出来的东西
2.|stack：      |局部变量
3.|data segment:|静态变量字符串常量
4.|code segment:|存放代码

类名的首字母大写
建立类：
public class person{
  String name;
 String sex;
 /*无返回无参*/
 public void eat()//方法定义格式，括号里写参数{
  System.out.println();
 }
}
必须使用new关键字创建一个对象
使用对象属性（对象名.成员变量）
使用对象方法（对象名.方法名）
同一个类的每个对象有不同的成员变量的存储空间
同一个类的每个对象共享该类的方法

get可以取值 set可以赋值
成员变量是声明在类中的。

成员变量类型 ： byte,short,int,的默认值为0
         long的默认值为oL
  char 的默认值为‘\u0000’
  flot 的默认值为 o.of   
  double 的默认值为o.oD
  boolean 的默认值为false
所以的引用类型为：null
return：返回方法指定类型的值（这个值总是确定的），结束（方法）的执行
类的默认方法：toString()
public公共的都可以访问
面向对象三大基本特征之一封装：

private做设置私有的在自己的类可以访问，别的类不可以

set给成员属性

get获取成员属性

封装的做法：修改属性的访问权限来限制对属性的访问。并为每一个属性创建一对取值方法和赋值方法，用于对这些属性的访问

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

java的核心知识：

java发展历程-—————-------—>java开发环境搭建————→基础程序设计
                |               ↓
             java新特性←――|   | 数据类型||控制语句||数组||方法| 
        ↓  | 
|泛型|枚举|装箱，拆箱|可支参数|Annotation|
      |————→面向对象程序设计
      |eclipse| ←—— |  ↓
      ↓    | |封装|继承|多态|设计模式|异常|包|     |
   |JDT|JUnit|CVS|         |——————→应用程序开发
           ↓
     |连接Oracle|←|JDBC|类|集|二叉树|链表|类库|多线程|Io|反射|网络| 

面向对象概述：
面向过程思想：强调的是功能和行为。
面向对象思想：将功能封装进对象，强调具备功能的对象。

面向对象的三个基本特征：封装 继承 多态
 写在class里的是成员变量，写在方法里的是局部变量
关键字：
this 用来指当前对象

学习方法：
1.基本功 背程序。多敲，多写
2.坚持不懈
3.多积累问题
4.多看书thinking injava（）java编程思想
5.温故而知新
6.多找题目来做
7.多交流

1.类名首字母必须大写
2.方法和属性必须小写
类名：StudentAdmin 方法或属性studentNameName

static 可以修饰类中的属性成员变量使之成为静态成员变量
它的存储方式是：从对象的取出相同所 访问的属性，然后在同时访问它

列如：
public() class A6_33{
 pbulic static void main(String[]args){
 Student A=new Studnet();
 A.country="中国";
 Studnet b=new Student();
 System.out.println(B.country);
 }
}
/*static关键字
 作用： 是一个修饰符，用于修饰成员（成员变量，成员方法）被
  static修饰后的成员变量只有一份，当成员被static修饰之后
  多了一种访问方式，除了可以被对象调用之外还可以被类名直接调用
  （类名.静态成员）
 static的特点：
  1.随着类的加载而被加载
  2.优先于对象的存在
  3.被所以的对象所共享的
  4.可以直接被类名所调用
 存放位置：
  类变量随着类的加载而存在于data内存区
  实例变量随着对象的建立而存在于堆内存。*/
class Studnet{
 String name;
 int age;//非静态成员变量叫实例变量
 static String county;//静态变量（类变量）
}
 主函数（主方法）
1.public （访问修饰符，公共的）代表该类或者函数访问权限是最大的
2.static  代表主函数随着类的加载而存在
3.void    代表主函数没有具体的返回值
4.main   不是java中的关键字，它是一个特殊的单词，它能被jvm（java虚拟机）所识别
5.String[] args 函数的参数，参数类型是一个字符串数组，该数组的元素是字符串

静态应用工具类：
 每一个应用程序都有共性的功能，可以将这些功能进行抽取，独立封装。
 以使复用对象的作用：对象是用来封装数据的。
classpath:主要是在执行CMD的时候起作用，告诉jvm类的所保存的路径
path：主要功能是设置jdk的可执行命令
文本文档的生成：
 f:ArrayOperate 列文
文档提取：在CMD 输入 f:javadoc -d mydoc -author -vaersion ArrayOperate.java
//mydoc：自创文件夹名装文本文档 author：表示作者 vaersion：表示版本

静态代码块：列子：daima.java
静态代码块
格式：
static{
 静态代码块中的执行语句
}
特点：随着类的加载而执行，并且只会执行一次，并且还优先于主函数。
作用：用于给类进行初始化

对象初始化过程：如图：
1.因为new Studnet()用到了Studnet类，所以会把它从
硬盘上加载如内存。
2.如果有static静态代码块就会随类的加载而执行，还有
静态成员和普通方法也会随之类的加载而被加载。
3.在堆中开辟空间，分配内存地址。
4.在堆中建立对象属性，并同时对属性进行默认初始化
5.对属性进行显示初始化.
6.执行构造代码块，对所有的对象进行初始化。
7.执行对应的构造函数，对对象进行初始化。
8.将内存地址给new出来的对象（给栈中的变量）。

设计模式：针对此类问题最有效的解决方法
java有23种设计模式：解决一个类只在内存中存在一个对象

如何让一个类在内存中只存在一个对象？
1.禁止其他的应用程序，通过此类来创建对象
2.既然外部不能通过此类创建对象了，我们要用对象，就可以再本类中建立本类对象
3.为了其他应用程序能够访问到本类里面创建的对象，我需要对外界提供一种访问方式

如何用代码体现出来：
1.私有化构造函数
2.在本类中创建本类的对象
3.在类中创建返回对象的方法以用来实现对外界的访问

继承概念1：
1.提供了代码复用性，简化了代码
2.让类与类之间产生了继承关系，才有了后面的多态特性的存在
注意：千万别为了获取其他类的功能简化代码，而建立继承关系，必须要
类与类之间的继承关系。extends继承 
继承概念2：
子类拥有父类的成员，子类不能拥有父类中被private修饰后的成员

java多层继承 在多层继承中最下层的子类拥有整个继承体现的成员，
最上层的父类里面定义所以子类的共性描述

java中不支持多继承，但c++可以，java只支持单继承。
因为多继承存在安全隐患，当多个父类定义了相同的成员，
子类对象不确定运行哪一个。java保留这样机制，并用了另
一种方式来体现，多实现。
例如：
class Animal{//父类
 String name="你是猪";
 int age=3;
 void ty(){
  System.out.println("我们都是动物");
 }
}
class Dog extends Animal{//子类
 void dg(){
 System.out.println("我们都是狗");
}
}
class Cat extends Dog{//子类
 void ct(){
 System.out.println("我们都是猫");
}
}
class Pig extends Cat{//子类
 void pg(){
 System.out.println("我们都是猪");
}}
public class Student{
 public static void main(String []args){
  Cat cat=new Cat();
  cat.ty();
 }
}
子父类成员特点：
成员：
1.成员变量
2.函数
3.构造函数
变量：
this 代表当前对象的引用 this.变量 首先在本类中找所需要的这个变量
如果没本类没有，再到父类中找。
super 用于访问当前对象的父类成员，super.变量 直接在父类中找所需要的变量
例如：
class Person{
 String name="小风";
}
class Student extends Person{
 String name="小明";
 void show(){
  System.out.println(this.name);
  System.out.println(super.name);
 }
}
public class JC{
 public static void main(String[]args){
  Student stu=new Student();
   stu.show();
 }
}
2.函数
当子类中出现和父类中一样的函数时，当子类对象调用该函数，运行的是子类中的函数，如同父类中的函数被覆盖了一样，这种情况就是函数的另一种特性：重写（重载）
注意：
1.子类覆盖父类时，必须要保证子类权限大于等于父类，才可以覆盖，否则编译出错
2.访问权限修饰符：public>default(默认)>private 成员前面没加任何访问权限修饰符默认权限就是default
3.静态的函数只能覆盖(重写)静态的
class Animal{
 static String type;
 static void  run(){
  System.out.println("我在奔跑");
 }
}
class Cat extends Animal{

}
class Dog extends Animal{
  static void  run(){
  type="小风";
  System.out.println(type+"疯狂的奔跑");
 }
}
public class A6_48{
 public static void main(String[]args){
  Cat c=new Cat();
  c.run();
  Dog d=new Dog();
  d.run();
 }
}
有了子父类之后构造函数的特点：
在对子类对象进行初始化的时候，父类的构造方法也会运行，那是因为子类的构造函数默认
第一行有一条隐式的语句 super（）；

子类每个构造方法第一行都有一个隐式的super（）；
例如：
class fu{
 String name;
  fu(){
  System.out.println("父类构造方法");
 }
  fu(String k){
  System.out.println(k+"父类构造方法");
 }
}
class zi extends fu{
 zi(){
 super();
  System.out.println("子类的构造方法");
 }
 zi(String f){
  super("小明");
  System.out.println(f+"子类的构造方法");
 }
}
public class A6_49{
 public static void main(String []args){
  zi z=new zi("小月");
   
 }
}

对象的转型：
 1.对象的向上转型 子类转成父类 默认进行
 2.对象的向下转型 父类转成子类 强制进行

关键字：instanceof 测试左边的对象是否是右边类的实例
 如果是返回TRUE 如果不是返回false
例如：
class Animal{
 void sleep(){
 System.out.println("睡觉(～﹃～)~zZ");
 }
}
class Cat extends Animal{
 void cath(){
  System.out.println("吃鱼(⊙_⊙)？");
 }
}
class Dog extends Animal{
 
}
public class A6_50{
 public static void main(String[]args){
  Animal a=new Dog();//向上转型
  Dog s=(Dog)a;//向下转型
  //s.sleep();
  System.out.println(s instanceof Animal);
  
 }
}
ooP三大特性：封装，继承，多态
多态：可以理解为事物存在的多种体现形态
动物：猫，够，猪
人物：男人，女人

1.多态的体现
父类引用指向子类对象

2.多态的前提
（1）必须是类与类之间存在关系，可以是继承关系 也可以是实现关系
（2）必须得有重写

3.多态的好处
大大提高了程序的可扩展性

4.多态的弊端
提高程序的可扩展性，只能用于父类引用，访问到父类中的成员

5.多态成员变量的特点：
1.编译期间：参阅的是引用型变量所属的类中是否有调用的方法
2.运行期间：参阅对象所属的类中是否有调用的方法
例如：
class Animal{
 void sing(){
  System.out.println("动物( ⊙ o ⊙ )啊！");
 }
}
class Cat extends Animal{
 void sing(){
 System.out.println("喵喵~");
 }
}
class Dog extends Cat{
 void sing(){
 System.out.println("嗷嗷~~~~");
 }
 void call(){
 System.out.println("hello");
 }
}
public class A6_51{
 public static void main(String[]args){
  //Cat c=new Cat();
  //function(c);
  Dog k=new Dog();
  function(k);
 }
 public static void function(Cat c){//Cat c=new Dog();
  Dog d=(Dog)c;
  d.call();
 }
}

匿名对象：没有名字的对象
匿名对象使用方式：
1.当对对象的方式值调用一次时，我们可以用匿名对象来完成，比较简化。
2.匿名对象可以被当做实参传递
例如：
class Car{
 void start(){
  System.out.println("汽车启动");
 }
}
public class A6_54{
 public static void main(String[]args){
  //new Car().start();调用方法
  print(new Car());
 }
 static void print(Car c){//实参传递
  c.start();
 }
}
一个特殊的类：

object：它是java中所以对象的直接或间接父类，也称：根父类（基类），它里面定义的功能是所以对象都应该具备的。

记住：当定义一个新类时，没有指明要继承某类，它就默认继承object类。

Object所以对象的父类：
java.lang.Object类中有toString方法

==和object里面的equals是一样的都是比较的内存地址是否一致

final(最终)是一个修饰符
1、final可以修饰类，函数，变量（成员变量，局部变量）
2、被final修饰后的类不可以被其他类继承
3、被final修饰后的函数不可以被重写
4、被final修饰后的变量不允许被再次赋值，并且在修饰的同时还要赋值，被final修饰后的变量我们称它为常量，常量的值不允许被改变
常量的命名格式：字母全部要大写，如果这个名字是由多个单词组成，则在单词之间用_隔开

class Cat{
  final  static String age="小月";//全局常量
 
 
 }
public class A6_54{
 public static void main(String[]args){
  Cat c=new Cat();
  Cat c2=new Cat();
  
  
 }

}
被public final static多个修饰符修饰的变量称为全局常量

/*
 需求：求一段代码的运行时间
 原理：结束时间-开始时间 System.currentTimeMillis()
 
 什么是模板方法设计模式：
 定义功能时，功能的一部分是确定，而确定的部分在使用不确定，
 那么这时就得将不确定的部分暴露出去，由该子类去完成
*/
abstract class Demo{
 void getTime(){
  long a=System.currentTimeMillis();
   function();
  long b=System.currentTimeMillis();
  System.out.println("运行时间"+(a-b));
 }
 public abstract void function();
 
}
class Test extends Demo{
 public void function(){
  for(int i=0;i<9999;i++){
  System.out.print("I LOVE YOU");
  }
 }
}
public class A6_60{
 public static void main(String[]args){
  Demo d=new Test();
  d.getTime();
 }
}
接口：初步理解，接口是一个特殊的抽象类，当抽象类中全部是抽象方法时，
可以通过接口的形式来体现。
class 用于定义类
interface 用于定义接口

接口中成员的格式：
public static final String NAME="小风";//全局常量
public abstract void show();//抽象方法
在接口中：可以直接定义成员，因为接口会自己动加上public static abstractfinal ，接口中没有构造函数

注意：
1、接口中只能出现public访问修饰符
2、接口不可以创建对象（内存中也没有对象存在）,因为里面有抽象方法，需要被子类实现，子类对接口中的所有抽象方法实现后，子类才能够实例化，否则子类就是一个抽象类
3.在接口中实现就相当于继承implements=extends重写也叫实现
interface smoket{
 public static final String Name="小风";
  void show();
}
class Student implements smoket{
 public void show(){
  System.out.println("Hello");
 }
}
public class A6_61{
 public static void main(String[]args){
  Student s=new Student();
   s.show();
 
}}
java中没有多继承，但是有多实现：
类与类之间的关系：继承关系
接口与类之间的关系：实现关系
接口与接口直接的关系：继承关系
例如：
interface smoket{
 public static final String Name="小风";
 public abstract void show();
}
interface game{
 public void sing();
}
class Student implements game,smoket{
 public void show(){
  System.out.println("Hello");
 }
 public void sing(){}
}
public class A6_61{
 public static void main(String[]args){
  Student s=new Student();
   s.show();
 
}}
 
接口：提高了我们功能的扩展性，因为它降低了事物之间的耦合性（关系紧密程度）
接口好处：
可以多实现，也就是一个类可以实现多个接口
父类中定义的是多个类中共性的基本功能
接口中定义的是扩展功能

包（package）
什么是包呢？可以理解为文件夹
包的作用：
1、对类进行分类管理
2、给类提供了多层命名空间
注意：
1、类名的全称是包名.类名
2、定义包的语句一定要在代码的第一行

jar包 就是java中的压缩包
javac test.java 包名
jar

 字体：Window->preferences->General->Appearance->Colors and Fonts-> Basic->TextFont

异常捕获：用try catch 就可以避免没有出错的代码不被执行
try{  可能会出错的代码区 } catch(Exception a){

}
throws处理异常：
throws的处理方法是将异常抛给上一级处理，如果都不能处理，就抛给虚拟机处理，这个过程称为抛异常。这个处理方法适合比较严重的异常和程序员无法预料或无法完全避免异常发生的情况下。
import java.util.*;
public class luoluo {
  public  static void main(String []args){
  A a=new A();
  try{
  a.m();
  }
  catch(Exception e){
   System.out.println("请重新输入");
  }
  
  }
}
class A{
 public void m()throws Exception{
  Scanner k=new Scanner(System.in);
  System.out.println("请输入整数");
  int a=k.nextInt();
   int b=k.nextInt();
   int c=0;
    c=a%b;
    System.out.println(c);
 }
 
}
throws一般写在方法旁边，将扫描方法是否出错，出错将抛出异常

final：
类不能被继承，没有子类，
final
类中的方法默认是final的。
final
方法不能被子类的方法覆盖，但可以被继承。
final
成员变量表示常量，只能被赋值一次，赋值后值不再改变。
final
不能用于修饰构造方法。

Finally语句是起到异常处理出口的作用，用在try...catch语句最后，无论是否出现异常（catch中的语句是否被执行），finally中的语句都会被执行，这样可以更好的控制程序的走向

对象之间不再用==来进行比较，因为==是用来比较的是内存地址。
覆盖后的equals方法比较的不再是俩个对象的内存地址，而是根据之间的需求来决定。
例如：
public class L3_1
{
 public static void main(String[]args){
  K a1=new K(22);
  K a2=new K(22);
  System.out.println(a1.equals(a2));
 }
}
class K{
 private int i;
 K(int i){
  this.i=i;
 }
  boolean equals(K b2){
  if(this.i==b2.i){
   return true;
  }else{
   return false;
  }
 }
}