Java

第一个Java程序

程序的操作流程

• 1.先写出可执行的代码
• 2.在命令框之中使用javac “文件地址”运行后，生成一个class字节码文件
• 再在命令框中使用java “文件名称”运行代码
  即为将class文件装载进入JVM（类加载器）当中，再去硬盘上查找该文件进行运行。
• 得到执行结果

helloworld

程序概况

• 程序如下
  public class HelloWorld{
  public static void main(Strings[] args){
  System.out.println(“Hello World!”);
  }
  }

• 注意：该程序在命名时，文件名称必须和public class后面的名称一致。

• 对于HelloWorld程序的解释

  • 1.public 是表示公开的（关键字）

  • 2.class 用力声明一个类（关键字）

  • 3.HelloWorld 是一个类名

  • 4.每一句Java语句都必须用；结尾，代码自上而下执行。

  • main 即为程序的入口，又叫做主方法，main后{}中的称为方法体。

  如何给Java程序添加注释

  注释的三种方式

  • 第一种：单行注释

    • //单行注释，两个正斜杠后面的内容为注释内容。

  • 第二种：多行注释

    • /*

    • *这里的注释信息为多行注释

    • *第一行注释内容

    • *第二行

    • */

  • 第三种：javadoc注释

    • /**

    • *@author 作者名字

    • *@version 版本号

    • *@since 自从哪个版本开始就存在了

    • */

    • 对于Javadoc注释来说，这里的注释内容会被javadoc.exe解析并生成帮助文档。

  注释应该怎么写

  • 通常在类和接口处写，这一部分的注释是必须的。在这里我们可以使用javadoc.exe注释，表明创建者，时间，版本，以及类的应用。
  • 对于入参，出参，返回值，均要标明。
  • 对于常量，标明该常量的用途。

  public class和class的区别

  • 在同一个Java文件之中，public class定义的公共类名只能有一个，而且这个文件若是A.java 则被public class定义的类名只能是A。

  • 在源文件之中，我们可以使用class创建多个类来使用，但是类的名称不能重复，在每一个类中我们都可以编写main方法，想让程序从哪个入口执行，则加载哪个类即可。

Java基础语法

标识符

标识符的命名规则

• 标识符只能以数字，字母，下划线，美元符号组成。

• 标识符不能以数字开头。

• Java关键字和保留字不能作为标识符。

• 严格区分大小。

• 没有长度限制。

关键字

关键字即是Java系统中自己定义的常量，有些表示数据类型，或是数据结构。

字面值

字面值其实就是数据

Java中的字面值

• 1.整数型字面值

• 2.浮点数型字面值

• 3.布尔字面值

• 4.字符串型字面值

• 5.字符字面值（单引号括起来的单个字符）

数据类型

• 例如：
  float i=1.0；
  int n=（int）i；

  注意：

  • 在数据的强制转化之中，可能会造成精度丢失，要慎重。（大容量转向小容量，即为上面的例子。）

  • 也有一种转化为自动转化，即为小容量向大容量转化。

  • 不同的类型在进行运算时，先转化成为容量最大的那个类型，再进行运算。

  难点

  • 对于下面的程序

    byte a=3;
    byte b=a+4;
    byte c=3+4;

    • 这个程序的第二句会报错，然而第三句却不会，这是为什么呢？
      • 因为第二句中是byte类型加上int类型，他们会先转化为int再进行运算，编译器认为byte+int可能会超出byte的值，而且a还是一个变量，所以报错了。但是第三句中，3和7都是常量不是变量，可以直接计算出来是7，而这个7也没有超出byte的范围，所以编译又通过了。

  数据类型转为字符串如何转

  • 只需要在数据后面加上加号输出即可。
    public class StringTurn {
    public static void main(String[] args) {
    int i =1;
    double e= 2.11;
    float x=3.11f;
    String i1=i+“”;
    String e2=e+“”;
    System.out.println(i1);
    System.out.println(e2); }
    }
    

    那么字符串类型转为其他数据类型该怎么办呢？

  语法：需要用到基本类型的包装类调用parseXX方法即可

  • 要转换谁，就使用基本类型的包装类调用parseXX方法

    • eg：转换为整数使用Integer.parseInt()
      • Float.parseFloat()

  • Double.parseDouble()

    • Bollean.parseBoolean（）

    • 那么字符串如何转化为字符类型呢，我们需要的是把字符一个一个取出来，就像python的集合一样

      • eg：System.out.println(s.charAt(0));此刻我们假设s为一个字符串，我们取出他的第一位。

运算符

算数运算符

• +（加），-（减），*（乘），/（除），%（取余符号）

  单目运算符

  • ++，对数字自加1

  • –，对数字自减1

  • Java中规定，当单目运算符出现在变量之后时，会先做赋值运算。即=的优先级在此时高于++。

    • 比如b=a++，此时会先将值赋给b再进行加一运算，那么b=++a，此时a会先进行加一运算再赋予b。

  • 下面我给出一道经典的面试题

    int i=1;
    i=i++;
    System.out.println(i);
    i最后等于什么？为什么？

    • 这其中有一个临时变量，我来写出每一步
      1.temp =i 2.i=i+1 3. i=temp

  • 其中temp就是电脑执行这行命令时，所创造出的临时变量。

关系运算符

• >,>=,<,<=,==,!=

• 此关系符输出的是bool值

逻辑运算符

• &逻辑与

  • ture&true——true

  • flase&ture———flase

• |逻辑或

  • ture|flase——true

• ！逻辑非

  • ！true——flase

  • ！flase——true

• &&短路与

• ||短路或

• 短路，即为惰性原则，当&&判断出第一个是flase时，不会去计算后面的式子，而是直接输出flase，这就叫发生了短路。

• 运算结果为bool值

赋值运算符

• =

• +=

• -=

• *=

• %=

• /=

• 这几种全是赋值运算符，除去第一个，其他的全都是式子的简写，我以第二个为例子

  • a+=1就是a=a+1，其余的也一样，可以在编程中简化代码

字符串连接运算符

• 字符串连接符即为➕，当➕两边有一边是字符串类型时，会进行字符串的拼接。

• 字符串拼接时，会从左向右依次执行eg：

  a+“+”+b+“=”+a+b

  • 第一个加号是字符串，第二个是字符串连接符，执行下来的结果为a+b=a+b

• 当左右连接的是字符串时，会将其连接，但是如果是字符时，会将其转换成为阿斯克码再进行相加的运算。

条件运算符（三目运算符）

• 语法结构： 布尔表达式：表达式1？表达式2；

• 若布尔表达式为true，执行表达式1，若为flase，执行表达式2。

位运算符

• &按位与，|按位或，^按位异或，~按位取反，<<左移,>>右移（带符号）,>>>不带符号右移。

其他运算符

• instanceof

• new

控制语句

选择语句

if

• if语句一般的编写方式如下

  if(布尔表达式){
  java语句;

}
else if(布尔表达式){
java语句;

}
else{java语句; 
}- 如果布尔表达式值为true就执行当前if语句中大括号内的代码。

switch

• switch的编写方法一般如下

  switch(int/string){
  case int/string:
  java语句;
  break;
  case int/string:
  java语句;
  break;

  case int/string:
  java语句;
  break;
  default:
  java语句;

  }

  • 当switch括号内的值等于case括号内的值时，就执行当前case语句下面的java语句，如果没有匹配的值，就执行default下面的java语句

• 注意：每一个case的java语句写完后，都要加上break语句来终结本次选择语句的执行。

循环语句

for

• for语句的语法结构如下

  for(初始化表达式;布尔表达式;更新表达式){
  java语句;
  java语句;
  java语句;
  java语句;
  }

  • for循环中，先执行初始化表达式，再判断布尔表达式，如果布尔表达式为true，则开始执行循环体，当执行完循环体时，再执行更新表达式，最后再对布尔表达式进行判定，如果为ture则继续执行循环体，如果为flase就结束循环。

while

• while循环结构如下

  while(布尔表达式){
  循环体;
  }

  • 当布尔表达式为true时，循环会一直执行下去，直到布尔表达式为flase。

do……while

• do……while循环结构如下

  do{
  循环体;
  }while(布尔表达式);

  • 它会先执行循环体，再进行条件判断，如果为true，则继续循环，如果为flase就终止循环。

转向语句

• break

  • 被用于循环体中，用来跳出循环。

• continue

  • 被用于终止本次循环，继续进行下一次循环。

返回语句

• return
  • 当函数有调用时，用于返回值到函数调用处。

方法(内含Java虚拟机的内存管理)

方法的作用

• 方法的出现，极大的提高了编程的效率，当一个功能需要重复实现时，就可以用上方法来简化程序。

方法的声明和调用

• 方法的定义语法如下

  ​ [修饰符列表]返回值类型 方法名(形参列表){
  ​ 方法体;
  }

  • 修饰符列表，这个是可选的不是必须的。

  • 返回值类型，可以是Java的任何一种数据类型，当一个方法执行完成后，没有返回值时，必须写成void。

  • 方法名，这项必须是合法的标识符，可以看出来方法的作用。

  • 形式参数列表，当有多个形参时，通常使用“，”进行分离。

  • 方法体，由Java语句构成，代码遵循自上而下的顺序依次执行。

• 当写完一个方法的定义后，这个函数就已经声明了。

• 方法的调用实在主函数中，写出“类名.方法名.（实际参数列表）；”

• 有些情况下，类名可以被省略。

  • 当在方法a中执行方法b时，而且方法a与方法b的类相同时，b的类名可以被省略。

方法的形参和实参

• 方法在调用时，其实参必须和形参一一对应

• 形参和实参类型也必须一一对应，当然有些时候会出现类型的自动转化，比如int转long

方法的返回值

• 返回值会使用return语句，返回我们需要的值回到方法调用处。

• 方法的返回值必须和定义函数时写下的类型相同，不然会报错。

方法的重载和调用时其内存变化

• 要知道内存变化，我们先要了解一个数据结构：栈（stack）

  

• 如上图所示，向一个栈插入新元素，叫做进栈，入栈或是压栈（push），它将新元素放在栈顶元素的上面，使他成为新的栈顶元素；同样的将栈的元素删除称为出栈，退栈又称弹栈（pop），它是将栈顶元素删除来实现。

• 栈的限制是：仅允许在表的一边进行添加和删除的操作。

• 知道了栈的数据结构后，我们来看一张图

- 当Java程序开始实现时，先通过类加载器系统找到字节码文件，再将其加载到虚拟机中的方法区当中，开始调用main方法，main方法在被激活的瞬间，会在栈中给他分配活动空间，此时是压栈动作，main在栈底。- 当Java程序执行完成后，会释放内存发生弹栈动作，main方法最后一个被放出，所以我们说当main方法结束时，这个程序也就结束了是不无道理的。#### 对于图上各个点的解释##### 线程的概念- 线程是操作系统中能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。

程序计数器

- 概念：可以看做当前线程所执行的字节码的行号指示器。- 特点：线程私有的内存。

Java虚拟机机栈

- 概念：描述的是Java方法执行的内存模型
- 特点：线程私有，生命周期和线程相同。这个区域会出现两种异常。分别是StackOverflowError异常：线程请求深度大于虚拟机所允许的深度。  OutOfMenmoryError异常：若虚拟机可以动态扩展，如果扩展是无法申请到足够的内存。

本地方法栈

- 概念：他与虚拟机栈所发挥的作用是相似的，区别是Java虚拟机栈为Java方法服务，而本地方法栈为本地方法服务。- 特点：他也有和Java虚拟机机栈相同的异常。

