【JAVA学习笔记】

该笔记是学习bilibili中狂神说大咖的随手笔记，主要是由文字,代码和图片结合记录，有利于回顾(路漫漫其修远兮，吾将上下而求索)，希望大家多写代码，多写笔记，多思考，最重要的就是坚持。推荐该大咖网址——》bilibili狂神说

文章目录

1.Java前言

2.java预科

I. 写博客和Markdown语法详解
II. 什么是计算机
III. 冯-诺依曼体系结构
IV. cmd和Dos命令

3.java入门

I. java学习路线图
II. 工欲善其事必先利其器java开发环境搭建
III.使用IDEA开发
IV.HelloWorld实例

4.java基础

I. 注释，标识符，关键字
II. 数据类型及其转换
III. 变量，常量，作用域
IV. 基本运算符
V.包机制和JavaDoc生成文档

5.Java流程控制

I. 用户交互Scanner
II. 顺序结构
III. 选择结构
IV. 循环结构
V. 流程控制练习

6.java方法

I.方法定义及其调用
II.方法重载
III.命令行传参
IV.递归讲解

7.java数组

I.数组声明和创建
II.三种初始化及内存分析
III.数组的使用
IV.Arrays类讲解
V.稀疏数组

8.面向对象(oop)

I.类的对象和创建
II.构造器详解
III.封装
IV.继承
V.多态
VI.抽象类
VII.接口的定义与实现
VIII.N种内部类

9.java异常

I.Error和Exception
II.捕获和抛出异常
III.自定义异常及经验小结

Java前言

1.Java是一门面向对象的编程语言，不仅吸收了C++语言的各种优点，还摒弃了C++里难以理解的多继承、指针等概念，因此Java语言具有功能强大和简单易用两个特征。Java语言作为静态面向对象编程语言的代表，极好地实现了面向对象理论，允许程序员以优雅的思维方式进行复杂的编程。

2.Java具有简单性、面向对象、分布式、健壮性、安全性、平台独立与可移植性、多线程、动态性等特点。

3.Java可以编写桌面应用程序、Web应用程序、分布式系统和嵌入式系统应用程序等。

回到所点位置

java预科

写博客和Markdown语法详解

写博客能提高逻辑思维能力
写博客能提高总结能力
Markdown详细了解请点请点我

冯-诺依曼体系结构

打开cmd（命令提示符）方式

显示界面

常用的Dos命令

 1.#盘符切换2.#查看当前所有的文件 dir3.#切换目录  通过cd change directory4.#cd ..5.#清理屏幕 cls (clear screen)6.#退出终端 exit7.#查看电脑ipconfig

回到所点位置

java入门

java学习路线

工欲善其事必先利其器，搭建java开发环境

配置IDEAde运行，工作环境，在百度上搜索JDK，JRE安装教程

配置环境变量

在cmd中测试是否安装成功

输入java -version显示成如图则安装成功

使用IDEA开发

IDEA官方下载https://www.jetbrains.com/

java开始实例

public class HelloWorld{public static void main(String[] args){System.out.printf("Hello,World");}
}

回到所点位置

java基础

注释，标识符，关键字

1.注释:

单行注释  //
多行注释 /* 内容   */
javaDos：文档注释 (/** 加回车)

2.标识符和关键字

数据类型及其转换

关于数据类型的一些实例

public class DemoI {public static void main(String[] args) {//八大基本数据类型//整数int num1=10;byte num2=20;//-128~127short num3=30;long num4=40;//小数float num5=50.1f;double num6=3.14159265358;//字符char name= '中';//String不是关键字//布尔值：是非boolean flag = true;}
}

public class DemoII {public static void main(String[] args) {int i = 10;int i2 = 010;//八进制0bint i3 = 0x10;//十六进制0x    0~9   A~FSystem.out.println(i);System.out.println(i2);System.out.println(i3);System.out.println("====================");//浮点数拓展float f = 0.1f;double d = 1.0 / 10;System.out.println(f==d);//falsefloat d1 = 12444345f;float d2 = d1 + 1;System.out.println("d1==d2");//trueSystem.out.println("====================");//字符拓展char c1 = 'A';char c2 = '中';System.out.println(c1);System.out.println((int) c1);//强制转换System.out.println(c2);System.out.println((int) c2);char c3 = '\u0061';System.out.println(c3);System.out.println("====================");}
}

类型转换

低------------------------------->高

byte，short，char—>int—>long—>float—>double

public class Demo3 {public static void main(String[] args) {int i =128;byte b = (byte)i;//内存溢出//强制转换   （类型）变量名  高到低//自动转换     低到高System.out.println(i);System.out.println(b);/*注意点：1. 不能对布尔值进行转换2. 不能把对象类型转换为不想干于的类型3. 在把高容量转换到低容量的时候，强制转换4. 转换的时候可能存在内存溢出，或者精度问题*/System.out.println("===================");System.out.println((int)23.7);System.out.println((int)-45.445f);System.out.println("===================");char c = 'a';int d = c+1;System.out.println(d);System.out.println((char)d);}
}

