发展史

1990年是sun公司的一个项目，1994年改名为java，现属于oracle公司。

Java版本

1. javaSE：standard edition,标准版，桌面软件，桌游。
2. javaME：移动版，发展不怎么好，被Android用了然后带飞了。
3. javaEE:企业版，一般用其做大型系统，大型网站。

java优点

一次编写，处处运行，在不同系统上安装java虚拟机（JVM）即可使用，且jvm不跨平台，各个系统都可以使用。所以java是跨平台语言。

java相关工具认识

JDK：java development kit ，java开发者工具。（=JRE+运行环境工具）
JRE：java runtime environment， java运行环境，包含 java虚拟机。(只能运行java程序，但不能开发。)（=JVM+核心类库）
JVM：java virtual machine， java虚拟机，相当于在操作系统上模拟了一个cpu去运行java相关的东西。

java跨平台核心是因为JVM

安装jdk（java开发者包）

1. 百度搜索jdk12，找到下载地址

2. 下载对应的版本，下载exe后缀的

3. 双击安装jdk

4. 记住安装的路径，

5. 配置环境变量（不区分大小写）

   我的电脑-右键-属性-环境变量

   1. java_home :需要自己新建，写java的jdk的路径。
   2. path ：写到jdk下的bin目录，此条必须写，因为执行程序时会 在里面找相应的程序。
   3. classPath: .;java的lib目录（；前写的.代表自己写的类，；后写别人写得类的路径。）

   例如： (%包住代表相对应用)
   

   • dos下输入 java -version 显示版本表示安装成功

删除jdk

1. 删除java的安装目录（删除jdk的包）

2. 删除java_home（此电脑-属性-高级设置-环境变量）

3. 删除path下关于Java的目录

4. dos窗口输入 java -version 出现 java 不是内部或者外部命令，也不是可运行的程序或批处理文件

helloworld代码初实现

1. 编译软件编译

   public class Hello{public static void main(String[] args){System.out.print("hello,world");}
   } 

2. dos窗口编译运行
   

3. 使用javac编译java文件，会生成一个class文件

4. 再通过java 运行class文件，此时class文件不用写后缀

---

可能遇到的问题：

-java大小写敏感
-尽量使用英文
-文件名和class后的名字必须保证一致
-符号必须使用英文

java注释

5. 单行注释 //
6. 多行注释/* */
7. 文档注释 /** */ 可以识别的

标识符

8. 又名关键字，是系统定义好的。（所以不能用这些再起名字了）
   如 public 、class、 static、 viod、

9. 、标识符是大小写敏感的

10. 可以使用中文命名，但一般不建议这样。

11. 所有标识符都应该以字母A-Z,a-z,美元符$,或者下划线开始。

数据类型

12. 强类型语言: 要求变量的使用要严格符合规定，所有变量必须先定义后才能使用。java、 c++

13. 弱类型语言： 变量符合规定就行了，没有这么严格。

14. java的两大类数据类型：
    3.1 基本类型：
    数值类型（整数类型（byte、short、int、long）、浮点类型（float（四个字节）、double(占8个字节)）、字符类型（char,占两个字节）），布尔类型（boolean,只占一个位，只有true,false两个取值）

    例子： int num1=10;

    ​ byte num2=20;

    ​ short num3=30;

    ​ long num4=30L; //long类型要在数字后面加个L

    ​ float num5=50.1F; // 默认为double类型，所以加个F指明为float类型

    ​ double num6=3.1415926；

    ​ char name=‘张’ ； // 字符类型 只能是一个字。或者单个的字母

    ​ String names=" ahnasubcnu" //String不是关键字，是一个类。

    ​ boolean flag=true;

    ​ boolean flag=false;

3.2 引用类型：类、接口、数组

---

 小科普:什么是字节1. 位：是计算机 内部数据 存储  的最小单位，11001100是一个八位二进制数。bit2. 字节：是计算机中 数据处理 的基本单位，习惯上用B来表示。byte3. 1B=8bit (一个字节等于八位数)4. 字符：使之计算机中使用的字母、数字、字和符号。5. 电脑32位和64位指的是电脑的寻址能力。6. 1byte=8bit ； 1024byte=1kb；1024kb=1m；1024m=1G7. 1位 只有0和1两种情况，通常以byte为单位（8位）8. 1 short = 2 byte; 1 int =4 byte; 1 long =8 byte= 8* 8 =2^64bit9. 1 float  =4 byte；1 double =8 byte;10. 一个byte有2^8=256个可能性，正负开为[-128,127],即为byte的取值范围。
3.2 **引用类型**：类、接口、数组

---

///进制问题
1. 二进制：数字前加ob  ob11=2
2. 八进制：数字前加o     o11=9
3. 十六进制：数字前加ox  ox11=16^1+16^0=17  A~F表示10到15