Java堆

• 概念：是被所有线程共享的一块区域，在虚拟机创建时创建。

• 特点：线程共享，存放的是对象实例，GC管理的主要区域可以处于物理上不连续的区域。

方法区

• 概念：存储已经被虚拟机加载的类信息，常量，静态变量，即时编译器编译后的代码等数据。

• 特点：线程共享区域，抛出异常OutOfMemory异常：当方法去无法满足内存分配需求时。

方法重载

方法重载的定义：

是在一个类中定义多个同名的方法，但要求每个方法具有不用的参数类型或者是参数个数

作用：

在调用重载方法时，java编译器可以通过检查调用方法的参数类型和参数的个数来选择一个合适的方法。

满足的条件

• 1.在同一个类中
• 2.方法名相同
• 3.参数列表不同
  • 个数不同算不同
  • 顺序不同算不同
  • 类型不同算不同

递归

递归的定义

递归就是在m（）之中又调用了m（）方法，方法调用方法自身，就构成了递归。

注意事项

• 1，递归函数得在自己的函数中调用自己，才能一步步自己执行下去。

• 2，递归函数得自己设定结束的标志，不然会一直运算下去

生活实例

可以解决各种生活问题，比如汉诺塔，阶乘问题，迷宫问题，球和篮子的问题，算法中也会用到递归，比如快排，归并排序，二分查找等

例子：计算1~n的和

public class Test{public static void main(Strings[]args){int n=99;int result=accumulate(n);System.out.println("1~n的和是"+result);}public static int accumulate(int n){int result=0;if(n==1){return 1;}return n+accumulate(n-1);}	

例二：汉诺塔

规则:1、有三根相邻的柱子，标号为A,B,C。

​ 2、A柱子上从下到上按金字塔状叠放着n个不同大小的圆盘。

​ 3、现在把所有盘子一个一个移动到柱子B上，并且每次移动同一根柱子上都不能出现大盘子在小盘子上方。

代码实现：

public class hannuota {public static void main(String[] args) {class Tower{public void lujing(int num,char a,char b,char c){if(num==1){System.out.println(a+"->"+c);}else{lujing(num-1,a,c,b);System.out.println(a+"->"+c);lujing(num-1,b,a,c);}}}Tower t=new Tower();t.lujing(n,'A','B','C');}
}

例三：小老鼠走迷宫

小老鼠需要从左上角走到右下角，该怎么实现？

public class mouse {public static void main(String[] args) {int [][]migong=new int[8][7];for(int i=0;i<7;i++){migong[0][i]=1;migong[7][i]=1;}for(int i=0;i<8;i++){migong[i][0]=1;migong[i][6]=1;}migong[3][1]=1;migong[3][2]=1;
for(int i=0;i<migong.length;i++){for(int j=0;j<migong[i].length;j++){System.out.print(migong[i][j]);System.out.print(" ");}System.out.println(" ");
}System.out.println("==============");
class a{public boolean foundway(int [][]a,int i,int j){if(a[6][5]==2){return true;}else if(a[i][j]==0){a[i][j]=2;if(foundway(a,i+1,j)){return true;}else if(foundway(a,i,j+1)){return true;}else if (foundway(a,i-1,j)){return true;}else if(foundway(a,i,j-1)){return true;}else{a[i][j]=3;return false;}}else {return false;}}
}
a A=new a();A.foundway(migong, 1, 1);for(int i=0;i<migong.length;i++){for(int j=0;j<migong[i].length;j++){System.out.print(migong[i][j]);System.out.print(" ");}System.out.println(" ");}}
}

红色的就是小老鼠走过的路程。

this和static的用法

this

this可以看作一个引用，储存在java虚拟机内部，this这个引用保存了当前对象的内存地址指向自身，每一个堆内存的java对象都有一个this。

this引用和变量名引用其实是可以画等号的，都是指向对象的属性。

this不能出现在static的方法里面，因为static方法里面调用时不需要创建对象，直接采用类名调用，所以不用使用当前对象调用，因为this是和当前对象划等号的。

换句话来说this是出现在实例方法里面的。这个实例方法里面正在调用的对象是谁，this就是谁。

this在构造方法中

使用在构造方法的第一行，调用他时的语法格式是this（实际参数列表）。

很大程度上来说this简化了程序，当实参进入程序时，实参名等于this名，可以直接使用，提高了代码的可维护性。

static

表示”静态的“，它可以被使用来修饰变量，方法，代码等，修饰方法时叫做静态方法，变量叫静态变量，代码叫做静态代码块。

凡是使用static修饰的都是与类相关的，直接通过类名访问。

static使用时，即代表这个数值不会根据对象的改变而改变，如果根据对象的改变而改变了，那么就应该时实例对象，而不是静态对象。

静态代码块

• 就是在代码块外围大括号前面写上static。

  • 他会在类加载时运行，并且只执行一次。

  • 在静态代码块中出现实例变量会报错，我们只需要在给实例变量定义时前加上static即可，这表示该变量是一个静态变量。

    静态方法

• 一般是工具类的方法，会有利于开发，方便调用，直接使用类名就可以使用。

输入语句

用到了扫描器scanner=>他是简单文本扫描器

步骤

• 第一步：导入包，java.util.Scanner

• 第二步：创建一个对象，就是new（）在面向对象中写过如何创建一个对象。

• 第三步：接受键盘输入

数组(引用类型)

定义一个数组

• 比如：double [ ]hens ={1,5,9,7,9,5};
  • double代表这个数组的类型，hens代表这个数组的名称。

遍历数组（利用for循环）

• eg：利用for循环从hens[i]来循环，i=0然后慢慢递增，直到第5个，就将这个数组遍历完了。

• 这是代码

• 这是执行后的成果

数组的使用及其初始化

初始化方法

• 1.静态初始化

  • 

• 2.动态初始化

  • 

• 3.直接赋值

  • 

• 使用细节

• 1.数组是多个同类型数据的组合，实现对这些数据的统一管理。

• 2.不能高精度值赋给低精度类型，比如不能把double类型的数据放入int数组。

• 3.数组的数据类型，不能混用。

• 4.在数组创建后，没有的赋值时，默认值为0。

• 5.数组是引用类型，数组型数据是对象（object）。

数组的赋值规则

• 拷贝赋值

  • 就是基础类型之间的直接赋值，比如下面的代码，当我们改变n2的值时，n1不会受到影响。这与jvm的内存系统有关。

    int n1=10;
    int n2=n1;
    in2=20;

  • 在给n1赋值时将10直接给了n1，在执行n2=n1时，会将n1的值10直接拷贝到n2的值上，这就叫做拷贝复制，当我们改变n2的值时，n1便不会受到影响。

• 引用赋值

  • 数组在默认情况下是引用传递，赋的值是地址，赋值的方式为引用赋值。

  • 下面我用一段代码来说明

    int []arr1={1,2,3};
    int []arr2=arr1;
    arr2[0]=10;

    • 当我改变了arr2[0]的值时，arr1这个数组的值也会改变，这是因为在jvm里面存放时，数组指向的不是具体的值，而是一个空间，这个空间的名字叫地址，这个空间里面来存放数据，当我们将arr1数组赋给arr2数组时，是将他的地址赋给了arr2，那么此时arr2这个数组，也可以直接访问这个地址，当我们改变arr2的值时，相当于改变了这个地址上面的值，arr1也会随之改变。

• 数组拷贝（得到新数组，不和上一个有关联）

• 1.先new一个新数组，int arr1=new int [arr1.lenght];

• 2.然后使用for循环遍历救数组，将旧数组的值赋给新数组。

• 数组扩容

• 给int arr[]={1,2,3};后面扩容，加上4，使其变成{1,2,3,4}

  • 方法

  • 1.定义初始数组

  • 2.定义一个新的数组

  • 3.遍历初始数组，依次将初始数组的元素拷贝到新数组上

  • 4.让初始数组指向新数组，那么原来的数组将会被销毁

  • 代码实现

    • 

  • 原理

    • 主要是最后一步的指向，是将新数组的地址赋给旧数组的地址，从而使得旧数组的地址被销毁。

• 那我们现在写一个程序让用户自己决定什么时候停止给数组扩容

  import java.util.Scanner;
  public class shuzu {public static void main(String[] args) {int a[] = {1,2,3};do {Scanner s=new Scanner(System.in);System.out.println("input number");int w=s.nextInt();int newa[]=new int[a.length+1];for(int i=0;i<a.length;i++){newa[i]=a[i];}newa[a.length]=w;a=newa;for(int x=0;x<newa.length;x++){System.out.println(a[x]);}System.out.println(" if you want continue please input 1");int x=s.nextInt();if(x==1){break;}}while(true);}
  }
  

• 数组中查找东西

  • 1.定义一个字符串数组。

  • 2.接受用户输入，遍历数组，进行逐一比较，如果有，则提示信息，并推出。

  • 代码实现

    import java.util.Scanner;
    public class found {public static void main(String[] args) {String a[]={"mike","anna","davi"};Scanner d=new Scanner(System.in);System.out.println("please input name");String name=d.next();for(int i=0;i<a.length;i++){if(a[i].equals(name)){System.out.println("yes,you found it");}else if(i==a.length-1){System.out.println("sorry");}}}
    }
    

多维数组

• 多维数组

  • 二维数组

  • • 什么是二维数组

      • 从定义和形式上看，就是原来的每个元素都是一个数组，这样就是二维数组。

    • 两种创建方法

      • 第一种直接赋值创建
      • 就是直接赋值的方法

    • 第二钟动态创建
      int arr[][]=new int[2][3];
      arr[1][1]=3;

      • 列数不确定创建，即为一维数组中的元素不相同。

        • int[][]arr=new int [3][];

        • 就是给上面的一维数组开空间，然后可以分别给一维数组的每个元素赋值。

    • 遍历方法

      • 套用两层循环来实现

      • 代码实现

        public class DoublEshuzu {
        public static void main(String[] args) {int a[][]={{1,0,1,3},{5,4,1,4},{5,4,8,7}};for(int i=0;i<a.length;i++){for (int j=0;j<a[i].length;j++){System.out.print(a[i][j]+"\t");}}}
        }
        

    输出10行杨辉三角

    public class YangHui {public static void main(String[] args) {int [][]a=new int[10][];for(int i=0;i<a.length;i++){a[i]=new int[i+1];for(int j=0;j<a[i].length;j++){if (j == 0 || j == a[i].length-1){a[i][j]=1;}else{a[i][j]=a[i-1][j]+a[i-1][j-1];}}}for(int i=0;i<a.length;i++){for (int j=0;j<a[i].length;j++){System.out.print(a[i][j]+"\t");}System.out.println(" ");}}}
    

• 作业

随机生成10个整数（1~100）保存到数组，并倒序输出求出其打印值，求最大值和最小值的下标，并查找里面是否有8

代码实现

public class homework {public static void main(String[] args) {int []b;int sum =0;double HalfSum=0;b=new int[10];for(int i=0;i<10;i++){int a=(int)(Math.random()*100+1);b[i]=a;}int max=b[0];int min=b[0];for(int j=9;j>=0;j--){System.out.print(b[j]+" ");if(b[j]==8){System.out.print("yes");}sum += b[j];HalfSum=sum / 10;}System.out.println(" ");System.out.println(sum);System.out.println(HalfSum);for(int k=0;k<10;k++){if(max<b[k]){max= b[k];}if(min>b[k]){min=b[k];}}for(int f=0;f<10;f++){if (b[f]==max){System.out.println("max is"+f);}if(b[f]==min){System.out.println("min is"+f);}}}}

类与对象

为什么引入类与对象这个方法，我们从一个问题中来得到答案
王奶奶有两只小猫，一只5岁黑色公猫，一只6岁黄色母猫，现在编写程序来输入一只猫，得到这只猫的所有信息，如果输入的猫不是王奶奶的猫，则说明错误。

这个问题中，我们首先想到使用变量来实现，我们会发现，变量太多代码程序繁杂，那么我们再考虑使用数组来实现，数组在使用的过程中，我们不能统一数据类型进行使用，也是行不通的。

这时候，我们使用类与对象的方法来解决这个问题。

类和对象的关系

• 把猫所有的特性提取出来构成一个猫类，这些特性的数据类型各不相同，把每个猫的特性数据集合到一起，构成一个对象。这个对象就是一个具体的实例。

代码实现