变量，常量，作用域

变量就是可以变化的量。
常量就是不变的量。
java是一种强类型语言，每个变量都必须声明其类型。
java变量是程序中最基本的存储单元，其要素包括变量名，变量类型和作用域。
注意事项
变量名必须是合法的标识符，每个声明都必须以分号结束。

作用域

基本运算符

下面是运算符计算实例

public class Demo5 {public static void main(String[] args) {int a = 40;int b = 30;int c = 20;int d = 10;System.out.println(a + b);System.out.println(a - b);System.out.println(a * b);System.out.println(a / b);System.out.println("================");long A = 123123134L;int B = 123;short C = 10;byte D = 8;System.out.println(A+B+C+D);System.out.println(B+C+D);System.out.println(C+D);System.out.println("================");int a1 = 10;int b1 = 20;int c1 = 21;System.out.println(c1%a1);System.out.println(a1>b1);System.out.println(a1<b1);System.out.println(a1==b1);System.out.println(a1!=b1);System.out.println("================");//++   --     自增，自减int A1 = 3;int B1 = A1++;//A1++    A1=A1+1int C1 = ++A1;System.out.println(A1);System.out.println(B1);System.out.println(C1);System.out.println("================");double pow = Math.pow(3,2);//2*2*2System.out.println(pow);System.out.println("================");boolean x = true;boolean w = false;System.out.println("x&&w:"+(x&&w));System.out.println("x||w:"+(x||w));System.out.println("!(x&&w):"+!(x&&w));System.out.println("================");int score = 60;String type = score <60?"不及格":"及格";System.out.println(type);}
}

包机制和JavaDoc生成文档

javaDoc生成文档

去浏览器搜索jdk帮助文档(javase 文档--API和文档)了解javaDoc[API文档](https://docs.oracle.com/javase/8/docs/api/)

学会查找使用IDEA生产javaDoc文档！

回到所点位置

Java流程控制

用户交互Scanner

上手实践Scanner

import java.util.Scanner;
public class Demo1 {public static void main(String[] args) {Scanner scanner = new Scanner(System.in);System.out.println("使用next方式接收");//判断用户有没有输入字符串if(scanner.hasNext()){//使用next方式接收String str = scanner.next();System.out.println("输入的内容为："+str);}scanner.close();//凡是属于IO流的类如果不会关闭会一直占用资源，要养成良好的习惯用完就关掉}
}

上述代码注意事项

import java.util.Scanner;public class Demo3 {public static void main(String[] args) {Scanner scanner = new Scanner(System.in);//定义一个和double sum = 0;//计算输入了多少个数字int m= 0;//通过循环判断是否还有输入，并在里面对每一个进行求和统计while(scanner.hasNextDouble()){double x = scanner.nextDouble();m= m+1;//m++sum = sum +x;System.out.println("你输入了第"+m+"个数据，当前的结果sum="+sum);}System.out.println(m+"个数的和为："+sum);System.out.println(m+"个数的平均值是：" +(sum/m));scanner.close();}
}

顺序结构

java 的基本结构就是顺序结构，除非特别指明，否则就按照顺序一句一句执行。
顺序结构是最简单的算法结构。
语句与语句之间，框与框之间是按从上到下的顺序进行的，它是由若干个依次执行的处理步骤组成的，它是任何一个算法都离不开的一种基本算法结构。

选择结构

它分别是if单选择结构，if双选择结构，if多选择结构，嵌套的if结构，switch多选择结构。

单选择结构

import java.util.Scanner;public class Demo1 {public static void main(String[] args) {Scanner scanner = new Scanner(System.in);System.out.println("请输入内容：");String s = scanner.nextLine();//equals:判断字符串是否相等if(s.equals("Hello")){System.out.println(s);}System.out.println("End");scanner.close();}
}

if双选择结构

语法：

if(布尔表达式){
//如果布尔表达式的值为true
}else{
//如果布尔表达式的值为false
}

import java.util.Scanner;
public class Demo3 {public static void main(String[] args) {//考试分数大于60就是及格，小于60分数就不及格Scanner scanner = new Scanner(System.in);System.out.println("请输入成绩：");int score = scanner.nextInt();if(score>60){System.out.println("及格");}else{System.out.println("不及格");}scanner.close();}
}

Switch多选择结构

1.多选择结构还有一个实现方式就是Switch case语句。

2.Switch case语句判断一个变量与一系列中某个值是否相等，每个值称为一个分支。

3.Switch语句中的变量类型可以是：

 I. byte，short，int或char。II. 从java SE 7开始。III. Switch支持字符串String类型了。IV. 同时case标签必须为字符串常量或字面量。

public class Demo4 {public static void main(String[] args) {char grade = 'c';switch (grade){case 'a':System.out.println("优秀");break;case 'b':System.out.println("良好");break;case 'c':System.out.println("及格");break;case 'd':System.out.println("再接再厉");break;case 'e':System.out.println("挂科");break;default:System.out.println("未知等级");}}
}

循环结构

1.while循环

I.要布尔表达式为true，循环就会一直执行下去。

II.我们大多数情况是会让循环停止下来的，我们需要一个让表达式失效的方式来结束循环。

III.少部分情况需要一直执行，比如服务器的请求响应监听等。

IV.循环条件一直为true就会造成无限循环【死循环】，我们正常的业务编程中应该尽量避免死循环。会影响程序性能或者造成程序快卡死崩溃。

while(布尔表达式){//循环内容
}
public class Demo5 {public static void main(String[] args) {//输出1~100和1+~100int i = 0;int sum =0;while(i<=100){sum = sum +i;i++;}System.out.println(sum);}
}

2.do…while循环
while和do-while具有相似之处不同的是，do…while循环至少会执行一次

while和do-while的区别：
while先判断后执行。do…while是先执行后在判断！
do…while总是保证循环体会至少执行一次！这是它们的主要差别。

public class Demo6 {public static void main(String[] args) {int i = 0;int sum = 0;do{sum =sum+i;i++;}while(i<=100);System.out.println(sum);}
}

3.for循环
for循环语句是支持迭代的一种通用结构，是最有效，最灵活的循环结构。
语法格式：

for(初始值;布尔表达式;更新){//代码语句
}

public class Demo9 {public static void main(String[] args) {//打印九九乘法表for (int j = 0; j <= 9; j++) {for(int i=1; i<=j; i++){System.out.print(j+"*"+i+"="+(j*i)+"\t");}System.out.println();}}
}

增强for循环

1.java5 引入了一种主要用于数组或者集合的增强型for循环。

2.java增强for循环语法格式如下：

for(声明语句: 表达式){//代码语句
}

3.声明语句：声明新的局部变量，该变量的类型必须和数组元素的类型匹配。其作用域限定在循环语句块，其值与此时数组元素的值相等。

4.表达式：表达式是要访问的数组名，或者是返回值为数组的方法。

  //遍历数组元素,增强for循环for(int x:numbers){System.out.println(x);}

break,continue

1.break在任何循环语句的主体部分，均可用break控制循环的流程。break用于强行退出循环，不执行循环中剩余的语句。（break语句也在Switch语句中使用）

2.continue语句用在循环语句体中，用于终止某次循环过程，及跳过循环体重尚未执行的语句，接着进行下次是否执行循环的判定。

关于goto关键字

1.goto关键字很早就在程序设计语言中出现，尽管goto仍是java的一个保留字，但并未在语言中得到正式使用，java没有goto，然而，在break和goto这两个关键字的身上，我们仍然能看出一些goto的影子…带标签的break和continue。

2.“标签”是指后面跟一个冒号的标识符，例如：label。

3.对Java来说唯一用到标签的地方是在循环语句之前，而在循环之前设置标签的唯一理由是：我们希望在其中嵌套另一个循环，由于break和continue关键字通常只中断当前循环，但若随同标签使用，他们就会中断到存在标签的地方。

public class Demo11 {public static void main(String[] args) {//打印三角形for (int i = 1; i <= 5; i++) {for(int j=5; j>=i; j--){System.out.print(" ");}for(int j = 1;j<=i; j++){System.out.print("*");}for(int j=1;j<i;j++){System.out.print("*");}System.out.println();}}
}

回到所点位置

java方法

什么是方法

1.方法是语句的集合，他们在一起执行一个功能。
2.方法是解决一类问题的步骤的有序组合。
3.方法包含于类或对象中。
4.方法在程序中被创建，在其他地方被引用。

设计方法的原则：

方法的本意是功能块，就是实现某个功能的语句块的集合。我们设计方法的时候，最好保持方法的原子性，就是一个方法只能完成一个功能，这样利于我们后期的扩展。

方法的命名规则：驼峰命名规则

public class Demo1 {//main方法public static void main(String[] args) {int sum = add(1,3);System.out.println(sum);}public static int add(int a,int b){return a+b;}
}

方法定义及其调用

public class Demo2 {//main方法public static void main(String[] args) {int max = max(10,20);System.out.println(max);}//比大小方法public static int max(int num1,int num2){int result =0;if(num1==num2) {System.out.println("num1=num2");return 0;//终止}if(num1>num2){result = num1;}else {result = num2;}return result;}
}

方法重载

1.重载就是在一个类中，有相同的函数名称，但形参不同的函数。

2.方法的重载的规则：

方法名称必须相同。
参数列表必须不同（个数不同，或类型不同，参数排列顺序不同等）。
方法的返回类型可以相同也可以不相同。
仅仅放回类型不同不足以成为方法的重载。

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

命令行传参

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

public static void printMax(double...numbers){if(numbers.length ==0){System.out.println("No argument passed");return;}double result = numbers[0];//排序for(int i=1;i<numbers.length;i++){if(numbers[i]>result){result = numbers[i];}}System.out.println("The max vaule is"+result);
}

递归讲解

1.A方法调用B方法。

2.A方法调用A方法！就是自己调用自己。

3.利用递归可以用简单的程序来解决一些复杂的问题。它通常把一个大型复杂的问题层层转化为一个与原则问题相似的规模较小来求解，递归策略只需少量的程序就可以描述出解题过程所需要的多次重复计算，大大的较少了程序的代码量。递归的能力在于用有限的语句来定义对象的无限集合。

public class Demo4 {public static void main(String[] args) {System.out.println(f(5));}public static int f(int n){if(n==1){return 1;}else{return n*f(n-1);}}
}

简单的计算机

import java.util.Scanner;
public class Demo5 {public static void main(String[] args) {System.out.println("请输入你的第一个数：");Scanner scanner = new Scanner(System.in);double num1 = scanner.nextDouble();System.out.println("请输入运算符：");String operator = scanner.next();System.out.println("请输入你的第二个数：");double num2 = scanner.nextDouble();switch(operator){case "+" :System.out.println("num1"+"与"+"num2"+"的和为:"+(num1+num2));break;case "-" :System.out.println("num1"+"与"+"num2"+"的差为:"+(num1-num2));break;case "*" :System.out.println("num1"+"与"+"num2"+"的积为:"+(num1*num2));break;case "/" :System.out.println("num1"+"与"+"num2"+"的商为:"+(num1/num2));break;}}
}

java数组

数组声明和创建

首先讲解下什么是数组：
1.数组是相同类型的有序集合。
2.数组描述的事项同类型的若干个数据，按照一定的先后次序排列组合而成。
3.其中，每个数据称作一个数组元素，每个数组元素可以通过一个小标来访问它们。

数组声明创建

首先必须声明数组变量，才能在程序中使用数组。下面是声明数组变量的语法：

int[] arr;//首选方法
int arr[];//效果相同，但不是首选方法

java语言使用new操作符来创建数组，语法如下：

int[] arr = new int[10];

数组的元素是通过索引访问的，数组索引从0开始。
获取数组的长度：arrays.length;

public class Array {public static void main(String[] args) {//变量的类型      变量的名字    =     变量的值；//数组类型int[] nums;//声明一个数组；nums = new int[10];//创建一个数组//int[] nums = new int[10];和上面是相同的//给数组元素赋值nums[0] = 1;nums[1] = 2;nums[2] = 3;nums[3] = 4;nums[4] = 5;nums[5] = 6;nums[6] = 7;nums[7] = 8;nums[8] = 9;nums[9] = 10;//System.out.println(nums[9]);//计算数组的和int sum = 0;//获取数组的长度  arrays.length ;for (int i = 0; i < nums.length; i++) {sum = sum + nums[i];}System.out.println("总和为："+sum);}
}

java内存分析：

数组的三种初始化：

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 数组的默认初始化
数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化。

public class arraydemo {public static void main(String[] args) {//静态初始化int[] a= {1,2,3,4,5,6,7,8};System.out.println(a[1]);//动态初始化；包含默认初始化int[] b = new int[10];b[0] = 10;System.out.println(b[0]);System.out.println(b[1]);System.out.println(b[2]);}
}

数组特点及其边界

数组的特点：

1.数组的长度是确定的，数组一旦被创建，它的大小就是不可以改变的。
2.其元素必须是相同类型，不允许出现混合类型
3.数组中的元素可以是任何数据类型，包括吉本类型和引用类型。
4.数组变量属引用类型，数组也可以看成对象，数组中的每个元素相当于该对象的成员变量。
5.数组本身就是对象，Java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型数组对象本身是在堆中的。

数组的边界：

下标的合法区间：[0.arrays.length-1],如果越界就会报错；

public static void main(String[] args){int[] a = new int[2];System.out.println(a[2]);
}

代码中出现ArrayInexOutOfBoundsException:数组下标越界异常!

小结

1.数组是相同数据类型（数据类型可以为任何类型）的有序集合。
2.数组也是对象。数组元素相当于对象的成员变量
3.数组长度的确定，不可变的。如果越界，则报：ArrayInexOutOfBoundsException

数组的使用

1.For-Each循环
2.数组做方法入参
3.数组作返回值

public class arraysdemo3 {public static void main(String[] args) {int[] arrays ={1,2,3,4,5};//JDK1.5,没有下标
//        for (int array : arrays) {//            System.out.println(arrays);
//        }
//        printArray(arrays);int[] reverse = reverse(arrays);printArray(reverse);}//打印数组元素public static void printArray(int[] arrays){for (int i = 0; i < arrays.length; i++) {System.out.print(arrays[i]+" ");}}//反转数组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;}
}

多维数组

1.多维数组可以看成是数组的数组，比如二维数组就是一个特殊的一维数组，其每一个元素都是一个一维数组。
2.二维数组

int a[][] = new int[2][5];

二维数组a可以看成一个两行五列的数组。

public class arraysdemo4 {public static void main(String[] args) {//四行两列[4][2]int[][] array = {{1,2},{2,3},{3,4},{4,5}};
//        System.out.println(array[0]);//输出的是数组的第一行for (int i = 0; i < array.length; i++) {for(int j =0;j<array[i].length;j++){System.out.println(array[i][j]);}}}
}

Arrays类讲解

1.数组的工具类java.util.Arrays
2.有余数组对本身并没有什么方法可以供我们调用，但API提供了一个工具类Arrays供我们使用，从而可以对数据对象进行一些基本的操作。
3.查看JDK帮助文档
4.Arrays类中的方法都是static修饰的静态方法，在使用的时候可以直接使用类名进行调用，而“不用”适用对象来调用（注意：是“不用”而不是“不能”）
5.具有以下功能：
I.给数组赋值：通过fill的方法
II.对数组排序：通过sort方法，按升序。
III.比较数组：通过equals方法比较数组中元素值是否相等。
IV.查找数组元素：通过binarySearch方法能对排序好的数组进行二分查找法操作。

import java.util.Arrays;
public class arraysdemo5 {public static void main(String[] args) {int[] a = {1,2,3,4,45,77,5,7567};Arrays.sort(a);//数组进行排序：升序System.out.println(Arrays.toString(a));//填充数组Arrays.fill(a,2,4,0);//对数组2号和4号进行填充System.out.println(Arrays.toString(a));}
}

冒泡排序

import java.util.Arrays;
public class arraysdemo6 {public static void main(String[] args) {int[] a={1,4,6,89,5,43,66};int[] sort = sort(a);System.out.println(Arrays.toString(sort));}//冒泡排序//1.比较数组种，两个相邻的元素，如果第一个比第二个数大，我们就交换他们的位置//2.每一次比较都会产生一个最大或者最小的数字//3.下一轮则可以少一次排序！//4.依次循环，直到结束!public static int[] sort(int[] arrays){int temp = 0;//外层循环，判断我们这个要走多少次for (int i = 0; i < arrays.length-1; i++) {//内层循环，比较判断两个数，如果第一个数比第二个数大，则交换位置for (int j = 0; j < arrays.length-1-i; j++) {if(arrays[j+1]>arrays[j]){temp = arrays[j];arrays[j] = arrays[j+1];arrays[j+1] = temp;}}}return arrays;}
}

稀疏数组

1.当一个数组中大部分元素为0时；或者为同一值得数组时，可以使用稀疏数组来保存该数组。
2.稀疏数组的处理方式：
记录数组一共有几行几列，有多少个不同值，
把具有不同值的元素和行列及值记录在一个小的数组中，从而缩小程序的规模。

public class arraysdemo7 {public static void main(String[] args) {//创建一个二维数组 11*11    0：没有棋子，   1：黑棋    2：白棋int[][] array = new int[11][11];array[1][2] = 1;array[2][3] = 2;System.out.println("输出原有的数组：");for (int[] ints : array) {for(int anInt : ints){System.out.print(anInt+"\t");}System.out.println();}//转化为稀疏数组保存//获取有效值的个数int sum = 0;for (int i = 0; i < 11; i++) {for(int j=0;j<11;j++){if(array[i][j]!=0){sum++;}}}System.out.println("有效值的个数:"+sum);//创建一个稀疏数组的数组int[][] arr = new int[sum+1][3];arr[0][0] =11;arr[0][1] =11;arr[0][2] =sum;//遍历二维数组，将非零的值存放稀疏数组中int count=0;for (int i = 0; i < array.length; i++) {for (int j = 0; j <array[i].length; j++) {if(array[i][j]!=0){count++;arr[count][0] = i;arr[count][1] = j;arr[count][2] = array[i][j];}}}//输出数组System.out.println("稀疏数组");for (int i = 0; i < arr.length; i++) {System.out.println(arr[i][0]+"\t"+arr[i][1]+"\t"+arr[i][2]+"\t");}}
}

面向对象(oop)

类的对象和创建

首先讲解什么是面向对象
面向对象编程的本质就是：以类的方式组织代码，以对象的组织（封装）数据。
三大特性：
封装，继承，多态

从认识论角度考虑是先有对象后有类。对象，是具体的事物。类，是抽象的，是对对象的抽象。

从代码运行角度考虑实现又类后有对象。类是对象的模板。

类的对象和创建是使用new关键字创建对象
1.使用new关键字创建的时候，除了分配内存空间之外，还会给创建好的对象进行默认的初始化以及对类中构造起的调用。
2.类中的构造器也称为构造方法，是在进行创建对象的时候必须要调用的。并且构造其有以下两个特点：
I.必须和类的名字相同
II.必须没有返回类型，也不能写void

构造器详解

创建对象内存分析

代码实例

画图分析

封装

封装（数据的隐藏）通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，者成为信息隐藏。用alt+insert构造有参和无参。
属性私有：get/set

继承

1.继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模，
2.extends的意思是“扩展”。
3.java中类只有单继承，没有多继承！
4.继承是类和类之间的一种关系，除之之外，类和类之间的关系还有依赖，组合，聚合。继承关系的两个类，一个为子类（派生类），一个为父类（基类），子类继承父类使用关键字extend是来表示。

super详解

注意点：
1.super 调用父类的构造方法，必须在构造方法的第一个
2.super 必须只能出现在之类的方法或者构造方法中！
3.super 和 this 不能同时调用构造方法

VS this详解

注意点：
1.this：本身调用者这个对象，没有也可以使用，this（）本类的构造
super：代表父类对象的应用，只能在继承条件才可以使用，super（）父类的构造。

方法的重写

重写：需要有继承关系，子类重写父类的方法

1.方法名必须相同

2.参数列表必须相同

3.修饰符:范围可以扩大但不能缩小。public>protected>default>private

4.抛出的异常：范围可以缩小但不能扩大

多态

1.即同一种方法可以根据发送对象的不同而采用多种不同的行为方式
2.一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多
3.多态存在的条件
I.有继承关系
II.子类重写父类的方法
III.父类引用指向子类对象
4.注意：多态是方法的多态，属性没有多态性

instanceof (类型转换)引用类型

父类如果要执行子类中的方法就需要进行转换！

抽象类

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

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

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

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

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

//抽象类   extends(单继承)   接口可以多继承
public abstract class action {//abstract , 抽象方法只有方法名字，没有方法的实现public abstract void dosomething();//1.不能new这个抽象类，只能靠子类去实现它，约束1//2.抽象类中可以写普通的方法//3.抽象方法必须在抽象类中
========================================
public class application {public static void main(String[] args) {//        //学生类 能调用的方法都是自己的或者继承父类的!
//        student s1 = new student();
//        //person 父类型可以指向子类，但不能调用子类独有的方法
//        person s2 = new student();
//        s2.run();
//        //对象能执行那些方法，主要看对象左边的类型，和右边关系不大！
//        //s2.eat();//子类重写了父类的方法，执行子类的方法
//        s1.eat();}
}
=====================================
public class a extends action{@Overridepublic  void dosomething(){}
}

接口的定义与实现

作用：

1.约束！
2.定义一些方法，让不同的人数实现
3.接口不能被实例化，接口中没有构造方法
4.imple门头石可以实现多个接口
5.必须要重写接口中的方法

N中内部类

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

2.成员内部类
3.静态内部类
4.局部类部类
5.匿名内部类

public class outer {//局部内部类public void method(){class inner{public void in(){System.out.println("这是局部内部类的方法");}}}
}

java异常

Error和Exception

什么是异常：
1.异常之程序运行中出现的不期而至的各种状况，如：文件找不到，网络连接失败，非法参数等。

2.异常发生在程序运行期间，他影响了正常的程序执行流程。

3.软件程序运行过程中，非常可能遇到刚刚提到的这些异常问题，我们叫异常，英文是；Exception。

public class demo1 {public static void main(String[] args) {System.out.println(11/0);//出错}public void a(){b();//出错}public void b(){a();//出错}
}

简单分类

Error

1.Error类对象由java虚拟机生成并抛出，大多数错误与代码编写者所执行的操作无关。

2.Java虚拟机运行错误（Virtual MachineError），当JVM不再有继续执行操作所需的内存资源时，将出现OutOfMemoryError。这些异常发生时，Java虚拟机（JVM）一般会选择线程终止。

3.还有发生在虚拟机师徒制性应用时，如类定义错误（NoClassDefFoundError），连接错误（LinkageError）。这些错误是不可查的，因为他们在应用的程序的控制和处理能力之外，而且绝大多数是程序运行时不允许出现的状况。

捕获和抛出异常

抛出异常

throws是用来声明一个方法可能抛出的所有异常信息，throws是将异常声明但是不处理，而是将异常往上传，谁调用我就交给谁处理。而throw则是指抛出的一个具体的异常类型

throws是用在方法名尾部，可以声明抛出多个溢出，多个溢出之间用逗号隔开。

import java.io.*;
public class className{public void withdraw(double amount) throws RemoteException,InsufficientFundsException{//Method implementation}//Remainder of class definition
}

throw是用在方法体内，主动抛出异常

public class ThrowTest{public static void main(String[] args){int a = 1;int b = 0;try{System.out.println(divide(a,b));}catch (Exception e){System.out.println("分母不能为0");//e.printStackTrace();}}public static double divide(int a,int b){if(b == 0){//主动抛出异常throw new ArithmeticException();}return 1.0*a/b;}
}

五个关键字try、catch、finally、throw、throws

1.使用try和catch关键字可以捕获异常。try/catch代码块放在异常可能发生的地方。

2.try/catch代码块中的代码称为保护代码。

3.finally区可以不要，在IO流，资源关闭时使用。

4.捕获多个溢出：从小到大！

5.快捷键：选中健康区域代码–>Ctrl + Alt + T

public static void main(String[] args) {int a=1;int b=0;try{//try监控区域System.out.println(a/b);}catch (Error e){System.out.println("程序出现异常，变量b不能为0");}catch(Exception e){System.out.println("Exception");}catch (Throwable t){System.out.println("Throwable");}finally {System.out.println("finally");}}public void a(){b();}public void b(){a();}

自定义异常及经验小结

总结
1.处理运行是异常时，采用逻辑去合理规避，同时辅助try-catch处理
2.在多重catch块后面，可以加一个catch（Exception）来处理可能会被遗漏的异常
3.对于不确定的代码，也可以加上try-catch，处理潜在的异常
4. 尽量去处理异常，切忌只是简单的调用printStackTrace()去打印输出
5.具体如何处理异常，要根据不同的业务需求和异常类型去决定
6. 尽量添加finally语句块去释放占用的资源。