常量、变量

1. java变量是程序中最基本的存储单位，包括变量名、变量类型和作用域。/数据类型 变量名 =值；

2. 声明变量是一条完整的语句，每一个声明必须以分号结束。

   ​ 变量的分类：

   • 局部变量：只写在方法里面。必须进行初始化。

   • 实例变量：作用域更大，写在类里面，方法的外面，从属于（对象）类，通过类才能使用。如果不自行初始值，默认为0、0.0、false,null.

   • 类变量：和实例变量一样，前面加个static，从属类，static为修饰符，不存在先后顺序

3. 常量：初始化后不能再改变的值，final 常量名=值;常量一般用大写字符。声明一个常量：static final double PI=3.14；（声明一个常量）

4. 变量存在于内存中，程序结束，计算机关机，变量失效，写入磁盘中的东西才能永久保存。

5. 变量的命名规范：

   • 所有变量、方法、类名要见名知意

   • 类成员变量和局部变量：首字母小写和驼峰原则（除了第一个单词以外，后面的单词首字母大写（lastName、monthSalary））

   • 常量：大写字母和下划线：MAX_VALUE

   • 类名：首字母大写和驼峰原则Man、DoodMan

   • 方法名：首字母小写和驼峰原则run()、runRun()

     即变量名，方法名首字母小写，类名首字母大写 都驼峰原则。

运算符

1. 算术运算符：+ - * /(取余) %（取模） ++(自增) --（自减）//自增自减属于一元运算符

2. 赋值运算符：=

3. 关系运算符;> < >= <= ==（等于） !=instanceof //关系运算符返回结果只有（true、false）

4. 逻辑运算符： && || !(与或非 and or !)

5. 位运算符：& | ^ >> << >>>

A= 0011 1100
B= 0000 1101
---------------------
//位运算
A&B 0000 1100     //两个位都为1时，结果才为1
A|B 0011 1101	  //两个位都为0时，结果才为0
A^B 0011 0001     //两个位相同为0，相异为1
~B  1111 0010	  //取反操作
/左移右移相对来说是底层运算，所以效率极高。
<< *2(左移*2)
>> /2(右移/2)
2*8=16  2*2*2*2=16
0000 0000 0
0000 0001 1
0000 0010 2
0000 0011 3				0000 0101 5
0000 0100 4				0000 0110 6
0000 1000 8				0000 0111 7
0001 0000 16
--------------------------------
//字符串连接符  +int a =10;int b=20;System.out.println(a+b+"");//“”代表空字符串，因为字符串在后面，会先进行计算     30System.out.println(""+a+b);//因为字符串在前面，会先进行字符串的拼接            1020System.out.println(""+(a+b));//因为加了括号，会优先运算括号里面的。            30

12. 条件运算符： ？ ：(因为涉及三个变量，所以叫三元运算符)

X ? Y : Z//如果X==true,则结果位Y，否则为true;
//x必须是布尔类型的值或者表达式
--------------------
public class demo05 {public static void main(String[] args) {boolean x= true;int y= 2;int b =20;System.out.println(x ? y : b);}
}
---------------------------
public class demo05 {public static void main(String[] args) {int score =50;String type =score<60 ? "不及格":"及格";System.out.println(type);}
}

7. 扩展赋值运算符：+= 、-= 、*= 、/=

int a=10;
int b=20;
a+=b;//a=a+b
a-=b;//a=a-b

---

特别说明：短路运算：a&&b ，若a是错误，则不会执行b。

初识math

• 幂运算2^3

---

很多运算会使用一些工具类来操作

double pow =Math.pow(2,3);
System.out.println(pow);

包机制

• 包的本质就是文件夹。
• 一般用公司域名倒置作为包

JavaDoc

javadoc命令是用来生成自己API文档的。类似与java的API文档

java程序的运行机制

1. 计算机的高级语言编程类型：

• 编译型：有一个负责翻译的程序，翻译成计算机能看懂的语言。
  解释型：对速度要求不高，边执行边解释。

• java既属于编译型又属于解释型。java先编译后解释。

2. 程序运行机制：javac中的c就是class的意思， 可以把java文件编译成class文件，再通过解释器告诉操作系统进行操作。

用户交互Scanner

说明：实现程序和人的交互，可以通过Scanner类获取用户的输入。通过java.util.Scanner包。

基本语法：
Scanner s = new Scanner(System.in);
Scanner属于类，有两个对象：
//next()不能得到带有空格的字符串，后者可以。
通过Scanner类的next()与nextLine()方法获取输入的字符串，在读取前我们一般需要使用hasNext()与hasNextLine()判断是否还有输入的数据。