  public class oop {public static void main(String[] args) {class cat{int age;//这里进行了猫类的创建，并且在猫类里面说明了猫的特性。}cat cat1=new cat();//创建了猫对象cat1.age=10;//给cat1对象的属性赋值System.out.println(cat1.age);}
}

如果要增加猫的属性，比如名字，直接再class cat里面加入名字这个特性即可。

对象在内存中的存在形式

基本数据类型会直接存储到堆里使用，非基本数据类型比如说字符串，会在堆里面存储地址，这个地址指向方法区里面的空间，在方法区这个空间存储变量。

属性和成员变量

基本概念：从概念和叫法上看，成员变量等于属性等于field（字段）

属性是类的一个组成部分，一般是基本数据类型，也可以是引用类型，比如说我们在猫类里面定义的age就是一个属性。

注意事项和细节说明：

1. 属性定义语法和变量相同，需要输入相同类型的值。
2. 属性的定义类型可以为任何类型，包含基本类型和引用类型。
3. 属性不赋值的情况下，有默认值，规则和数组相同。

对象其实是他里面的东西，cat1只是他的对象名，真正的对象是new出来的对象空间，即为new cat（） 。

成员方法

基本概念：在某些情况下，我们需要定义成员方法，比如人类除了年龄性别这些属性外，还有一些行为，这些就需要通过成员方法来完善。

public class oop {public static void main(String[] args) {class cat{int age;public void eat(){System.out.println("i like eat");}}cat cat1=new cat();cat1.age=10;cat1.eat();//调用eat方法System.out.println(cat1.age);}
}

这里的eat方法就是我定义的成员方法。

成员方法在jvm内存的储存空间

成员方法的定义方法

public 返回类型 方法名（形参列表）{方法体内的语句；return 返回值；
}

public是访问修饰符，有四种类型，用于控制方法生效的范围
四种分别是：public， 不写， potected， private。

细节问题

方法不能嵌套定义，即不能在方法里面定义方法

如何跨类调用方法

class A{public void m(){System.out.println("调用了a类中的m方法")；}public void n(){System.out.println("调用了a类中的n方法");}
}
class B{public viod am(){A a =new A();a.m();a.n();}
}
B b=new B();
b.am();

成员方法的传参机制

基本类型的传参机制

在方法中修改方法外部的数值，只要不return回去重新赋值，这个方法在执行完后会直接释放内存，不会影响外部的数值。不会修改地址。

引用类型的传参机制

比如数组来说，传递进去的是数组，即为地址，不是值。假如现在有一个方法用于交换数组当中的值，方法在调用时会，开辟一个新的栈来使用，这个方法在使用时，会对堆里面的地址进行改变，当方法执行完成后，这个方法栈被释放内存，但是这个堆里面的地址会永久的改变，这与基本类型不同，传递参数会影响到外部的值。会修改地址。 还有一种是传入对象，对象的本质也是地址，综上所述，这个只要传入的是地址，就会改变值。

如何将对象作为参数传入方法中呢？
比如现在的类是Person，在方法（）里面输入Person b即可，这示意在Person建立一个对象b传入方法之中。

了解了这么多，我们可以实现对象的克隆，属性情况都相同，但是输出的是两个不同的对象，下面是代码实现。

public class oop {public static void main(String[] args) {class Person {int age;String name;double high;}class copy {public Person copyPerson(Person b) {Person a=new Person();a.high=b.high;a.name=b.name;a.age=b.age;System.out.println(a.age);return a;}}Person b=new Person();b.age=11;b.name="mike";b.high=187.2;copy x=new copy();Person a=new Person();a=x.copyPerson(b);}
}

注意的点

一个是return出来的值需要去接收，所以我重新建立了一个新的对象a来接收方法执行中被克隆出来的对象。

第二个是方法如果要返回这个对象，他的返回值类型不能为void而是要返回的类名称，即为Person。

第三个是要使用方法时，需要先建立这个类的对象，再对象.方法名（），进行shi’y

重载（OverLoad）

基本介绍

介绍

Java中允许在一个类中，多个同名方法存在，但是要求形参列表不一致。比如说输出打印的方法，System.out.print()这个函数，什么都可以输出，比如说字符串，字符，布尔值，数字啥的。在这里的out其实就是一个对象，形参都不同，这种就叫方法的重载。

好处

1，减轻了起名的麻烦。

2，减轻了记名的麻烦。

例如

public class overload {public static void main(String[] args) {class num{public int num(int a, int b){return a+b;}public double num(double a,int b){return a+b;}public double num(int a,double b){return a+b;}public  double num(double a,double b){return a+b;}}num n=new num();System.out.println(n.num(5.3,6));System.out.println(n.num(5,4));System.out.println(n.num(6.6,4.2));}
}

运行正常，例子我用的是两位数的和方法，可以输出整数或者浮点数。

细节

方法名：必须相同。

参数列表：必须不同。（形参类型，形参个数不同都可以构成方法重载）

返回类型：无要求。

练习题

在m类中定义max（）方法，输入两个int值时输出较大值，输入两个double值时输出最大值，输入三个double值时输出最大值。

public class overload {public static void main(String[] args) {class m {public int max(int a, int b) {if (a > b) {return a;} elsereturn b;}public double max(double a, double b) {if (a > b) {return a;} else return b;}public double max(double a, double b, double c) {if(a>b&&a>c)return a;else if (b>a&&b>c)return b;else if (c>a&&c>b)return c;return 0;}}m m=new m();System.out.println(m.max(5,6));}
}

可变形参

基本概念

Java中允许将同一个类中多个同名同功能但是参数个数不同的方法，封装成为一个方法。这里就可以通过可变参数来实现。

快速入门案例

比如在重载中，我们加多个int类型的值，相加两个，相加三个，就得写两个方法，但是我们使用可变参数，就可以把他整合成为一个方法。

public class VarParameter{public static void main(Srting[] args){HsMethod m= new HsMethod();m.sum();}
}
class HsMethod{public int sum(int... nums){int res =0;for(int i=0;i<nums.lenght;i++){res += nums[i];}return 0;} 
}

我们现在观察上面的代码，其中的int… nums就代表可以接收int类型的值，数量是从0到n，这些数值会被保存到nums这个数组里面，当我们需要将其相加的时候，我们只需要遍历这个数组即可，极大的简化了程序。

注意事项

1. 可变参数的实参为0个或者至多个。
2. 可变参数的实质为数组。
3. 可变参数可以和普通类型的参数一起放在形参列表，但需保证可变参数在最后放置。
4. 一个形参列表只能出现一个可变参数。

练习

有三个方法，分别实现返回姓名和两门课程的总分，返回姓名和三门课的总分，返回姓名和五门课的总分，封装成一个可变参数的方法。

public class overload {public static void main(String[] args) {class b{public void student(String a,int... sums){int res=0;for(int i=0;i<sums.length;i++){res +=sums[i];}System.out.println(a);System.out.println(res);}}b a=new b();a.student("mike",4,5,7,8,9);}
}

作用域

基本使用

1. 在java编程中，主要的变量就是属性（成员变量）和局部变量。
2. 局部变量一般是指在成员方法中定义的变量。
3. 全局变量：就是属性，作用域为整个整体。
4. 局部变量：也就是除了属性以外的其他变量，作用域为定义它的代码块中。
5. 全局变量可以不进行赋值，直接使用，因为它具有默认值，局部变量必须进行赋值后才可以进行使用，因为没有默认值。

注意事项和细节

1. 属性和局部变量可以重名，访问时遵循就近原则。
   就近原则：比如有一个属性叫name=mike，在方法中的name=king，假如我们在创建对象后使用该方法输出name值，根据就近原则，会输出king这个值。那么我们接下来将方法中的name值给注销，再进行输出，就会输出mike这个值。
2. 在同一个作用域中，两个变量名不能重名。
3. 属性的生命周期长，伴随着对象的创建而创建，伴随着对象的死亡而死亡。局部变量，生命周期短，伴随着它的代码块执行而创建，伴随着代码块的结束而死亡，即在一次方法的调用中生效。
4. 范围不同
   全局变量：可以被本类使用，也可以通过在其他类中通过对象调用来在其它类中使用。（一种是跨类调用，另外一种是将类当参数传入方法使用）
   局部变量：只能在本类中的对应方法使用。
5. 修饰符不同
   局部变量不可以加修饰符。
   全局变量可以添加修饰符。eg：public ~ ~ ~

构造器constructor

什么时候使用？

当我们需要创建人类这个对象时，是先把一个对象创建好后，再给他的年龄和名字属性赋值，有了构造器，我们可以在创建人类对象时，直接指定这个对象的年龄和姓名。

作用：初始化新对象

基本语法

【修饰符】方法名（形参列表）{

​ 方法体；

}

说明：

1. 这里的修饰符可以不写，有默认值，也可以是public protected private
2. 构造器没有返回值。
3. 方法名必须和类的名字相同。
4. 参数列表和成员方法一样的规则。
5. 构造器的调用是由系统完成的。

快速入门

public class constructor {public static void main(String[] args) {class Person{String name;int age;public Person(String a,int b){name=a;age=b;}}Person p= new Person("mike",18);System.out.println(p.age);System.out.println(p.name);}
}

第十一行中在初始化对象时就定下了属性，输出结果正常。

注意事项和使用细节

1. 一个类可以定义多个不同的构造器，即为构造器重载。（可以一个只给名字，一个给名字和年龄等等）

2. 构造器名要和类名相同。

3. 构造器没有返回值。

4. 构造器是完成对象的初始化，不是创建对象。

5. 在创建对象时，系统自动调用该类的构造方法。

6. 如果程序员没有定义构造方法，系统会自动给类生成一个默认无参构造方法（也叫默认构造方法）比如Person（）{}，使用javap反指令反编译看看。

class Person {}

平常创建对象时，进行的 Person p=new Person（）；

这个小括号其实就是运行了默认的构造器。

反编译工具 javap

在cmd命令框里面运行

7. 一旦定义了自己的构造器，默认的构造器就被覆盖了，就不能使用默认的无参构造器，除非显式的重新定义一下，例如：Person（）{}

对象创建的基本流程

public static void main(String[] args){class b{int age;String name;public b(int a,String b){age=a;name=b;}}b B=new b(18,"mike");  
}

在第10行中的代码，首先执行的是创建一个新对象，这个对象并不是B，这个对象是指向B的地址，即会在栈中创建一个地址用来存放值，当没有在b（）中输入时，地址中的值为默认值，为null和0。在输入具体值后，会对默认值进行覆盖，至此，一个对象的创建便完成了。对象的实质是在栈中开辟的空间

this关键字

什么是this？

我们用一个案例来说明

public static void main(String[] args){class b{int age;String name;public b(int age,String name){age=age;name=name;}}
}

这里的形参为了方便我们看，我将它改为了属性名，但是这里存在一个问题，根据作用域的特点，这个方法中的name根据就近原则并不是属性名，而是形参，从这点来看，name=name和age=age就没有任何作用，这时候就引出了this关键字，这个关键字可以解决这个问题。代码实现如下

public static void main(String[] args){class b{int age;String name;public b(int age,String name){this.age=age;this.name=name;}}

这里的this就代指此处调用b（）方法的对象，如果对象w调用b（）方法，那么此时的this就代表w，实质上是w.name=name。

深入理解

对于内存存储的理解，在创建这个对象时，this作为隐藏属性存在其堆中，当使用this这个属性时，this会指向方法区中的一块地方，这个地方叫常量池，常量池中存在着对象的地址，使得this可以代替对象进行方法的调用，下面是图解

说白了，this会指向自己所在的对象空间，从而使方法得以使用。

使用细节

1. 访问成员方法的语法

class{public void t1(){System.out.print("调用了f1方法");}public oid t2(){System.out.print(" 调用了f2方法");f1();this.f1();}
}

其中如果想要在f2中调用f1方法，可以为第七行，也可以为第八行。

2. this还可以访问构造器，注意只能在构造器中使用（只能在构造器中访问另外一个构造器）。
   如果有this访问构造器这种语法，必须置于程序的第一行去执行。

   A e=new A();
   class A{public A(){this("jake",100);System.out.print("使用了public A（）构造器");}public A(String name,int age){System.out.print("使用了public A(String name,int age)构造器");}
   }
   

   程序中创建了a对象，使用了无参构造器，然后在无参构造器中访问了第二个构造器，进行访问。

   3. this不能在类定义的外部使用，只能在类中使用。

   练习

   定义Person类，里面有name，age属性，并提供compareTo比较方法，用于判断是否和另外一个人相等，提供测试类TestPerson用于测试，名字和年龄完全一样，就返回true，否则返回false。

   public class thiS {public static void main(String[] args) {class Person{String name;int age;public boolean compeTo(Person a,Person b){if(a.age==b.age&&a.name==b.name){return true;}else return false;}}}
   }

   这是不使用this关键字的程序，下面我使用this关键字来写一段。

   public class thiS {public static void main(String[] args) {class Person{String name;int age;public Person(String name,int age){this.name=name;this.age=age;}public boolean compareTo(Person p){return this.age==p.age&&this.name==p.name;}}Person p=new Person("mike",17);Person k=new Person("mike",17);System.out.println(p.compareTo(k));}
   }
   

Java中级编程

包

包的三大作用

1. 区分相同名字的类
2. 当类很多时，可以很好的管理类
3. 控制访问范围

包的基本语法

package com.hspedu;

说明：

1. package关键字，表示打包。
2. com. hspedu 表示包的名称

包的命名

命名规则：只能包含数字，字母，下划线，小圆点，不能是关键字或保留字。

命名规范：一般是小写字母加小圆点eg：com.oa.model这种

常用的包

java.lang* 基本包，不需要引用，直接使用

java.utrl.* util包，系统提供的工具包，工具类，比如使用scanner

java.net.* 网络包，做网络开发

java.awt.* 做java的界面开发，GUI

导入包

import java.utrl.Scanner
import java.utrl.*

第一种是导入这个包里面的的scanner方法

第二种是直接导入这个包

在编程过程中，推荐使用第二种方法。

使用细节和注意事项

1. package的作用是声明当前类所在的包，xvyaofangzaiclass的最上面，一个类中最多只能有一个package
2. import指令位置放在package的下面，在类定义的前面，可以有多句，而且没有顺序要求。

访问修饰符

基本介绍

java提供四种访问控制修饰符号，用于控制方法和成员变量，属性的访问权限。

1. 公开级别：使用public修饰，对外公开。
2. 受保护级别：用protected修饰，对子类和同一个包中的类公开。
3. 默认级别：没有修饰符，向同一个包的类公开。
4. 私有级别：用private修饰，只有类本身可以访问，不对外界公开。

注意事项

1. 修饰符可以用来修饰类中的属性，成员方法以及类。
2. 只有默认的和public才能修饰类，并且遵守以上的访问权限的特点。

封装（encapsulation）

就是把抽象出来的数据和对数据的操作封装在一起，数据被保护在内部，程序的其他部分只有通过被授权的操作方法，才能对数据进行操作。

好处

1. 隐藏实现的细节。
2. 可以对数据进行验证，保证安全合理。

封装实现的步骤

1. 属性私有化，让外部不能修改属性。
2. 提供一个public方法，用于对属性判断并赋值。
3. 提供一个公共的get方法，用于获取属性的值。

快速入门案例

设计一个小程序，不能随便查看别人年龄，工资等隐私。并对设置的年龄进行合理的验证，年龄合理就设置，否则给默认年龄，年龄介于1~~~~~100，姓名为2-6个字符

package test.encapsulation;
public class enca {public static void main(String[] args) {person a=new person();a.setName("m");String b=a.getName();System.out.println(b);}
}
class  person {String name;private int age;public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}
}

这样写get方法和set方法太慢了

我们可以使用快捷键来写alt+ins来找到get和out方法来完成。

这个程序中的age是私有类别，无法访问，极大的保护了用户的隐私。但是如果我是用一个构造器来破解他呢，即为在类中构建一个构造器来修改对象的属性，面对这种情况下的解决方法是，我们可以将这些get和set方法写在构造器当中，就可以实现保护的功能。

比如这样就会失效

package test.encapsulation;
public class enca {public static void main(String[] args) {person smith = new person("smith", 5);String b=smith.getName();System.out.println(b);}
}
class  person {String name;private int age;public person() {}public person(String name, int age) {this.name = name;this.age = age;}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}
}

继承

继承的含义以及为什么需要继承的存在

在写程序时，如果有两个类，比如说小学生和大学生，这两个类当中有许多属性和方法都是相同的，重复写会显得繁琐，这时候就可以使用继承，来使得程序简化。

当多个类中存在相同的属性和方法时，可以从这些类中抽象出父类，只需要通过extends来声明继承父类即可。

基本语法

class 子类 extends 父类{}

1. 子类会自动拥有父类定义的属性和方法
2. 父类又叫超类，基类。
3. 子类又叫派生类。

快速入门案例

学生考试案例，大学生和小学生有姓名，考试成绩，考试内容三个属性，使用继承来简化代码。

package test.encapsulation;public class student {public static void main(String[] args) {DAStuednt daStuednt = new DAStuednt();daStuednt.name="mike";daStuednt.chanegji=80;XIAOStuednt xiaoStuednt = new XIAOStuednt();xiaoStuednt.name="johb";xiaoStuednt.chanegji=50;daStuednt.Infor();xiaoStuednt.Infor();}
}
class Student{String name;double chanegji;String kemu;public void Infor(){System.out.println("mame="+name+"chanegji"+chanegji+"kemu"+kemu);}
}
class DAStuednt extends Student{String kemu="gao shu";}
class XIAOStuednt extends Student{String kemu="shu xue";
}

好处

1. 代码的复用性提高了
2. 代码的扩展性和维护姓提高了

细节深入

1. 子类继承了父类所有的方法和属性，但是私有属性和方法不能在子类中直接访问，要通过公共的方法去访问。
   比如一个父类中的name属性为私有属性，我们可以在父类中用一个getname的方法返回name的值，通过调用父类的getname方法从而使子类可以使用父类的name属性。相当于一个中转站。

2. 子类必须调用父类的构造器，完成父类的初始化。
   当创造子类对象时，子类的无参构造器被调用，父类同时也被调用，并且先调用父类的无参构造器，后调用父类的无参构造器。
   因为这其中隐藏了一个super（）方法。

   eg：public class sub extends base{public sub(){super();………………}}
   

   这个super（）方法就是默认的。

3. 当创建子类对象时，不管使用子类的哪个构造器，默认情况下总会去调用父类的无参构造器，如果父类没有提供无参构造器，则必须在子类的构造器中使用super去指定使用父类的哪个无参构造器完成对父类的初始化工作，否则，编译不会通过。
   下面我用代码帮助来理解

    public class base{public base(String name) {}}
   public class sub extends base{public sub(){super("mike");}
   }
   

   就是必须在子类构造器中用super方法指定父类构造器，super括号里面写父类构造器的参数。

4. 如果希望去指定调用父类的某个构造器，则显示的调用一下。
   就是使用super来指定。

5. super在使用时，需要放在构造器的第一行。

6. super和this都只能放在构造器的第一行，因此这个两个方法不能共存在一个构造器内。

7. 使用cutle +h 可以看到所有类的继承关系。

8. 父类构造器的调用不限于直接父类！将一直往上追溯到顶级父类。

9. java时单继承机制，即为a不能继承b，再继承c。

10. 不能滥用继承，子类和父类必须满足逻辑关系。

继承的本质

class GrandPa{String name= "大头爷爷";String hobby="";
}
class Father extends GrandPa{String name="大头爸爸";int age=39;
}
class Son extends Father{String name="大头儿子";
}
Son.son=new Son();

下面我提出三给个问题：

1. son.name=？
2. son.age=？
3. son.hobby=？

我用内存分配来加以理解，代码由创建son对象来开始，对象创建后，会在方法区开辟空间，son的父类为father ，father的父类为grandpa，grandpa没有父类，因此方法区会先开辟grandpa的空间接下来是father最后是son。在堆中开始分配常量空间，会先为grandpa类开辟一个空间来储存常量一个是name，一个是hobby，接下来为father开辟空间进行常量分配，并会不进行覆盖或者冲突。

如果son .属性 这个属性没有在son中定义，就会到son的上一级去找直至找到，但是如果son有这个属性，则会直接输出。如果是父类的私有属性，则不能访问，会报错。如果父类的age是私有的，爷爷类也有age，他不会去输出爷爷的age，而是报错，因为father类的age是私有的，会直接报错，并不会去grandfather查找。

例题

编写Computer类，包含CPU，内存，硬盘等属性，getDetails方法用于返回Computer的详细信息。

编写PC类，继承Computer类，添加特有属性“品牌brand”

编写NotePad子类，继承Computer类，并添加特有属性“演示color”

编写Test类，在main方法中创建PC和NotePad对象，分别给对象中特有的属性赋值，以及从Computer类继承的属性赋值，并使用方法打印输出信息。

这里我用PC类作为例子。

super ()方法

基本介绍

super代表父类的引用，用于访问父类的属性，方法，构造器

基本语法

1. 访问父类的属性，但不能访问父类的private属性
   super.属性
2. 访问父类的方法，不能访问父类的private方法
   super.方法名（参数列表）
3. 访问父类的构造器
   super（参数列表）注意这句只能放在构造器的第一句，只能出现一句。

super给编程带来的便利（细节）

1. 调用父类构造器的好处（分工明确，父类属性由父类初始化，子类的属性由子类初始化）

2. 当子类中有和父类的属性或方法重名时，为了访问父类的成员属性，必须通过super。如果没有重名，使用super，this，直接访问是一样的效果。
   eg：

   class A{public void say(){System.out.println("A say~~")}
   }
   class B extends A{public void test(){say();this.say();super.say();}
   }
   