package scanner;import java.util.Scanner;public class demo03 {public static void main(String[] args) {Scanner scanner =new Scanner(System.in);//创建一个Scanner类型的scanner容器，来接收键盘的输入。System.out.println("请输入数据：");//提示用户输入数据String str =scanner.nextLine();//程序在此时停下，直到输入变量保存到变量类型为String的str中去。System.out.println("输出的内容为："+str);//scanner.close();}}

顺序结构

1. java的基本结构就是顺序结构，除非特别指明那个，一般都是一行一行执行。
2. 顺序结构是最简单的算法结构。

选择结构

1. if单选择结构

if(布尔表达式){
//如果为true执行的语句;
}

2. if双选择结构

if(布尔表达式){
表达式为true执行的语句;
}else{表达式为true执行的语句;}

3. if多选择结构

if(布尔表达式){表达式为true执行的语句;}
else if(布尔表达式){表达式为true执行的语句;}
else if(布尔表达式){表达式为true执行的语句;}
else if(布尔表达式){表达式为true执行的语句;}
else if(布尔表达式){表达式为true执行的语句;}
else if(布尔表达式){表达式为true执行的语句;}
else{表达式为true执行的语句;}

package struct;import java.util.Scanner;public class ifDemo02 {public static void main(String[] args) {Scanner scanner = new Scanner(System.in);System.out.println("请输入内容：");int s = scanner.nextInt();if(s==100){System.out.println("恭喜，满分");} else if(s<100 && s>=90){System.out.println("A级");} else if(s<90 && s>=80){System.out.println("B级");} else if(s<80 && s>=70){System.out.println("C级");} else if(s<70 && s>=60){System.out.println("D级");} else if(s<60 && s>=0) {System.out.println("不及格");} else{System.out.println("不合法");}System.out.println("end");scanner.close();}
}
//按顺序只要一个为真就直接跳出程序。

4. 嵌套的if结构
5. switch多选择结构

#####switch case 语句判断一个变量与一系列值中某个值是否相等，每个值称为一个分支
switch(表达式){case value:输出语句;break;//可选case value:输出语句；break;//可选default://默认输出
}

public class IfDemo03 {public static void main(String[] args) {Scanner scanner =new Scanner(System.in);System.out.println("请输入：");String s = scanner.nextLine();switch(s){case "Hello":System.out.println("你好");break;case "100":System.out.println("满分");break;default:System.out.println("end");break;}System.out.println("end");scanner.close();}///break是执行完跳出循环，///default是默认，当都不符合case条件时，执行default语句。//break和default都不是必须写的内容。//case穿透，不写break会把剩下的case执行输出一遍。所以一般都要配break.

循环结构

1. while循环

while(布尔表达式){
//循环内容
}
//只要表达式为true，循环就会一直执行，大多数情况下需要一个让表达式失效的方式来结束循环。
//

package struct;public class WhileDemo01 {public static void main(String[] args) {//输出1-100int i =0;while(i<100){i++;System.out.println(i);}}
}

package struct;public class WhileDemo02 {//计算1+2+3+……+100public static void main(String[] args) {int i =0;int sum =0;while(i<100){i++;sum =sum +i ;System.out.println(i+"个数相加的和为："+sum);}}}

2. do while 循环：即使不满足条件，也至少执行一次。

do{
//代码语句
}whlie(布尔表达式)

package struct;public class DoWhileDemo01 {public static void main(String[] args) {int i=100;int sum =0;do {sum = sum + i;i++;} while(i<100);{System.out.printf(i+"个数和和为："+sum);}}
}

3. for循环

• for循环使一些循环结构变得简单。
• for循环是支持迭代的一种通用结构，是最有效最灵活的循环结构。
• for循环的执行次数是在执行前就确定的。
• for循环说明：
  最先执行初始化步骤可以声明一种类型，但可初始化一个或多个循环变量体，也可以是空语句。然后检测布尔表达式，如果为rue，则执行循环体，否则，循环终止，开始执行循环体后面的语句，执行一次循环后，更新循环控制变量，再次检测布尔表达式，循环执行上面的过程。

for(初始化; 布尔表达式; 更新){
//循环体
}
//根据初始值先判断是否满足布尔表达式，若满足则执行循环体，更新控制语句，否则跳出循环。

for( ; ; ){}
//代码可以存在，但是是死循环
。

5. 增强for循环

for(声明语句：表达式)
{
//代码句子
}
//声明语句：声明新的局部变量，该变量的类型必须和数组元素的类型相匹配，其值与数组元素的值相等。
//表达式：表达式是要访问的数组名，或者是返回值为数组的方法。
package struct;
//增强for循环
public class ForDemo06 {public static void main(String[] args) {int [] number={10,20,30,40,50};//定义了一个数组for(int i =0;i<5;i++){System.out.println(number[i]);}System.out.println("=========================");for(int x :number ){//增强for循环,遍历数组的元素，直接把number每一项的值赋值给xSystem.out.println(x);}}
}

break&contine

//break用于强制性退出循环，不执行循环中剩余语句。用在任何循环结构的部分，直接跳出循环。
//coutinue，用于终止某次循环过程。即跳出循环体中尚未执行的部分，接着进行下一次是否执行循环体的判断。

public interface BreakDemo {public static void main(String[] args) {int i=0;while(i<10){i++;if(i==5)continue;//碰到i=5,跳出该次循环，判断是否执行下一次循环。System.out.println(i);}System.out.println("end");}
}

public interface BreakDemo {public static void main(String[] args) {int i=0;while(i<10){i++;if(i==5)break;//碰到i=5,跳出循环体System.out.println(i);}System.out.println("end");}
}

---

 一些练习：

package struct;
计算0到100之间奇数和偶数的和public class ForDemo02 {public static void main(String[] args) {int osum =0;//定义偶数的和int jsum =0;//定义奇数的和//for(初始化、判断语句、控制语句){循环体//此时用if进行判断}for(int i=0;i<=100;i++){if(i%2==0){osum=osum+i;}else{jsum=jsum+i;}}System.out.println(osum);System.out.println(jsum);}
}

package struct;
//用for循环输出1-1000之间能被5整除的数，并且每行输出三个。
public class ForDemo03 {public static void main(String[] args) {for(int i=1;i<=1000;i++){if(i%5==0){System.out.print(i+"\t");//先找出能被5整除的数字,不让换行输出}if(i%15==0){System.out.println();//找出能被15整除的数，换行出//等价于System.out.print("\t");}}}
}```

package struct;
//99乘法表 自己写
public class ForDemo05 {public static void main(String[] args) {for(int i =1;i<=9;i++){//j代表行，i代表列for(int j =1;j<=i;j++){//j代表行，i代表列//由行控制列，所以外面是行，里面是列System.out.print(j+"*"+i+"="+(j*i)+"\t");}System.out.println();}}}主要思想：1.先打印第一行2.我们把固定的1再用循环包起来3.去掉重复项，i<j4.调整样式

package struct;
//99乘法表public class ForDemo04 {public static void main(String[] args) {for(int j = 1; j <= 9; j++){for (int i = 1; i <= j; i++) {//i是列，j是行System.out.print(i+"*"+j+"="+(j*i)+"\t");}System.out.println();}}}//先用一个变量打印出一行或一列，用变量调试。

方法

1. 方法是语句的集合，在一起执行一个功能。本质上就是函数

2. 方法的命名规则：首字母小写，驼峰原则

package method;
public class Demo01 {//main方法//void代表返回类型为空public static void main(String[] args) {int sum =add(1,2);System.out.println(sum);}//加法,类的名字为add,类型为intpublic static int add (int a,int b){return a+b;}}

3. 设计方法的原则：一个方法只完成一个功能，便于后期的拓展。即原子性。

方法定义及调用

1. 修饰符 返回值类型 方法名（参数类型 参数名）{
2. 方法体
3  .……
4 return 返回值
5. }
方法的定义：
//修饰符：可选，告诉编译器如何调用该方法，定义该方法的访问类型,如public
//返回值类型：方法可能会有返回值，如不需要返回值，关键字为void
//方法名：自己起的名字
//参数：分为实参和形参。多个参数用,隔开
//方法的具体内容。

//方法的调用
对象名.方法名（实参列表）
1.有返回值时调用
2.方法返回值时Void时，方法调用是一条语句。

package method;public class Demo02 {public static void main(String[] args) {int max=max(3,4)//方法调用，把方法的值赋值给maxSystem.out.println(max);//输出值}//修饰符       返回值类型 方法名（形参类型 形参名字）public static int max(int num1,int num2){int result=0;if(num1>num2){result =num1;}if(num1<num2){result=num2;} else{System.out.println("num1<num2");return 0;//终止方法}        return result;}}

方法重载

1.方法名一样，但参数列表必须不同（可以是类型不同，个数不同，参数排列顺序不同等），方法的返回值类型可以相同可以不同。仅仅返回类型不同不足以成为方法的重载。（容易出现笔试）
2. 实现理论:

方法名称相同时,编译器会根据调用方法的参数个数、参数类型等去逐个匹配，以选择对应的方法，如果匹配失败，则编译器报错。

可变参数

 public static int max(int num1,int num2){//可变参数，max(int num1,double...num2),int为普通参数，double类型的为可变参数，即可以有很多个double类型的参数。int result=0;if(num1>num2){result =num1;}if(num1<num2){result=num2;} else{System.out.println("num1<num2");return 0;//终止方法}        return result;

1. 一个方法中只能指定一个可变参数，它必须是方法的最后一个参数，任何普通参数必须在它之前声明。
2. 声明方式： 在指定参数类型后加一个省略号

递归

A方法调用A方法。自己调用自己。

package method;
/求阶乘
public class Demo04 {public static void main(String[] args) {System.out.println(diGui(4));//4的阶乘}public static int diGui(int n){if(n==1){return 1;}else{return n*diGui(n-1);}}
}

2. 递归会有边界，即一定会进行到底。

3. 先算4->3->2->1 结果在从1返回来

4. 基数比较大大事，占内存效率低，不一定跑起来。会影响机器的性能。

 //计算器
public class test {public static void main(String[] args) {try {Scanner input = new Scanner(System.in);System.out.print("请输入第一个数字：");double nuber1 = input.nextDouble();System.out.print("请输入第二个数字：");double nuber2 = input.nextDouble();System.out.print("请输入运算符：（+、-、*、/）");String oprate=input.next();double result = 0;switch (oprate) {case "+":result = nuber1 + nuber2;break;case "-":result = nuber1 - nuber2;break;case "*":result = nuber1 * nuber2;break;case "/":if (nuber2 == 0) {System.out.print("除数不能为0");} else {result = nuber1 / nuber2;}break;}System.out.print("结果是：" + result);} catch (Exception e) {System.out.println("输入有误");}}}
==================================
基本思路
1.写4个方法：加减乘除
2.利用循环+switch进行用户交互
传递需要操作的两个数
输出结果

数组

一组数，相同类型，先后次序，通过下标访问。下标从0开始，数组一旦被创建，大小就不可以改变了。数组中的元素可以是基本类型，也可以是引用类型。

1. 数组的声明与创建

int []  nums;//定义了数组，数组名为numsnums = new int[10]//  创建一个数组nums[0]=1; //给数组赋值声明创建一个数组int [] nums = new int[10];///获取数组长度：array.length

2. 数组使用

package method;public class ArrayDemo07 {public static void main(String[] args) {//打印全部的数组元素int[] array = {1, 2, 76, 84, 5};for (int i = 0; i < array.length; i++) {System.out.print(array[i]);}System.out.println();//计算所有元素的和int sum = 0;for (int i = 0; i < array.length; i++) {sum = sum + array[i];}System.out.print(sum);System.out.println();//查找最大元素int max = 0;for (int i = 0; i < array.length; i++) {if(array[i]>max){max=array[i];}}System.out.println(max);}
}

package method;public class ArrayDemo07 {public static void main(String[] args) {int[] arrays={1,23,45,56,67,78,43};printArray(arrays);}//打印数组元素//主要说明数组可以分装成类的参数public static void printArray(int[] arrays){for(int i=0;i< arrays.length;i++){System.out.print(arrays[i]);}System.out.println("");}

3. 多维数组：定义二维数组

   int [ ] [ ] array={{1,2,3,4,5},{1,2,3,4,5}}

4. arrays类

   数组中本身没有什么方法，数组中有一个Arrays类，包含操作数组方法的各种元素。例如： array.sort(数组名)会排序，sort是array中的一种方法。

5. 稀疏数组（了解概念即可，不怎么用）

6. 冒泡排序：是一种排序算法。每两个进行一次比较。时间复杂度为o(n2).

package method;import java.util.Arrays;public class Demoo7 {public static void main(String[] args) {int[] a = {2, 34, 5, 6, 78, 90, 55, 45, 23, 12};int[] sort = sort(a);//将数组a调用我们写的方法。System.out.println(Arrays.toString(sort));//将其转化为字符串输出}//1.比较数组中两个相邻的元素，第一个数比第二个大，则交换顺序public static int[] sort(int[] array) {//临时变量int tem = 0;//外层循环，判断要走都少次for (int i = 0; i < array.length - 1; i++) {//内层循环，比较判断两个数，判断出来，交换位置。for (int j = 0; j < array.length - 1 - i; j++) {if (array[j] > array[j + 1]) {tem = array[j];array[j] = array[j + 1];array[j + 1] = tem;}}}return array;}
} 

8. 初始数组为空时，在栈里
9. 给数组分配空间是，在堆里，通过new关键字
10. 数组的三种初始化(赋值)状态：

1.静态初始化int[] a = {1,2,3};
Man[] mans = {new Man(1,1) , new Man(2,2)};
2.动态初始化int[] a = new int[2]; 
a[0]=1;
a[1]=2;
3.数组的默认初始化数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化。

数组的使用

For-Each循环public class Demo09_Array {public static void main(String[] args) {int[] arrays = {1,2,3,4,5};//JDK1.5,没有下标for (int array : arrays) {System.out.println(array);}}
}
数组作方法入参public class Demo09_Array {public static void main(String[] args) {int[] arrays = {1,2,3,4,5};printArray(arrays);}//打印数组元素public static void printArray(int[] arrays){for (int i = 0; i < arrays.length; i++) {System.out.print(arrays[i]+" ");}}
}
​
数组作返回值public class Demo09_Array {public static void main(String[] args) {int[] arrays = {1,2,3,4,5};int[] reverse = reverse( arrays);printArray(reverse);}//反转数组public static int[] reverse(int[] arrays){int[] result = new int [arrays.length];//反转的操作for (int i = 0,j=result.length-1; i < arrays.length; i++,j--) {result[j] = arrays[i];}return result;}//打印数组元素public static void printArray(int[] arrays){for (int i = 0; i < arrays.length; i++) {System.out.print(arrays[i]+" ");}}
}

封装

1. 程序设计原则;高内聚低耦合。

2. 将数据封装起来，只暴露给外界接口。

3. 封装主要是针对属性的。在属性前面加关键词 private

4. 把属性用 private修饰

5. 对私有属性的操作 通过公共的get/set方法完成。

//类中只有属性和方法
public class Student {//类 private: 私有//属性私有private String name; //名字private int id; //学号private char sex; //性别private int age;//提供一些可以操作这个属性的方法!//提供——public的get. set方法//get获得这个数据public String getName(){return this.name;}//set给这个数据设置值public void setName(String name){this.name = name;}//alt + insertpublic int getAge() {return age;}public void setAge(int age) {if(age <0 || age > 120){this.age = 3;}else {this.age = age;}}public int getId() {return id;}public void setId(int id) {this.id = id;}public char getSex() {return sex;}public void setSex(char sex) {this.sex = sex;}
}

• 封装的优点

  提高程序的安全性，保护数据.
  隐藏代码的实现细节
  统一接口
  系统可维护增加了

继承

1. 继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模。

2. extands的意思是“扩展”。子类是父类的扩展。

3. JAVA中类只有单继承，没有多继承!

4. 被final修饰的类不能被继承。

5. 继承是类和类之间的一种关系。除此之外,类和类之间的关系还有依赖、组合、聚合等。

• 继承关系的俩个类，一个为子类(派生类),一个为父类(基类)。子类继承父类,使用关键字extends来表示。
• 子类和父类之间,从意义上讲应该具有"is a"的关系.

6. object类

   java中的所有类都直接或间接继承Object类

7. super

• super注意点:

  1. super调用 父类的构造方法，必须在构造方法的第一个

  2. super 必须只能出现在子类的方法或者构造方法中!

  3. super和 this 不能同时调用构造方法!

• Vs this:

  1. 代表的对象不同: this 本身调用者这个对象 super:代表父类对象的应用

  2. 前提 this:没有继承也可以使用 super:只能在继承条件才可以使用

  3. 构造方法 this() ; 本类的构造 super():父类的构造!

// 子类维承了父类，就会拥有父类的全部方法!
public class Student extends Person{public Student() {//隐藏代码:调用了父类的无参构造super(); // 调用父类的构造器，必领要在子类构造器的第一一行System.out.println("Student无参执行了");}public Student(String name) {this .name = name ;}private String name = "qinjiang" ;public void print(){System.out.println("Student");}public void test1(){print();//Studentthis.print();//Studentsuper.print();//Person}
}
public class Person {//一个类即使什么都不写，它也会存在个方法//显示的定义构造器protected String name ="kuangshen";int age;//alt+ insert//1.使inew关键字， 本质是在调用构造器//2.用例初始化值public Person(){System.out.println("Person");}//有参构造:一旦定义 了有参构造。无参就必须显示定义public Person(String name){this.name = name ;}public void print(){System.out.println("Person");}
}

方法重写

父类静态方法public class Demo04_A extends Demo04_B{public static void test(){System.out.println("A==>test()");}
}
//重写都是方法的重写，和属性无关
public class Demo04_B {public static void test(){System.out.println("B==>test()");}
}
public class Applications {public static void main(String[] args) {//Demo04//方法的调用只和左边，定义的数据类型有关Demo04_A a = new Demo04_A();a.test();//A==>test()//父类引用指向引用Demo04_B b = new Demo04_A();b.test();//B==>test()}
}

父类非静态方法public class Applications {public static void main(String[] args) {//Demo04/*静态方法和非静态方法区别很大静态方法：方法的调用只和左边，定义的数据类型有关非静态方法：重写，父类方法只能是public*/Demo04_A a = new Demo04_A();a.test();//A==>test()//父类引用指向引用Demo04_B b = new Demo04_A();//子类重写了父类的方法b.test();//A==>test()}
}
//重写都是方法的重写，和属性无关
public class Demo04_B {public void test(){System.out.println("B==>test()");}
}
public class Demo04_A extends Demo04_B{@Overridepublic void test() {System.out.println("A==>test()");}
}

1. 重写:需要有继承关系，子类重写父类的方法!

• 方法名必须相同

• 参数列表列表必须相同

• 修饰符:范围可以扩大但不能缩小:public>Protected >Default>private

• 抛出的异常:范围，可以被缩小，但不能扩大: ClassNotFoundException --> Exception(大)

• 重写，子类的方法和父类必要一 致;方法体不同!

2. 为什么需要重写:

• 父类的功能，子类不一定需要， 或者不一定满足!

• Alt +Insert ;---->override;

多态

1. 即同一方法可以根据发送对象的不同而采用多种不同的行为方式。

2. 一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多

3. 多态存在的条件

• 有继承关系
• 子类重写父类方法
• 父类引用指向子类对象
• 注意:多态是方法的多态，属性没有多态性。

4. 多态注意事项:

• 多态是方法的多态，属性没有多态
• 父类和子类，有联系 类型转换异常! ClassCastException!
• 存在条件: 继承关系，方法需要重写，父类引用指向于类对象! Father f1 = new Son();
• 不能进行多态的方法：
  static 方法，属于类，它不属于实例
  final常量;
  private 方法;

5. instanceof：(类型转换)引用类型， 判断一个对象是什么类型~

public class Applications {public static void main(String[] args) {Object object = new Student();//System. out . println(X instanceof Y);//能不能编译通过! X,Y之间要存在父子关系//System. out . println(X instanceof Y);// X是Y之的子类，trueSystem.out.println(object instanceof Student); //trueSystem.out.println(object instanceof Person); //trueSystem.out.println(object instanceof Object); //trueSystem.out.println(object instanceof Teacher); //FalseSystem.out.println(object instanceof String); //FalseSystem.out.println("===========================");Person person = new Student();System.out.println(person instanceof Student); //trueSystem.out.println(person instanceof Person); //trueSystem.out.println(person instanceof Object); //trueSystem.out.println(person instanceof Teacher); //False//System.out.println(person instanceof String); //不能通过编译System.out.println("===========================");Student student = new Student();System.out.println(student instanceof Student); //trueSystem.out.println(student instanceof Person); //trueSystem.out.println(student instanceof Object); //true//System.out.println(student instanceof Teacher); //不能通过编译//System.out.println(student instanceof String); //不能通过编译}
}

6. 转换

父类转子类public class Application {public static void main(String[] args) {//类型之间的转化:父子//高               低Person obj = new Student();//student将这个对象转换为Student类型，我们就可以使lstudent类型的方法了!((Student) obj).go();}
}

子类转父类public class Application {public static void main(String[] args) {//类型之间的转化:父           子//子类转换为父类，可能丢失自己的本来的一些方法!Student student = new Student();student.go();Person person = student;}
}

7. 多态总结

• 父类引用指向子类的对象

• 把子类转换为父类，向上转型；

• 把父类转换为子类，向下转型；强制转换

• 方便方法的调用，减少重复的代码!简介

• 封装、继承、多态! 抽象类，接口

static

public class Student {//2:赋初值~{System.out.println("匿名代码块");}//1 :只执行一次~static {System.out.println("静态代码块");}//3public Student() {System.out.println("构造方法");}public static void main(String[] args) {Student student = new Student();System.out.println("==========");Student student2 = new Student( );}
}

//静态导入包~
import static java.lang.Math.random;
import static java.lang.Math.PI;
public class demo01 {public static void main(String[] args) {System.out.println(random());System.out.println(PI);}
}

抽象类

1. abstract修饰符可以用来修饰方法也可以修饰类，如果修饰方法，那么该方法就是抽象方;如；果修饰类，那么该类就是抽象类。

2. 抽象类中可以没有抽象方法,但是有抽象方法的类一定要声明为抽象类。

3. 抽象类,不能使用new关键字来创建对象, 它是用来让子类继承的。

4. 抽象方法,只有方法的声明,没有方法的实现,它是用来让子类实现的。

5. 子类继承抽象类,那么就必须要实现抽象类没有实现的抽象方法, 否则该子类也要声明为抽象类。

//约束有人帮我们实现~
public abstract class Action {//abstract， 抽象方法，只有方法名字，没有方法的实现!public abstract void run();public void go(){System.out.println("Action==>go()");}//1. 不能new这个抽象类，只能靠子类去实现它;约束!//2. 抽象类中可以写普通的方法~//3. 抽象方法必须在抽象类中~//抽象的抽象:约束~//思考题?  new，存在构造器么?//存在的意义抽象出来~ 提高开发效率
}
public class A extends Action{//必须实现父类的抽象方法，除非其本身也是抽象类@Overridepublic void run() {System.out.println("A==>run()");}
}

接口

1. 普通类:只有具体实现

2. 抽象类:具体实现和规范(抽象方法)都有!

3. 接口:只有规范! 自己无法写方法~专业的约束!约束和实现分离:面对接口编程

4. 接口就是规范，定义的是一组规则，体现了现实世界中“如果你…则必须能.的思想。如果你是天使，则必须能飞。如果你是汽车,则必须能跑。如果你好人，则必须干掉坏人;如果你是坏人，则必须欺负好人。

   接口的本质是契约,就像我们人间的法律一样。制定好后大家都遵守。

   oo的精髓，是对对象的抽象，最能体现这一点的就是接口。为什么我们讨论设计模式都只针对具备了抽象能力的语言(比如c++. java、 c#等) ，就是因为设计模式所研究的，实际上就是如何合理的去抽象。

public interface UserService {//interface定义的关键字，按口都需 要有实现类//常量~ pubsic static final,一般不在接口中定义常量int AGE = 99;//按口中的所有定义的方法其实都是抽象的public abstractvoid add(String name);void delete(String name);void update(String name);void query(String name);
}
public interface TimeService {void timer();
}

//抽象类: extends~
//类可以实现接口implements 按口
//实现了按口的类，就需要重写接口中的方法~
//多继承~利用接口实现多继承
public class UserServiceImpl implements UserService, TimeService {@Overridepublic void add(String name) {}@Overridepublic void delete(String name) {}@Overridepublic void update(String name) {}@Overridepublic void query(String name) {}@Overridepublic void timer() {}
}

5. 接口总结

• 方法public abstract

• 常量public static final

• 接口不能被实例化_{，接口中没有构造方法}

• implements 可以实现多个接口

• 必须要重写接口中的方法~

内部类

1. 内部类就是在一个类的内部在定义一个类,比如，A类中定义一个B类,那么B类相对A类来说就称为内部类，而A类相对B类来说就是外部类了。
2. 成员内部类

public class Outer {private int age = 10;public void out(){System.out.println("这是外部类的方法");}public class Inner{public void in(){System.out.println("这是内部类的方法");}public void getAge(){System.out.println(age);}}
}
public class Applications {public static void main(String[] args) {//demo09Outer outer = new Outer();Outer.Inner inner = outer.new Inner();inner.getAge();inner.in();outer.out();}
}     

3. 静态内部类
4. 局部内部类

//局部内部类public void method(){class Inner1{public void in1(){}}}

6. 匿名内部类

异常

1. 实际工作中，遇到的情况不可能是非常完美的。比如:你写的某个模块，用户输入不一定符合你的要求、你的程序要打开某个文件，这个文件可能不存在或者文件格式不对，你要读取数据库的数据，数据可能是空的等。我们的程序再跑着，内存或硬盘可能满了。等等。

2. 软件程序在运行过程中，非常可能遇到刚刚提到的这些异常问题，我们叫异常，英文是:Exception,意思是例外。这些，例外情况，或者叫异常,怎么让我们写的程序做出合理的处理。而不至于程序崩溃。

3. 异常指程序运行中出现的不期而至的各种状况,如:文件找不到、网络连接失败、非法参数等。

4. 异常发生在程序运行期间,它影响了正常的程序执行流程。

5. 要理解Java异常处理是如何工作的，你需要掌握以下三种类型的异常:

• 检查性异常:最具代表的检查性异常是用户错误或问题引起的异常,这是程序员无法预见的。例如要打开一个不存在文件时，一个异常就发生了,这些异常在编译时不能被简单地忽略。

• 运行时异常:运行时异常是可能被程序员避免的异常。与检查性异常相反，运行时异常可以在编译时被忽略。

• 错误ERROR:错误不是异常,而是脱离程序员控制的问题。错误在代码中通常被忽略。例如,当栈溢出时，一个错误就发生了，它们在编译也检查不到的。

• 异常体系结构

1. Java把异常当作对象来处理，并定义一个基类java.lang.Throwable作为所有是常的超类。

2. 在Java API中已经定义了许多异常类，这些异常类分为两大类，错误Error和异常Exception。

异常处理框架
public class Demo1 {public static void main(String[] args) {int a=1;int b=0;//假设要捕获多个异常:从小到大!try { //try监控区域System.out.println(a/b);} catch (Error e){ //catch(想要航获的异常类型! )捕获异常System.out.println("Error");} catch (Exception e){System.out.println( "Exception");} catch (Throwable t){System.out.println("Throwable");} finally { //处理普后工作System.out.println( "finally");}//finally可以不要finally,假设IO， 资源，关闭!}public void a(){b();}public void b(){a();}
}

主动抛出异常public class Demo02 {public static void main(String[] args) {try {new Demo02().test( 1, 0);} catch (ArithmeticException e) {e. printStackTrace();}}//假设这方法中，处理不了这个异常。方法上:抛出异常public void test(int a,int b) throws ArithmeticException {if (b == 0) { //throwthrow new ArithmeticException(); //主动的抛出异常，一般在方法中使用}System.out.println(a/b);}
}