   第8 9 10 行都可以调用想要的方法，但是如果有重名的时候出现，他会直接调用本类的，因为在查找方法时，会先找本类，如果没有再去找父类的，当重名情况出现时就得使用super关键字了。this关键字此时是指代本类的，加不加都一样。

   super.say()是直接找父类的，跳过了找本类的这一步。接下来的步骤和找本类的一样进行。

3. super的访问不限于直接父类，如果爷爷类和本类中有同名的成员，也可以使用super去访问爷爷类的成员，如果多个基类中都有同名的成员，使用super访问遵循就近原则。

方法重写/覆盖（override）

基本介绍

方法覆盖就是子类有一个方法，和父类的某个方法的名称，返回类型，参数一样，那么我们说子类的这个方法覆盖了父类的那个方法

我以一段代码加以理解

class A{public void say(){System.out.println("A")}
}
calss B extends A{public void say(){System.out.println("B");}
}

这里的say方法就构成了方法重写

注意事项

1. 子类方法的参数，方法名称，要和父类方法的参数，方法名称完全一样

2. 子类方法的返回类型和父类方法返回类型一样，或者是父类返回类型，是子类返回类型的父类。

   ![微信截图_20230529142555](微信截图_20230529142555.png)public Object getIfor()
   public String getInfor()
   

   这里的object类型是string的子类，因此可以正常运行。

3. 子类方法不能缩小父类方法访问的权限。
   即为必须遵守public prote 空private的顺序。

   void say()
   private void say()
   

   第一行的访问权限大于第二行的访问权限，所以第一行可以成为第二行的父类，但是第二行不能成为第一行的父类。

练习

编写一个person类，包括属性name age 构造器，方法say（返回自我介绍的字符串）

编写一个student类，继承person类，增加id，score的属性，以及构造器，定义say（）方法返回自我介绍的信息。

在main方法中分别创建person和student对象，调用say方法输出自我介绍。

多态

为何提出多态

我用一个案例来来说明，编写一个程序，Master中有一个feed方法，可以完成主人给动物喂食的信息，Master主人类 Food食物类（fish鱼肉类，Bone骨头类，Rice米饭类）Animal动物类（Cat猫类 Dog狗类 Pig猪类）

当养的动物开始增多时，我们会发现main方法的feed方法会越写越多，这样的情况就需要多态出马来解决了。

基本介绍

方法或对象有多种形态，是面向对象的第三大特征，多态是建立在封装和继承的基础之上的

具体体现

1. 方法的多态，重写和重载就体现出了多态，一个对象通过改变他的形参列表，可以去改变调用的方法。方法形成了重载，具有多种不同的形态。

2. 对象的多态

   • 一个对象的编译对象和运行类型可以不一致。

   • 编译类型在定义对象时，就确定了，不能改变。

   • 运行类型是可以变化的。

   • 编译类型看定义时=的左边，运行类型看=的右边。

     class Animal{}
     class Dog extends Animal{}
     Animal animal = new Dog();
     

     注意看第七行，animal的编译类型时Animal但是他的运行类型是Dog。

     如果我在第七行后写上一句

     animal=new Cat();
     

     此时的运行类型就是Cat，对象的类型进行了改变。这就被称为**对象的多态**。

案例

以动物喂食为案例，对上面的代码进行优化

只需要修改第一张图片即可

Animal可以指向Animal的所有子类对象，Food可以指向Food的所以子类对象。

注意事项和细节讨论

编译javac 运行java

1. 前提条件：两个包或者类有着继承关系。

2. 多态的向上转型

• 本质：父类的引用指向了子类的对象，比如上面的animal指向了dog
• 语法：父类类型 引用名 = new 子类类型（）
• 特点

  • 编译类型看左边，运行类型看右边

  • 可以调用父类中的所有成员。（须遵守访问权限）

  • 不能调用子类中的特有成员。

  • 最终运行效果看子类的具体实现。

    即调用方法时，从子类开始找，没有了找父类。

3. 多态的向下转型

• 语法：子类类型 引用名 =（子类类型）父类引用；

• 只能强转父类的引用，不能强转父类的对象。

• 要求父类的引用必须指向是当前目标类型的对象。

• 可以调用子类类型的所有成员。

• 例子

  希望调用cat的catchmouse方法class Cat extends Animal{public void catchmouse(){System.out.println("get mouse");}}Cat cat=(Cat) animal;cat.catchmouse();
  

  Cat cat=(cat) animal;
  Dog dog=(Dog) animal;
  

  第二个代码块的第二行会出错（类错误），因animal是指向猫的对象。第二行将其强制转换为狗，出现了错误。

4. 属性没有重写之说，属性的值看编译类型。

   class Base{int count = 10;
   }
   class Sub extends Base{int count =20;
   }
   Base base =new Sub();
   base.count;
   

   这里的第八行的值是10，因为他的编译类型为base，会直接从base中的对象开始查找，找i到后直接输出。
   左边是编译类型

5. instanceOf 比较操作符
   用于判断对象的类型是否为XXX类型或者XXX类型的子类。

   class A{}
   class extends B{}
   class c{}
   B b=new B();
   C c=new C();
   C a=new b();
   System.out.println(b instanceof A);
   System.out.println(c instanceof A);
   System.out.println(a instanceof A);
   

   第一个返回true，第二个返回false,第三个返回true。综合第一个和第三个来看，这个方法比较的是运行类型，而不是编译类型。

练习

写出下面代码的输出结果。

class Base{int count =10;public void display(){System.out.println(this.count);}
}
class Sub extends Base{int count=20;public void display(){System.out.println(this.count);}
}
Sub s=new Sub();
System.out.println(s.count);
s.display();
Base b=s;
System.out.println(b==s);
System.out.println(b.count);
b.display;

分析

​ 首先第十三行创建了Sub的对象s，所以s所使用的属性都是Sub中的。

​ 然后将b指向了s，实现了向上转型，b和s共同指向同一个地址，即为Sub的地址。

​ 此时的b的编译类型为Base 运行类型为Sub。

答案

​ 20 20 true 10 20

这个10和20，是因为程序运行过程中，属性看编译类型，方法看运行类型。

应用

多态数组

数组的定义类型为父类类型，里面实际保存的类型为子类类型

实际应用

现有一个继承结构，Student和Teacher为Person的子类。现要求创建一个Person对象和两个Teacher对象，统一放在数组中，并且调用每个对象的say方法。

多态参数

方法定义的形参为父类类型，实参类型允许为子类类型

应用实例

定义员工类Employee，包含姓名和月工资，以及计算年工资getAnnual的方法，普通员工和经理继承了员工，经理类多了奖金bonus属性和管理manage方法，普通员工多了work方法，普通员工和经理类要求重写agtAnnual方法

最后text类中的getmoney方法中的参数就为多态参数，可以改变运行参数从而调用想要的方法。

Java的动态绑定机制

特点

1. 当调用对象方法的时候，该方法会和该对象的内存地址/与运行类型绑定。
2. 当调用对象属性时，没有动态绑定机制，哪里声明，那里使用。

实例

class A{public int i=10;public int sum(){return get()+10;}public int sum1(){return i+10;}public int get1(){return i;}
}
class B extends A{public int i=20;public int sum(){return i+20;}public int get(){return i;}public int sum1(){return i+10;}
}
main方法中
A a=new B();
System.out.println(a.sum());
System.out.println(a.sum1());

首先将a指向B类，实现向上转型，此时a的运行类型为B，编译类型为A。第一个输出语句中调用方法，看运行类型，所以输出的是40，第二个同理输出30。

但是我现在如果将B类中的sum和sum1方法注销，这两句的输出又是什么呢？
将B类的方法注销后，找不到方法，会去父类A查找，此时调用了A的sum方法，sum方法中又有get方法，那么此时到底是调用A中的方法还是B的方法呢？
根据Java的动态绑定机制，当调用对象方法的时候，该方法会和该对象的内存地址/与运行类型绑定，此时对象的运行类型为B，会和B类的get方法绑定，因此调用了B类中的get方法，输出了30。

运行sum1方法时，因为B被注销，无法查找到，会去A进行查找，调用a的sum1方法，此时的i根据Java的动态绑定机制第二条当调用对象属性时，没有动态绑定机制，哪里声明，那里使用。这里的就是A中的i，所以输出了20。

Object类详解

Object类再java的lang包中，是自动引用的，程序中的所有对象都可以调用这个类中的方法

equals方法

equals和==的对比

1. ==：既可以判断基本类型，又可以判断引用类型
   • 如果判断基本类型，判断是值是否相等。
   • 如果判断引用类型，判断的是地址是否相等，即为判断是不是同一个对象。

Java中的方法

Scanner方法

• 导入该方法库

  • import Java.util.Scanner;

• 新建一个对象，来接收这个方法

  • 使用到new（）

  • Scanner A=new Scanner(System.in)

• 看需要从键盘输入哪些类型，来确定下面的方法，我用int为例子

  • int a=A.nextInt();

• 接下来从键盘输入即可。

• 字符串输入时使用A.next（）方法

随机方法(Math.random)

• math库中的random方法，这个方法可以返回0.0到1.0之间的double类型数字。

• eg：如果我想随机0~100之间的随机数字

  • int a=Math.random()*100+1

  • 写出上面的代码即可

标签的使用（label）通常和break和continue一起使用。

• 标签的名称由程序员定义。
• 标签在实际开发中尽量不要使用。
• break后的标签是什么，就退回到那个标签后的循环体。
• 如果break后面没有指定，就退出到最近的循环体。

string中的equals方法（比较字符串是否相同）

• 用于将字符串进行比较，返回boll值。

• 比如

  - String name="mike";System.out.print(name.equals("nike"));
  - 
  

• 这个程序执行完后会返回一个false值。

计算数组长度的方法(length方法)

使用数组名称.length可以得到数组的长度

hashCode()方法【可以查询地址】

使用这个该方法，可以返回一个哈希码值，这个哈希码是根据该对象的地址进行变化得出的，可以变相的进行地址的比较。

排序

分类

• 内部排序
  • 指将需要处理的所有数据都加载到内部储存器进行排序，包括交换式排序法，选择式排序法和插入式排序法。
• 外部排序
  • 指数据量过大，无法全部加载到内存中，需要借助外部储存进行排序，包括合并排序法和直接合并排序法。

冒泡排序

• 进行多轮比较，将大数放到小数的后面。 （进行数字数目减一次）

  • 第一轮比较会将最大的数字移动到最后一位

  • 第二轮比较会将第二大的数组移动到倒数第二位，在比较时，因为第一大的数已经确定下来了，所以没有和最后一个比较的必要

  • 综上所述，比较的轮数是数字数目总和减一

public class MaoPao {public static void main(String[] args) {int a[] = {5, 8, 4, 9, 55, 47, 1, 0};for (int j = 0; j < a.length - 1; j++) {for (int i = 0; i < a.length - 1- j; i++) {int temp = 0;if (a[i] > a[i + 1]) {temp = a[i + 1];a[i + 1] = a[i];a[i] = temp;}}}for (int s = 0; s < a.length; s++) {System.out.print(a[s]+" ");}}
}

，看运行类型，所以输出的是40，第二个同理输出30。

但是我现在如果将B类中的sum和sum1方法注销，这两句的输出又是什么呢？
将B类的方法注销后，找不到方法，会去父类A查找，此时调用了A的sum方法，sum方法中又有get方法，那么此时到底是调用A中的方法还是B的方法呢？
根据Java的动态绑定机制，当调用对象方法的时候，该方法会和该对象的内存地址/与运行类型绑定，此时对象的运行类型为B，会和B类的get方法绑定，因此调用了B类中的get方法，输出了30。

运行sum1方法时，因为B被注销，无法查找到，会去A进行查找，调用a的sum1方法，此时的i根据Java的动态绑定机制第二条当调用对象属性时，没有动态绑定机制，哪里声明，那里使用。这里的就是A中的i，所以输出了20。

Object类详解

Object类再java的lang包中，是自动引用的，程序中的所有对象都可以调用这个类中的方法

equals方法

equals和==的对比

1. ==：既可以判断基本类型，又可以判断引用类型
   • 如果判断基本类型，判断是值是否相等。
   • 如果判断引用类型，判断的是地址是否相等，即为判断是不是同一个对象。

Java中的方法

Scanner方法

• 导入该方法库

  • import Java.util.Scanner;

• 新建一个对象，来接收这个方法

  • 使用到new（）

  • Scanner A=new Scanner(System.in)

• 看需要从键盘输入哪些类型，来确定下面的方法，我用int为例子

  • int a=A.nextInt();

• 接下来从键盘输入即可。

• 字符串输入时使用A.next（）方法

随机方法(Math.random)

• math库中的random方法，这个方法可以返回0.0到1.0之间的double类型数字。

• eg：如果我想随机0~100之间的随机数字

  • int a=Math.random()*100+1

  • 写出上面的代码即可

标签的使用（label）通常和break和continue一起使用。

• 标签的名称由程序员定义。
• 标签在实际开发中尽量不要使用。
• break后的标签是什么，就退回到那个标签后的循环体。
• 如果break后面没有指定，就退出到最近的循环体。

string中的equals方法（比较字符串是否相同）

• 用于将字符串进行比较，返回boll值。

• 比如

  - String name="mike";System.out.print(name.equals("nike"));
  - 
  

• 这个程序执行完后会返回一个false值。

计算数组长度的方法(length方法)

使用数组名称.length可以得到数组的长度

hashCode()方法【可以查询地址】

使用这个该方法，可以返回一个哈希码值，这个哈希码是根据该对象的地址进行变化得出的，可以变相的进行地址的比较。

排序

分类

• 内部排序
  • 指将需要处理的所有数据都加载到内部储存器进行排序，包括交换式排序法，选择式排序法和插入式排序法。
• 外部排序
  • 指数据量过大，无法全部加载到内存中，需要借助外部储存进行排序，包括合并排序法和直接合并排序法。

冒泡排序

• 进行多轮比较，将大数放到小数的后面。 （进行数字数目减一次）

  • 第一轮比较会将最大的数字移动到最后一位

  • 第二轮比较会将第二大的数组移动到倒数第二位，在比较时，因为第一大的数已经确定下来了，所以没有和最后一个比较的必要

  • 综上所述，比较的轮数是数字数目总和减一

public class MaoPao {public static void main(String[] args) {int a[] = {5, 8, 4, 9, 55, 47, 1, 0};for (int j = 0; j < a.length - 1; j++) {for (int i = 0; i < a.length - 1- j; i++) {int temp = 0;if (a[i] > a[i + 1]) {temp = a[i + 1];a[i + 1] = a[i];a[i] = temp;}}}for (int s = 0; s < a.length; s++) {System.out.print(a[s]+" ");}}
}
## 面向对象编程高级部分### 类变量和类方法#### 类变量##### 解决问题（快速入门）现在由一群小孩玩游戏，不断有新的小孩加入，问现在有多少小孩在玩游戏。如果使用现有的技术来解决这个问题，我们可以使用count++来获得值，代码实现如下：~~~java
package static_;public class Children_game {public static void main(String[] args) {int count=0;children child1=new children("mike");count ++;children child2=new children("jhon");count ++;children child3=new children("zhu");count ++;System.out.println("the number is "+count);}public static class children{private String name;public children(String name) {this.name = name;}public String getName() {return name;}public void setName(String name) {this.name = name;}}
}

注意：当写children方法时，要给前面加上static关键字，因为main是一个static方法，class Clerk是一个非静态的内部类，只能被该类的非静态方法访问。否则会报错。

静态方法只能调用静态类和方法

问题分析：

1. count是一个独立于对象和类的变量，很尴尬。
2. 以后我们访问count很麻烦，没有使用到OOP。
3. 因此我们引入 类变量、静态变量。

想法:我们设计count时，可以让在这个对象被创建时，就加一，并且count是所有对象共享的。

使用类变量进行代码实现

package static_;public class childrengame {public static void main(String[] args) {children c1=new children("5");children c2=new children("2");children c3=new children("6");System.out.println(c1.count);System.out.println(c2.count);System.out.println(c3.count);}public static class children{private String name;public static int count =0;public children(String name) {this.name = name;count ++;}public String getName() {return name;}public void setName(String name) {this.name = name;}public static int getCount() {return count;}public static void setCount(int count) {children.count = count;}}
}

这里的输出全为3，因为所有的对象都使用这一个变量。是共享的。

定义以及概念

概念：

类变量也叫静态变量和静态属性，是该类所有对象共享的变量，任何一个对象去访问时，取到的都是相同的值。

如何定义

访问修饰符 static 数据类型 变量名；

static 访问修饰符 数据类型 变量名；

如何访问

类名.类变量名

对象名.类变量名

使用细节和注意事项

什么时候需要使用类变量

在当需要让某个类的所有对象都共享一个变量时，就可以考虑使用类变量。

类变量和实例变量的区别

类变量是该类的所有对象共享的，而实例变量是每个对象独享的。

细节和注意

1. 加上static称为类变量或者静态变量否则称为实例变量/普通变量/非静态变量
2. 实例变量不能通过类名.类变量名的方式访问。
3. 类变量在类加载时就会初始化，几时没有创建对象，在类加载时就可以使用类变量了
4. 类变量的生命周期是随着类进行变化的。

类方法

介绍

类方法也叫静态方法

形式：

​ 访问修饰符 static 数据返回类型 方法名(){}

​ static 访问修饰符 数据返回类型 方法名(){}

调用方法：

​ 类名.类方法名 或者 对象名.类方法名

应用案例

统计学费总和，使用代码实现

package static_;
public class totla_money {public static void main(String[] args) {student s1=new student("make");student.payfee(45);student tom = new student("tom");student.payfee(50);student.showFee();}
}
class student {private String name;private static double Money = 0;public student(String name) {this.name = name;}public static double payfee(double Money) {student.Money += Money;return Money;}public static void showFee() {System.out.println("tolal is "+student.payfee(student.Money));}
}

使用场景

当方法中不涉及任何和对象相关的成员时，可以使用类方法进行开发，提高代码开发效率。

使用细节

1. 类方法和普通方法都是随着类的加载而加载，将结构信息储存在方法区。
2. 类方法中没有this的参数，普通方法中含有this的参数，因为类方法是所有的对象都可以调用的方法，this是单个的对象调用的。
3. 类方法可以通过类名调用，也可以通过对象名调用。
4. 类方法中不允许使用和对象有关的关键字
5. 类方法中，只能访问静态变量或者静态方法
6. 普通成员方法，即可以访问非静态成员也可以访问静态成员

深入理解main方法

main方法的语法

1. main方法是由java虚拟机调用的，所以只能是public
2. 调用main方法时不必创建对象，所以该方法必须是static
3. 该方法接收String类型的数组参数，该数组中保存执行java命令传递给所执行的类的参数，接收参数
4. args数组就是接收参数的

特别提示

1. 在main方法中，我们可以直接调用main方法所在类的静态方法或者属性，但是不能直接访问该类中的非静态成员，必须创建该类的一个实例对象后，才能通过这个对象去访问类中的非静态成员。
   举例说明

   package mian;
   public class main01 {private static String name ="make";static void pp(){System.out.println("hi");}public void pp1(){System.out.println("hello");}public static void main(String[] args) {System.out.println("name is "+name);pp();main01 main01 = new main01();main01.pp1();}
   }
   

   其中的name和pp()都是静态成员，main方法是静态方法，所以可以调用name和pp()。但是pp()1不是静态方法，所以得先建立一个对象才能对他进行调用。

案例演示

package mian;
public class CommandPara {public static void main(String[] args) {for(int i=0;i< args.length;i++){System.out.println("args["+i+"]="+args[i]);}}
}

在idle中这样给args传入数据

最后就会成功输出

代码块

基本介绍

代码块又称为初始化块，属于类中成员，类似于类方法，将逻辑语句封装在方法体中，通过{}包装起来。

但是和方法不同，没有方法名，没有返回，没有参数，只有方法体，而且不用通过对象或类显式调用，而是加载类时，或创建对象时隐式调用。

基本语法

【修饰符】{代码
};

注意：

1. 修饰符可选，要写只能写static
2. 代码块分为两类，使用static修饰的叫静态代码块，没有static修饰的叫普通代码块
3. 逻辑语句可为任何逻辑语句比如输出，输入，循环，判断，方法调用等
4. ;可写可不写

应用场景和案例演示

应用场景：

1. 相当于另外一种形式的构造器，可以做初始化的操作，如果多个构造器中都又重复的语句，可以抽取到代码块中，提高代码的重用性。

案例演示：

package mian;public class CodeBlock {public static void main(String[] args) {Movie movie = new Movie("mike",556);System.out.println("is ok");}}
class Movie{{System.out.println("start moive");System.out.println("the moive is over");}private String name;private double price;private String director;public Movie(String name) {this.name = name;}public Movie(String name, double price) {this.name = name;this.price = price;}public Movie(String name, double price, String director) {this.name = name;this.price = price;this.director = director;}
}

这里中的电影开始和结束是必须输出的语句，所以把他提取出来放入代码块，当创建这个对象时，代码块会自动运行，输出中的moive start…………是在is ok之前的。所以当程序运行时，代码块先进行运行。

注意事项

1. static代码块也叫静态代码块，作用就是对类进行初始化，而且它随着类的加载而执行，并且之后执行一次，如果是普通代码块，每创建一个对象，就只执行一次。

2. 类什么时候加载

• 创建对象实例的时候
• 创建子类对象实例的时候，父类也会被加载
• 使用类的静态成员时

3. 普通的代码块，在创建对象实例的时候，会被隐式的调用，创建一次调用一次。
   如果是使用类的静态成员时，普通代码块并不会执行。

4. 当创建一个对象在一个类当中，调用顺序

调用静态代码块和静态属性初始化（注意：静态代码块和静态属性初始化调用的优先级一样，如果有多个静态代码块和静态变量初始化，则按照他们定义的顺序调用）

调用普通代码块和普通属性初始化（注意：普通代码块和普通属性初始化调用的优先级一样，如果有多个普通代码块和普通变量初始化，则按照他们定义的顺序调用）

5. 构造器前面其实隐藏了一个super()和调用普通代码块，新写一个类演示说明（如下），静态相关的代码块，属性初始化，在类加载时就执行完毕，因此是优先于构造器和普通代码块执行的。

class A(){public A(){super();System.out.println("ok");}
}

这个问题可以在代码块中使用this来体现，this的任何属性都为空，因此this是在构造器之前运行的

运行的顺序：第一步 进行父类的普通代码块运行，父类再找他的父类，如果运行完了，进入第二步，运行自己的代码块，最后进行第三步运行自己类中的程序。

6. 创建一个子类对象时（继承关系），他们的静态代码块，静态属性初始化，普通代码块，普通属性初始化，构造方法调用顺序如下：

• 父类的静态代码块和静态属性（优先级一样，按照定义顺序执行）
• 子类的静态代码块和静态属性（优先级一样，按照定义顺序执行）
• 父类的普通代码块和普通属性初始化（优先级一样，按照定义顺序执行）
• 父类的构造方法
• 子类的普通代码块和普通属性初始化（优先级一样，按定义顺序执行）
• 子类的构造方法

创建演示

package mian;public class CodeBlock001 {public static void main(String[] args) {new BBB();}}
class AAA{private static int n1 =getValue01();static{System.out.println("A的一个静态代码块。。。");}{System.out.println("A的一个普通代码块。。。");}public int n2=getVlaue02();public static int getValue01(){System.out.println("getValue01");return 10;}public int getVlaue02(){System.out.println("getValue02");return 10;}public void A(){System.out.println("A的构造器");}
}
class BBB extends AAA {private static int n3=getValue03();static {System.out.println("这是b的一个静态代码块。。。");}{System.out.println("这是b的一个普通代码块。。。");}public static int getValue03(){System.out.println("getValue03");return 10;}public void B(){System.out.println("这是b的构造器");}
}

这是输出结果

​ getValue01
​ A的一个静态代码块。。。
​ getValue03
​ 这是b的一个静态代码块。。。
​ A的一个普通代码块。。。
​ getValue02
​ 这是b的一个普通代码块。。。

这体现出，先执行静态，再进行普通，顺序是先父类再子类。

设计模式

单例设计模式

什么是单例模式

所谓类的单例模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法

单例模式的方式

饿汉式

1. 构造器私有化

2. 在类的内部创建

3. 向外暴露一个静态的公共方法

4. 例子（代码实现）

   package mian;public class SingleTon1 {public static void main(String[] args) {GirlFriend xx= GirlFriend.getInstance();System.out.println(xx);}
   }
   class GirlFriend {private String name;private static GirlFriend gf = new GirlFriend("11");private GirlFriend(String name) {this.name = name;}public  static GirlFriend getInstance(){return gf;}@Overridepublic String toString() {return "GirlFriend{" +"name='" + name + '\'' +'}';}
   }

   我接下来解释这段代码，首先创建了私有的属性，然后创建了一个私有的对象，我们现在需要将这个对象传出去，所以有 public static GirlFriend getInstance()这个方法，因为只有静态方法可以调用静态属性，所以这里的方法是静态方法，接着getInstance是将对象实例化的方法，就是这个对象是抽象存在的，现在要调用其对象，就得将它实例化使用，接着返回出其实例化后的对象。这一步就是向外暴露一个静态的方法。

懒汉式

1. 构造器私有化

2. 类的内部创建对象

3. 向外暴露一个静态的公共方法

4. 代码实现

   package mian;public class SingleTon1 {public static void main(String[] args) {Cat  xixi =Cat.getInstance();System.out.println(xixi);}
   }
   class Cat{private String name;public Cat(String name) {this.name = name;}private static Cat cat;public static Cat getInstance(){if(cat==null){Cat xixi = new Cat("xixi");return xixi;}else{return cat;}}@Overridepublic String toString() {return "Cat{" +"name='" + name + '\'' +'}';}
   }
   

下面我来说明这个懒汉模式，懒汉模式是单例模式的一种，他是在调用这个方法的时候来创建对象的，并且这个对象仅仅创建一次，第二次调用的时候，依然返回第一次调用他时创建的对象。

区别

他们两个的区别在于：

1. 饿汉式是在类加载的时候就创建了对象，而懒汉式是在使用的时候才会创建。
2. 饿汉式不存在线程安全问题，但是懒汉式存在。
3. 饿汉式存在着浪费资源的可能，但是懒汉式不存在。

final关键字

应用场景

1. 当不希望类被继承的时候，可以使用final来修饰
2. 当不希望父类的某个方法被子类覆盖/重写的时候，就可以使用final关键字
3. 当不希望类的某个属性被修改，可以使用final修饰
4. 当不希望某个局部变了被修改，可以使用final修饰

注意事项和细节讨论

1. final修饰的属性又叫常量，一般用XX_XX_XXX来命名

2. final修饰的属性在定义的时候，必须要赋初值，并且以后不能修改，赋值可以如下位置之一

   • 定义的时候：public final double TAX_XRATE=0.08；
   • 在构造器当中
   • 在代码块当中

3. 如果final修饰的属性是静态的，则初始化的位置只能是：

   • 定义时
   • 在静态代码块，不能在构造器中赋值

4. final不能被继承，但是可以实例化对象

5. 如果类不是final类，但是含有finla方法，则该方法不能被重写，但是可以被继承

   final相当于c语言当中的conest

抽象类

应用场景

父类方法不确定的时候使用，考虑将这个方法变为抽象方法，所谓抽象方法就是没有实现的方法即为没有方法体，当一个类中存在抽象方法的时候，需要将这个类声明为abstract类，将来这个抽象类的作用是，他会被子类继承，由抽象子类实现这个抽象方法。

介绍

1. 使用abstract修饰一个类的时候，他就是抽象类
   访问修饰符 abstract 类名{

   }

2. 使用abstract关键字来修饰一个方法的时候，这个方法就是抽象方法
   访问修饰符 abstract 返回类型 方法名（参数列表）{

   }没有方法体

3. 抽象类的价值更多在于设计，是让设计者设计好后，让子类继承并且实现抽象类（）

4. 抽象类在框架和设计模式使用的比较多

细节

1. 抽象类不能被实例化

2. 抽象类可以不包含抽象方法。

3. 一旦含有抽象方法，这个类就必须声明为abstract。

4. abstract只能修饰类和方法，不能修饰其他和属性。

5. 抽象类可以有任意成员

6. 抽象方法不能有主题，即不能实现

7. 如果一个类继承了抽象类，则他必须实现抽象类的所有的抽象方法，除非他自己也声明成为抽象类。

8. 抽象方法不能使用private final static 来修饰

模板使用模式

需求

1. 有多个类，完成不同任务的job

2. 要求统计得到各自完成任务的时间

   ---

   我先使用最基本的方式来写

   package Abstract;public class A {public static void job(){long start =System.currentTimeMillis();int sum=0;for(int i=1;i<=800000;i++){sum =sum +i;}long end=System.currentTimeMillis();long oo=end-start;System.out.println(oo);}
   }
   package Abstract;public class B {public static void job(){long start =System.currentTimeMillis();int sum=0;for(int i=1;i<=80000000;i++){sum =sum +i;}long end=System.currentTimeMillis();long oo=end-start;System.out.println(oo);}
   }
   package Abstract;public class tex
   {public static void main(String[] args) {A aa = new A();aa.job();}
   }

   我们可以发现这两个类中存在相同的计算模式和程序，我们可以将它提炼出来形成一个模板，将它变成为抽象父类，让子类来实现自己想要的东西。

   package Abstract;abstract class Template {public abstract void code();public void caleTimes(){long a=System.currentTimeMillis();code();long b=System.currentTimeMillis();long c=b-a;System.out.println("耗费时间"+c);}
   }
   package Abstract;public class A extends Template {@Overridepublic void code() {int sum=0;for(int i=1;i<=80000000;i++){sum =sum +i;}}
   }
   package Abstract;public class B extends Template{@Overridepublic void code() {int sum=0;for(int i=1;i<=800000;i++){sum =sum +i;}}
   }package Abstract;public class tex
   {public static void main(String[] args) {A aa = new A();aa.caleTimes();B bb= new B();bb.caleTimes();}
   }

接口

基本介绍

接口就是给出一些没有实现的方法，封装到一起，到某个类将要使用的时候，再根据具体情况把这些情况写出来

语法：
interface 接口名{

​ 属性；

​ 方法；

}

class 类名 implements 接口{

​ 自己的属性；

​ 自己实现；

​ 必须实现的接口的抽象方法

}

小结：

1. 在jdk7.0前接口里的所有方法都没有方法体
2. jdk8.0后接口类可以有静态方法，默认方法，也就是接口中可以有方法的具体实现。

package interface111;public interface Interface01 {public int n1 =10;public void hi();//在接口中，抽象方法，可以省略abstract关键字default public void ok(){System.out.println("ok");}
}
package interface111;public interface Interface02 {public static void main(String[] args) {A a = new A();a.hi();a.ok();}
}
class A implements Interface01{@Overridepublic void hi() {System.out.println("is Interface02");}
}package interface111;public interface Interface02 {public static void main(String[] args) {A a = new A();a.hi();a.ok();}
}
class A implements Interface01{@Overridepublic void hi() {System.out.println("is Interface02");}
}

下面的这个A类，就使用了接口，接着将接口中的抽象方法实现，在进行对象实例化调用。

深入讨论

接口可以规范程序员的程序规范，使得项目有条不紊的开发。

注意事项和细节

1. 接口不能被实例化。
2. 接口中所有的方法是public方法，接口中的抽象可以不用abstract修饰。
3. 一个普通类实现接口，就必须将该接口的所有方法实现。
4. 抽象类实现接口，可以不适应实现接口的方法。
5. 快捷键：alt加enter，可以全选抽象方法进行实现，将光标停在implements上
6. 一个类可以同时实现多个接口，接口之间使用逗号隔开（但是继承只能继承一种父类）
7. 接口中的属性只能是final，而且是public static 的
   int n1 =10；====》final int n1=10；相互等价
8. 接口中属性的访问是，接口.属性名
9. 接口不能继承其他类型的类，但是可以继承其他的多个接口
   interface A extends B,C{}
10. 接口中的修饰符只能是public和默认。

接口的多态特性

1. 多态参数，既可以接受手机对象，也可以接受相机对象，实现了接口的参数多态

2. 多态数组

   package interface111;
   public interface Interface02 {public static void main(String[] args) {Usb usbs[]=new Usb[2];usbs[0]=new Phone();usbs[1]=new Camera();for (int i=0;i< usbs.length;i++){usbs[i].work();}}
   }
   interface Usb{void work();
   }class Phone implements Usb{public void cla(){System.out.println("yes");}@Overridepublic void work() {System.out.println("phone");cla();}};
   class Camera implements Usb{@Overridepublic void work() {System.out.println("camera");}
   };
   

3. 接口存在多态传递的现象
   比如说接口A继承了接口B，然后类C实现了接口A的对象实例，因为a是继承于b的，所以c实现的实例对象是要对b负责的，要完成b的抽象方法。

四种内部类

基本介绍

一个类的内部又完成嵌套了另一个类的结构，被嵌套的类称为内部类，嵌套其他类的类称之为外部类，使我们类的第五大成员，内部类的最大特点就是可以直接访问私有属性，并且可以提现类与类之间的包含关系

基本语法

class Outer{ //外部类

​ class Inner{ //内部类

​ }

}

class Other{ //外部其他类

}

分类

1. 定义在外部类局部位置上（比如方法内）：
   • 局部内部类（有类名）
   • 匿名内部类（没有类名）
2. 定义在外部类的成员位置上：
   • 成员内部类（没用static修饰）
   • 静态内部类（使用static修饰）

局部内部类

说明

1. 局部内部类是定义在外部类的局部位置上，比如方法中，并且有类名。
2. 不能添加访问修饰符，因为他的地位就是一个局部变量，局部变量是不能使用修饰符的，但是可以使用final修饰，因为局部变量可以使用final
3. 可以直接访问外部类的所有成员，包含私有的。
4. 作用域：仅仅在定义他的方法或代码块中。
5. 外部类——访问——->外部类的成员【访问方式：直接访问】
6. 外部类——访问——->局部内部类的成员.
   访问方式：创建对象，再访问（注意：必须在作用域内访问）
7. 外部其他类—–不能访问——>局部内部类的成员（因为局部内部类是一个局部变量）、
8. 如果外部类和局部内部类存在方法属性重名，默认遵循就近原则，如果想访问外部类的成员，则可以使用外部类名.this.成员去表示。

匿名内部类的使用

说明：匿名内部类是定义在外部类的局部位置，比如方法中，并且没有类名

1. 本质是类
2. 内部类
3. 该类没有名字
4. 同时还是一个对象

基本语法

new 类或接口（参数列表）{类体
};

案例（基于接口的）

package INeerclass;public class Anony {public static void main(String[] args) {Outer outer = new Outer();outer.method();A tiger=new A(){@Overridepublic void cry() {System.out.println("656565");}};tiger.cry();}
}
class Outer{private int i =10;public void method(){//基于接口的匿名内部类// 1.需求：想使用a接口，并且创建对象// 2.传统方式：写一个类，实现该接口，并且创建对象Tiger tiger = new Tiger();tiger.cry();//需求：tiger使用一次，后面不再使用//所以创建一个tiger类太浪费//解决方案：使用匿名内部类简化开发：}
}
interface A{public void cry();
}
class Father{String name;public Father(String name){this.name=name;}public void test(){}
}
class Tiger implements A{@Overridepublic void cry() {System.out.println("666666");}
}

这块tiger的编译类型是a，他的运行类型是这个匿名内部类

编译类型看定义时=的左边，运行类型看=的右边。

可以通过tiger.getClass();查看他的运行类型。

案例(基于类的)

package INeerclass;
public class Anony {public static void main(String[] args) {Father father=new Father("jack"){@Overridepublic void test() {System.out.println("888888");;}};father.test();System.out.println(father.getClass());}
}
class Father{String name;public Father(String name){this.name=name;}public void test(){System.out.println("7777");}
}

输出88888

匿名内部类重写了text方法，更加高效。

这个匿名类其实还是继承于原类的

使用场景

将匿名内部类当做实参传递

package INeerclass;public class wanda {public static void main(String[] args) {f1(new IAA() {@Overridepublic void show() {System.out.println("666");}});}public static void f1(IAA ia){ia.show();}
}
interface IAA{public void show();
}

这里首先写了一个接口，然后定义了一个方法，这个方法的形参是接口类型的，当调用这个方法的时候，直接创建一个新对象，这个对象即是接口也是匿名类，进行实现程序，简化代码。

题目：有一个铃声接口bell，里面有个ring方法，有一个手机类cellphone，有闹钟接口alarmclock，参数是bell类型，测试手机类的闹钟功能，打印666，再传入一个匿名内部类打印888

package INeerclass;public class CellPhone {public static void main(String[] args) {NoPhone noPhone = new NoPhone();noPhone.alarmclock(new Bell() {@Overridepublic void ring() {System.out.println("ring ring ring ...");}});noPhone.alarmclock(new Bell() {@Overridepublic void ring() {System.out.println("qichuangle");}});}
}class NoPhone{public void alarmclock(Bell bell){bell.ring();}
}
interface Bell{public void ring();
}

成员内部类

说明：将类写在类中，没有写在方法或者形参里，就是成员内部类

可以使用外部类的所有属性和方法

作用域：和外部其他成员相同，为整个类体

内部类访问外部类直接访问

外部类访问内部类先创建对象再访问

外部其他类使用内部类的三种方式

1. 使用外部类new一个内部类的对象

   class outer{class inner{}
   }
   psvm{outer O=new outer();outer.inner a =o.new inner();
   }
   

   相当于把new出的inner（）当做一个outer的成员

2. 在外部类中编写一个方法，返回一个内部类的实例。

遵循就近原则

可以通过外部类名.this.属性来访问外部类的所有成员

静态内部类

说明：将类写在类中，没有写在方法或者形参里，再用static修饰就是静态内部类

1. 可以访问外部类的所有静态成员，包含私有的，但不能直接访问非静态成员

2. 可以添加任意访问修饰符

3. 作用域是一整个类体

4. 内部类访问外部类直接访问

5. 外部类访问内部类先创建对象再访问

6. 外部其他类访问内部静态类

   • new一个外部类名.静态内部类名

   • 写一个方法，返回静态内部类的实例

7. 遵循就近原则

8. 如果想访问外部类的成员，直接外部类名.成员

枚举

介绍

案例引入

要求创建Season对象

package Chapt11.enum_;/*** @another SunHaoyu* @verson 1.0*/
public class enum01 {public static void main(String[] args) {Season season = new Season("spring", "warm");season.printt(season);}
}
class Season{private String name;private String desc;public Season(String name, String desc) {this.name = name;this.desc = desc;}public void printt(Season season){System.out.println(season.desc+"   and   "+season.name);}
}

这种设计方式，会使得任何人都可以给season类进行添加或者修改，会破坏这个类，但是对于季节来说，最多只有四个，是有限而且固定的，这种方式并不好。

那么我们现在希望使用另外一种方式来进行设计，此时便可以使用枚举类

说明

枚举是一种特殊的类，是一种常量的集合，里面只包含一组有限的特定的类。

自定义枚举类

package Chapt11.enum_;/*** @another SunHaoyu* @verson 1.0*/
public class enum01 {public static void main(String[] args) {}
}
class Season{private String name;private String desc;public static final Season Spring=new Season("Spring","warm");private Season(String name, String desc) {this.name = name;this.desc = desc;}public void printt(Season season){System.out.println(season.desc+"   and   "+season.name);}public String getName() {return name;}public String getDesc() {return desc;}}

分为三步完成：

1. 将构造器私有化，使得不能在外部创建对象
2. 将set方法删除，使得不能在外部更改内容
3. 在Season内部直接创建固定的对象，最好使用final+static共同修饰，让他不能被更改。

关键字实现枚举类

使用enum实现

package Chapt11.enum_;/*** @another SunHaoyu* @verson 1.0*/
public class enum01 {public static void main(String[] args) {Season ss= Season.SPRING;ss.printt();}
}
enum Season{SPRING("Spring","warm"),WINTER("Wanter","Cold");private String name;private String desc;private Season(String name, String desc) {this.name = name;this.desc = desc;}public void printt(Season season){System.out.println(season.desc+"   and   "+season.name);}public String getName() {return name;}public String getDesc() {return desc;}}

1. 将class用enum代替

2. 接着将对象创建部分改变

3. 如果想继续创建新的对象，使用逗号分割,最后一个对象使用分号进行结尾。

4. 创建的新的对象，必须写在最前面

5. 使用的时候

   Season ss= Season.SPRING;ss.printt();
   

   用第一行进行对象的建立，接着才能调用他的方法。

使用关键字实现枚举的注意事项

1. 使用enum关键字来开发一个枚举类的时候，会默认继承一个Enum类
2. 新建的对象写在enum类的第一行

直接调用对象，默认调用他的toString方法

使用枚举时常用的方法

因为继承了enum类，所以他的方法都可以使用

下面是几个常见的方法：

ToString方法

之前重写过了，用于返回类对象的各种信息

name方法

用于得到枚举对象的对象名称

ordinal方法

用于得到该枚举对象的次序，从0开始编号

values方法

会返回一个数组，是将所有的枚举对象封装起来返回出来

增强for循环

int []nums={1,2,3};
for(int i=0;i<nums.length;i++){System.out.println(i);
}
for(int i : nums){System.out.println(i);
}

下面这个是增强for循环，

是将数组中，依次拿一个出来赋给i，当数组结束的时候，for循环也结束了。

valueOf方法

这个方法是将字符串转换为枚举对象，要求字符串为已有的常量，不然会报错。其实是进行一个查找的功能，如果枚举对象中存在要找的字符串，会将和这个枚举对象返回出来。

compareTo方法

比较两个枚举常量，比较的是位置编号。

比较后，将前面的编号减去后面的编号，得到的结果返回

a.compareTo(b);

当a的编号是0，b是1，就会返回-1

课堂练习

声明week枚举类，其中包含星期一到星期天的定义，使用enum自带的方法输出这些信息。

package Chapt11.enum_;
/*** @another SunHaoyu* @verson 1.0*/
public class KnowWeek {public static void main(String[] args) {Week []weeks=Week.values();for (Week w:weeks){System.out.println(w.toString());}}
}
enum Week{Monday("星期一"),Tuesday("星期二"),Wednesday("星期三"),Thursday("星期四"),Friday("星期五"),Saturday("星期六"),Sunday("星期天");private String name;private Week(String name) {this.name = name;}@Overridepublic String toString() {return name ;}
}

注解Annotation/元数据Metadata

简单说明

1. 注解用于修饰解释 包，类，方法，属性，构造器，局部变量等数据信息。
2. 和注释不同，注解不影响程序逻辑，但注解可以被编译或者运行，相当于嵌入在代码中的补充信息。
3. 在JavaSE中，注解使用的目的较为简单，用于标记过时的功能，忽略警告，在JavaEE中用于配置应用程序的任何切面，代替他在旧版中所遗留的繁冗的代码和XML配置。

基本的Annotation介绍

使用Annotation时要在前添加@符号，并且把他当做一个修饰符使用，用于修饰他支持的元素

三个基本的Annotation

1. @Override：限定某个方法，是重写父类方法，该注解只能用于该方法。
   toString方法就用了这个
2. @Deprecated：用于表示某个程序元素已过时
3. @SupperssWarnings：抑制编译器警告

@Override

使用说明

1. @Override这个注解放在某个方法，表示子类的这个方法重写了父类的这个方法。
2. 如果不写@Override，也是重写了父类的方法
3. 但是，加上@Override，编译器会进入父类查找是不是有这个方法，如果父类没有这个方法，程序就会报错。

public @interface Override

这个表示是一个接口注解类

4. 查看@Override的源码，发现@Target，其中的@Target是修饰注解的注解，称之为元注解。

@Deprecated

使用说明

1. 用于表示某个程序元素已经过时
2. 可以修饰方法，包，字段，类，参数等等
3. @Deprecated可以做到新旧版本的过渡
4. 被@Deprecated标记依然可以使用，只是不推荐使用

@SupperssWarnings

使用说明

1. 比如说idle出现黄色警告，但是还是可以正常运行，我们不希望看到这些警告的时候，可以使用@SupperssWarnings进行警告的抑制，让他不出现

@SupperssWarnings({"…………"})

给里面填入相应的警告即可，比如填入all就可以抑制所有的警告。

2. 这个@SupperssWarnings是和放的位置相关，放在方法上，就抑制方法里面的，放在类上，就是抑制类的

四种元注解

元注解本身作用不大，是用于修饰其他Annotation

种类：

1. Retention 指定注解的作用范围，三种SOURCE，CLASS，RUNTIME
2. Target 指定注解可以在哪些地方使用
3. Documented 指定该注解是否会在javadoc中体现
4. Inherited 子类会继承父类注解

异常 -Exception

概念

异常处理体现在，当是一个小问题，不影响整体程序的运行，但是会让程序报错，这样会使得程序中止运行，影响用户体验，在这个时候，我们就需要处理异常，来使得程序正常运行。

怎么操作

1. 将改代码块选中，使用快捷键**alt ctrl t**，选择try+catch

2. 如果进行异常处理，那么即使出现异常，程序依然可以继续执行

   try{int res =1/0;
   }catch(Exception e){System.out.println(e.getMessage());
   }
   

   这个getmessage方法，可以输出异常的原因。