JAVA基础——数组、面向对象
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档
文章目录
- JAVA基础
- 三、方法
- 一、数组
-
-
- 1 数组基础
-
- 1.1 数组初始化
- 1.2 数组的四个基本特点
- 1.3 数组的使用
- 1.4 多维数组
- 2、数组的应用
-
- 2.1 Arrays 类
- 2.2 排序算法（8种）
-
- （1）冒泡排序
- 2.3 数据结构——稀疏数组
-
- 二、面向对象
-
-
- 1 面向过程思想
- 2 面向对象思想
- 3 面向对象编程（Object-Oriented Programing，OOP）
- 4 方法
-
- 4.1 方法的定义
- 4.2 方法的调用
- 4.3 实参和形参
- 4.4 值传递和引用传递
- 5 类与对象的关系
-
- 5.1 创建与初始化对象
- 5.2 类、对象、实例化
- 5.3 构造器
- 6、创建对象内存分析
- 7、封装、多态、继承
-
- 7.1 封装
-
- (1)属性私有（private）：get/set
- 7.2 继承
-
- (1)object 类
- (2)Super和 this
- (3) private、default、projected、public的优先级
- (4)方法的重写
- 7.3多态
-
- (1)instanceof关键字类型转换
- (2)Static 总结
- (3)抽象类——abstract*
- (4)接口
- (5)内部类
- 8、异常
-
JAVA基础
提示：这里可以添加本文要记录的大概内容：
例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。
提示：以下是本篇文章正文内容，下面案例可供参考
三、方法
一、数组
1 数组基础
1.1 数组初始化
静态初始化、动态初始化
//静态初始化：创建+赋值
int[] a={1,2,3,4,5,6,10};
//动态初始化:包含默认初始化即没有被赋值的元素就是0
int[] b=new int[10];
b[0]=10;
1.2 数组的四个基本特点
（1）其长度是确定的，数组一旦被创建，他的大小不可以改变
（2）其元素必须是相同类型，不允许出现混合类型
（3）数组中的元素可以是任何数据类型，包括基本类型和引用类型
（4）数组变量引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量，数组本身就是对象，java中对象是堆中的，因此数组无论保存原始类型还是其他对象类型，数组对象本身是在堆中的。
1.3 数组的使用
遍历数组、查找数组中的最大值、反转数组、打印数组
int[] array={1,2,3,4};
//遍历数组
for (int i=0;i<array.length;i++){
System.out.println(array[i]);
}
//查找数组中的最大元素
public static void main(String[] args) {
int[] array={1,98,78,30,50};
int max=array[0];
for (int i = 0; i < array.length; i++) {
if(array[i]>max){
max=array[i];
}
}
System.out.println(max);
}
public static void main(String[] args) {
int[] arrays = {1, 2, 3, 4, 6};
//printArray(arrays);
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.4 多维数组
多维数组：可以看成是数组的数组，比如二维数组就是一个特殊的一维数组，其每一个元素都是一个一维数组。
(a) 二维数组打印某一个数
(b)二维数组打印某一行
© 二维数组的打印方式
public static void main(String[] args) {
int a[][]=new int[2][5];
int[][] array={{1,2},{3,4}};
printArray(array[0]);//打印array第0行
printArray(array[1]);//打印array第1行
System.out.println(array[0][1]);//打印array的第0行第一个元素
System.out.println(array[0][0]);//打印array的第0行第0个元素
//打印二维数组的方式：
for (int i = 0; i < array.length; i++) {
for (int j = 0; j < array[i].length; j++) {
System.out.println(array[i][j]);
}
}
}
//打印数组
public static void printArray(int[] array){
for (int i = 0; i <array.length ; i++) {
System.out.print(array[i]+" ");
}
}
2、数组的应用
2.1 Arrays 类
数组的工具类java.util.Arrays
由于数组对象本身并没有什么方法可以供我们调用，但API中提供了一个工具类Arrays供我们使用，从而可以对数据对象进行一些基本的操作。
查看JDK帮助文档
Arrays类中的方法都是Static修饰的静态方法，在使用的时候可以直接使用类名进行调用，而“不用”使用对象来调用（注意：是“不用”而不是“不能”）
具有以下常用功能：
1、给数组赋值：通过fill方法
2、对数组排序：通过sort方法，按升序
3、比较数组：通过equals方法比较数组中元素值是否相等
4、查找数组元素：通过binarySearch方法能对排序好的数组进行二分查找法操作。
打印数组:Arrays.toString
自己仿照Arrays类进行打印数组
public static void main(String[] args) {
int[] a={1,27,3,4,566,788,4};
System.out.println(a);//[I@1540e19d
//打印数组元素用Arrays.toString
System.out.println(Arrays.toString(a));
printArray(a);
}
//自己的方法打印
public static void printArray(int[] a) {
for (int i = 0; i < a.length; i++) {
if(i==0){
System.out.print("[");
}
if(i==a.length-1){
System.out.print(a[i]+"]");
}else {
System.out.print(a[i]+", ");
}
}
}
Arrays.sort 升序排序打印数组
public static void main(String[] args) {
int[] a={234,556,67,254,66,43};
Arrays.sort(a);//数组排序
System.out.println(Arrays.toString(a));//打印数组元素
}
Arrays.fill 数组填充：将数组所有元素都填充成val的值：
public class Demo3_Arrayssort {
public static void main(String[] args) {
int[] a={234,556,67,254,66,43};
Arrays.sort(a);//数组排序
System.out.println(Arrays.toString(a));//打印数组元素
Arrays.fill(a,0);//数组填充
System.out.println(Arrays.toString(a));
Arrays.fill(a,2,4,0);//第二个元素到第四个元素之间被0填充
System.out.println(Arrays.toString(a));
}
}
//打印结果：
// [43, 66, 67, 234, 254, 556]
//[0, 0, 0, 0, 0, 0]
//[43, 66, 0, 0, 254, 556]
2.2 排序算法（8种）
（1）冒泡排序
比较数组中两个相邻的元素，如果第一个数比第二数大就交换位置；
每一次比较都会产生出一个最大或者最小的数字；
下一轮则可以少一次排序；
依次循环，直到结束。
public static void main(String[] args) {
int[] a={2,8,9,5,74,23};
int[] sorts=sorta(a);//调用完我们自己写的排序方法以后，返回一个排序后的数组
System.out.println(Arrays.toString(sorts));
}
//冒泡排序
public static int[] sorta(int[] a) {
int temp=0;
//外层循环，判断我们这个要走多少次
for (int i = 0; i <a.length-1 ; i++) {
//内层循环，比较判断2个数，第一个比第二个数大就交换位置
for (int j = 0; j <a.length-1-i ; j++) {
if (a[j]>a[j+1]){
temp=a[j];
a[j]=a[j+1];
a[j+1]=temp;
}
}
}
return a;
}
2.3 数据结构——稀疏数组
二、面向对象
1 面向过程思想
步骤清晰简单，第一步做什么，第二步做什么…
面对过程适合处理一些较为简单的问题
2 面向对象思想
物以类聚，分类的思维模式，思考问题首先会解决问题需要哪些分类，然后对这些分类进行单独思考。最后，才对某个分类下的细节进行面向过程的思索。
面向对象适合处理复杂的问题，适合处理需要多人协作的问题！
总结： 对于描述复杂的事物，为了从宏观上把握、从整体上合理分析，我们需要使用面向对象的思路来分析整个系统。但是，具体到微观操作，仍然需要面向过程的思路去处理。
3 面向对象编程（Object-Oriented Programing，OOP）
**面向对象编程的本质：**以类的方式组织代码，以对象的组织（封装)数据。
三大特性： 封装、继承、多态
从认识角度考虑是先有对象后有类。对象，是具体的事物。类，是抽象的，是对对象的抽象。
从代码运行角度考虑是先有类后有对象。类是对象的模板。
4 方法
4.1 方法的定义
修饰符
返回类型
break：跳出Switch，结束循环和return的区别
方法名：注意规范就ok，驼峰命名+见名如意
参数列表：（参数类型，参数名）…
异常抛出：IOException
4.2 方法的调用
静态方法
非静态方法
形参和实参
值传递和引用传递
this关键字
方法：
修饰符 返回值类型 方法名（…）{
//方法体
return 返回值；
}
public String sayhello(){
return "hello world";
}
public void hello(){
return;//void类型 返回是空
}
public int max(int a,int b){
return a>b?a:b;//三元运算符：如果a大于b就返回a，否则返回b
}
//抛出异常
//数组下标越界异常：ArrayIndexOutOfBoundsException
public void readFile(String file)throws IOException{
}
方法的调用
想要调用学生类（静态方法）：直接类.方法名
public class Demo02 {
public static void main(String[] args) {
//静态方法:类名.方法名
Student.say();
}
}
//学生类
public class Student {
//静态方法
public static void say(){
System.out.println("学生说话了");
}
}
想要调用学生类（非静态）：需要new这个方法
public class Demo02 {
public static void main(String[] args) {
//非静态方法：
//实例化这个类 new
//对象类型 对象名=对象值
Student student=new Student();
student.say();
}
}
public class Student {
//非静态方法
public void say(){
System.out.println("学生说话了");
}
}
两个方法同时是static，互相调用不出错
两个方法同时不是static，互相调用也不出错
一个方法是static，一个方法不是static时，调用会出错
原因如下：
//和类一起加载的
public static void a() {
b();
}
//类实例化之后才存在
public void b() {
}
4.3 实参和形参
实际参数和形式参数的类型要对应
public class Demo03 {
public static void main(String[] args) {
int add=Demo03.add(1,2);//实参
System.out.println(add);
}
public static int add(int a,int b){//形参
return a+b;
}
}
4.4 值传递和引用传递
1、值传递
//值传递
public class Demo03 {
public static void main(String[] args) {
int a=1;
System.out.println(a);
Demo03.change(a);
System.out.println(a);//a=1
}
//返回值为空
public static void change(int a){
a=10;
}
}
2、引用传递
引用传递：对象，本质还是值传递
//引用传递：对象，本质还是值传递
public class Demo04 {
public static void main(String[] args) {
Person person=new Person();
System.out.println(person.name);//null
Demo04.change(person);
System.out.println(person.name);//杨晨晨
}
public static void change(Person person) {
//person是一个对象：指向的--->Person person=new Person()
person.name="杨晨晨";
}
//定义一个Person类，有一个属性：name
}
class Person{
String name;//null
}
5 类与对象的关系
类是一种抽象的数据类型，它是对某一类事物整体描述/定义，但是并不能代表某一个具体的事物
例如：动物、植物、手机、电脑…
Person类、Pet类、Cat类等，这些类都是用来描述/定义某一类具体的事物应该具备的特点和行为
对象是抽象概念的具体实例
例如：张三就是人的一个具体实例，张三家里的旺财就是狗的一个具体实例
能够体现出特点，展现出功能的是具体的实例，而不是一个抽象的概念。
5.1 创建与初始化对象
使用new关键字创建对象
使用new关键字创建的时候，除了分配内存空间之外，还会给创建好的对象进行默认的初始化以及对类中构造器的调用。
类中的构造器也称为构造方法，是在进行创建对象的时候必须要调用的。并且构造器有以下2个特点：
1、必须和类的名字相同
2、必须没有返回类型，也不能写void。
5.2 类、对象、实例化
一个类中只有属性和方法
类是抽象的，需要被实例化
学生guoyu是类的对象，
创建类的对象的过程就是类的实例化：使用new关键字来实例化一个对象
以下方代码举例：
类=学生
类的对象=学生guoyu
类的实例化=创建对象的过程
//学生类
public class Student {
//属性：字段
String name;//null
int age;//0
//方法
public void study(){
System.out.println(this.name+"在学习");
}
}
public class Aplication {
public static void main(String[] args) {
//类：抽象的，实例化
//guoyu是类的对象，创建类的对象的过程就是类的实例化。
//类实例化后会返回一个自己的对象！
//国宇对象就是一个Student类的具有实例！
Student guoyu = new Student();//类的实例化=创建对象的过程
Student yangchenchen = new Student();
guoyu.name="国宇";
guoyu.age=18;
System.out.println(guoyu.name);
System.out.println(guoyu.age);
}
}
5.3 构造器
Alt+insert 一键生成有参无参构造器
使用new关键字，本质是调用构造器
构造器一般用来初始化值
例如：无参构造
//学生类
public class Student {
//一个类即使什么都不写，它也会存在一个方法
// 显示的定义构造器
String name;
//实例化初始值
//使用new关键字，本质是调用构造器
//无惨构造
public Student(){
this.name="杨晨晨";
}
}
public class Aplication {
public static void main(String[] args) {
//new 实例化了一个对象
Student student = new Student();
System.out.println(student.name);//杨晨晨
}
}
有参构造
（1）一旦定义了有参构造，无参构造必须要写上去，否则new实例化时会报错！
//学生类
public class Student {
String name;
//无参构造
public Student(){}//很重要！！！
//有参构造
public Student(String name){
this.name=name;
}
}
public class Aplication {
public static void main(String[] args) {
//new 实例化了一个对象
Student student = new Student();
System.out.println(student.name);//杨晨晨
}
}
（2）有参构造——new实例化传参数
传递结果只走有参的。
//学生类
public class Student {
String name;
//无参构造
public Student(){}
//有参构造
public Student(String name){
this.name=name;
}
}
public class Aplication {
public static void main(String[] args) {
//new 实例化了一个对象
Student student = new Student("yangchenchen");
System.out.println(student.name);//杨晨晨
}
}
6、创建对象内存分析
栈：方法和变量的引用
堆：存放具体创建出来的对象
下图的具体流程详解及其代码：
1、main方法在栈里的最底下，当栈结束时会被弹出。首先程序先从Application_pet类中进来,进入main函数。
2、当执行到new Pet()时会跳转到宠物Pet类，此时实例化对象dog就有了name和age这两个属性，以及shout方法；但是此时的name 和age没有值。
3、接下来定义dog的name名字叫“富贵”，dog的age是3。此时的dog这个名字是在栈里，真正的dog对象是在堆中，此时name=null，age=0，shout是空。
4、堆中的dog调用方法区的name=‘富贵“，和age=1以及Pet类中的调用的shout()，此时dog就有了名字和年龄。所有的值赋完，dog这个对象在堆中就有值了。以此类推，cat也是，但是cat在方法区中没有赋name和
5、static静态方法区和类一起加载，堆中所有对象都可以调用它。
public class Application_pet {
public static void main(String[] args) {
Pet dog = new Pet();//创建dog对象
dog.age=3;
dog.name="富贵";
dog.shout();
System.out.println(dog.age);
System.out.println(dog.name);
Pet cat = new Pet();//创建cat对象
}
}
public class Pet {
public String name;
public int age;
public void shout() {
System.out.println("叫了一声");
}
}
7、封装、多态、继承
7.1 封装
该露的露，该藏的藏
程序设计要追求“高内聚，低耦合”。高内聚就是类的内部数据操作细节自己完成，不允许外部干涉；低耦合：仅暴露少量的方法给外部使用
封装（数据的隐藏)
通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏。
(1)属性私有（private）：get/set
使用private 的属性，当实例化类后，实例化对象不能直接调用其属性，所以此时要`采用另一个方式，来操作private属性。使用get/set方法
get：获取这个数据；
set：给这个数据设置值
右键 Generate Getter and Setter自动生成get 和set
public class Application {
public static void main(String[] args) {
Student s1 = new Student();
s1.setName("杨晨晨");
s1.setAge(999);//不合法！！！
System.out.println(s1.getName());
System.out.println(s1.getAge());
}
}
public class Student {
//名字
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;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public int getAge() {
return age;
}
public void setAge(int age) {
if(age<120&&age>0){
this.age = age;
}else {
this.age=3;
}
}
}
私有化的意义：
（1）提高程序的安全性、保护数据
（2）隐藏代码的实现细节
（3）统一接口
（4）系统可维护增加了
7.2 继承
继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模。
extends是扩展的意思。子类是父类的扩展。
JAVA中类只有单继承，没有多继承！ 一个儿子只能有一个爸爸；一个爸爸可以有多个儿子！
继承是类和类之间的一种关系，除此之外，类和类之间的关系还有依赖、组合、聚合等。
继承关系的两个类，一个为子类（派生类），一个为父类（基类）。子类继承父类，使用**关键字extends来表示。
子类和父类之间，从意义上讲应该具有“is a“的关系。
(1)object 类
super
方法重写
优先级从高到低
public > protected > default > private
【继承】例子如下程序：
父类：人
子类：学生
即使子类里面什么都没写，但是父类里面定义了属性，所以在new子类的实例化对象时，子类对象可以继承父类的属性。
public class Application {
public static void main(String[] args) {
Student student = new Student();
student.say();
System.out.println(student.money);
}
}
public class Person {
//优先级从高到低
//public
//protected
//default
//private
public int money=10000;
public void say(){
System.out.println("说了一句话");
}
}
public class Student extends Person {
//ctrl+H
}
==================打印结果==================：
说了一句话
10000
在JAVA中，所有的类，都默认直接或者间接继承object类
(2)Super和 this
子类访问父类，
1、想要调用父类的name属性并输出，用super.name
输出当前类的属性值用this.name
2、想要调用父类的构造函数，用super();
super需要注意：
1、super是调用父类的构造方法，必须在构造方法的第一个
2、super必须只能出现在子类的方法或者构造方法中
3、super和this不能同时调用构造方法
super VS this：
1、super和this代表的对象不同：
this：本身调用这个对象
super：代表父类对象的应用
前提
this:没有继承也可以使用
super:只能在继承条件下才可以使用
构造方法
this():本类的构造
super()：父类的构造
public class Aplication {
public static void main(String[] args) {
Student student = new Student();
student.test("杨");
student.test1();
}
}
public class Person {
public Person(){
System.out.println("Person无参执行了");
}
protected String name="ren";
public void print(){
System.out.println("Person");
}
}
public class Student extends Person{
public Student(){
//隐藏代码：默认调用了父类的无参构造
super();//调用父类的构造器，必须要在子类构造器的第一行
System.out.println("Student无参构造执行了");
System.out.println("=======1=======");
}
private String name="yangchenchen";
public void print(){
System.out.println("Student");
}
public void test1(){
print();
this.print();//当前类的public定义的函数
super.print();//父类的public定义的函数
System.out.println("=========3=========");
}
public void test(String name){
System.out.println(name);//传递的参数
System.out.println(this.name);//当前属于哪个类就输出类里面的东西
System.out.println(super.name);//输出的事父类的东西
System.out.println("=========2=========");
}
}
打印结果：
Person无参执行了
Student无参构造执行了
=======1=======
杨
yangchenchen
ren
=========2=========
Student
Student
Person
=========3=========
Process finished with exit code 0
(3) private、default、projected、public的优先级
public>projected>default>private
**public：**所有类均可见
**projected：**同一个包下的类，以及所有子类都可见
**default：**只有同一个包下的类可见
private只对本类可见
(4)方法的重写
重写：非静态条件下是前提，需要有继承关系，子类重写父类的方法！
1、方法名必须相同
2、参数列表必须相同
3、修饰符：范围可以扩大，但不能缩小。
4、抛出的异常：范围，可以被缩小，但不能扩大：ClassNotFoundException–>Exception(大)
口诀：方法看左边，实现看右边！
意思是：先看左边的类名，是Animal，找到Animal的类中是否有bark方法、sleep属性，有的话说明该bark函数、sleep函数可以被调用；再看右边，是Cat类，所以最后实现的结果是Cat中的bark函数里的值，和sleep函数的值，由于Cat类里面没有特殊的sleep函数，Cat是Animal的子类，Cat继承Animal类的所有方法，所以对于sleep函数也可以调用父类的值。代码如下：
//方法看左边，实现看右边！
Animal a1=new Cat();//子类重写了父类的方法
a1.bark();//结果：喵喵喵~
a1.sleep();//结果：Animal is sleeping
完整代码如下：
public class Application {
public static void main(String[] args) {
//方法看左边，实现看右边！
Animal a = new Animal();
a.bark();
Cat b = new Cat();
b.sleep();
//方法看左边，实现看右边！
Animal a1=new Cat();
a1.bark();
a1.sleep();
// Cat c=new Animal();//错误！！！这句话的意思是：动物是猫？所以是错误的
// c.bark();
}
}
public class Animal {
public void bark() {
System.out.println("Animal is barking");
}
public void sleep(){
System.out.println("animals is sleeping");
}
}
public class Cat extends Animal{
@Override
public void bark() {
System.out.println("喵喵喵~");
}
public void eating(){
System.out.println("吃鱼！");
}
}
打印结果：
Animal is barking
animals is sleeping
喵喵喵~
animals is sleeping
Process finished with exit code 0
静态方法与非静态方法的区别很大
重写的前提是在非静态的条件下，如下程序，想要实现cat的bark方法喵喵喵，在非静态的条件下，重写父类方法，达到效果；但是在静态Static条件下，
不能起到重写的效果，所以结果还是父类的bark函数里的结果。代码如下：
public class Animal {
public static void S_bark() {
System.out.println("静态Animal is barking");
}
public void bark() {
System.out.println("非静态Animal is barking");
}
}
public class Cat extends Animal{
public static void S_bark() {
System.out.println("静态喵喵喵~");
}
@Override
public void bark() {
System.out.println("非静态喵喵喵~");
}
}
public class Application {
public static void main(String[] args) {
Animal a1=new Cat();
a1.barking();
a1.bark();
}
}
打印结果：
静态Animal is barking
非静态喵喵喵~
Process finished with exit code 0
7.3多态
动态编译：类型：可扩展性
即同一方法可以根据发送对象的不同而采用多种不同的行为方式。
一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多。
多态存在的条件
有继承关系
子类重写父类的方法
父类引用指向子类对象
注意：多态是方法的多态，属性没有多态性
强转类型：父类和子类之间是有的关系的前提下才可以转换。
类型转换异常：ClassCastException!
强转类型举例代码如下：
Animal a = new Cat();
//由于a是Animal类型的，父类没有eating函数，想要调用子类的eating函数
//可以采用强转类型
((Cat) a).eating();
多态总结：
1、多态是方法的多态，属性没有多态
2、类型转换的前提是：父类和子类，没有关系的类型之间不可以转换
3、当父类和子类的方法名字重复时，需要override进行方法重写
4、以下情况不能进行方法重写：
（1)Static 状态下的方法，它属于类不属于实例
（2）final 常量
（3）private 定义的方法
(1)instanceof关键字类型转换
可以判断两个类之间是否存在父子关系，通过bool类型返回结果如下：
public class Application {
public static void main(String[] args) {
//判断下面是否可以编译通过，就看下面这句话X与y是否为父子类关系，如果没有父子关系，编译就会报错
//X x=new m();
//System.out.println(x instanceof y);
//判断True or false 就看x所指向的类型是不是y的子类型。
//Object>String
//Object > Person > Teacher
//Object > Person > Student
Object object = new Student();
System.out.println(object instanceof Object);//true
System.out.println(object instanceof String);//false
System.out.println(object instanceof Person);//true
System.out.println(object instanceof Teacher);//false Object和Teacher是父子关系，但是Student与teacher无关
System.out.println(object instanceof Student);//true
System.out.println("========================");
Person person = new Student();
System.out.println(person instanceof Object);//true
//System.out.println(person instanceof String);//报错！！Person与String不是父子关系
System.out.println(person instanceof Person);//true
System.out.println(person instanceof Student);//true
System.out.println(person instanceof Teacher);//false
System.out.println("========================");
Student student = new Student();
System.out.println(student instanceof Object);//true
//System.out.println(student instanceof String);//报错！！Student与String不是父子关系
System.out.println(student instanceof Person);//true
System.out.println(student instanceof Student);//true
//System.out.println(student instanceof Teacher);//报错！！Student与String不是父子关系
}
}
(2)Static 总结
（1）静态属性：
（2）静态方法：
静态属性：
public class Student {
private static int age;//静态变量 多线程！
private double score;//非静态变量
public static void main(String[] args) {
Student s1 = new Student();
System.out.println(Student.age);
//System.out.println(Student.score);报错
System.out.println(s1.score);
System.out.println(s1.age);
}
}
静态方法
被final修饰的类，不能被继承——断子绝孙
例如：public final class Person
静态方法举例
public class Student {
public static void go(){
}
public void run(){
}
public static void main(String[] args) {
Student.go();
//Student.run();//报错！！！
go();
//run();//报错！！！
}
}
代码块
public class Student{
{
//代码块（匿名代码块）
//创建对象的时候就出现了，而且是在构造器之前
System.out.println("2匿名代码块");
}
static {
//静态代码块，类一加载就执行，永久执行
System.out.println("1静态代码块");
}
public Student() {
System.out.println("3构造器");
}
public static void main(String[] args) {
Student student = new Student();
System.out.println("======================");
Student student1 = new Student();
}
}
打印结果：
1静态代码块
2匿名代码块
3构造器
======================
2匿名代码块
3构造器
Process finished with exit code 0
(3)抽象类——abstract*
抽象类的所有方法，继承了它的子类，都必须要实现它的方法~
public abstract class Action {
//自己不想实现，找人帮我们实现
//abstract，抽象方法，只有方法名字，没有方法的实现
public abstract void doSomething();
//1、抽象类不能new，只能靠子类去实现它；约束！
//2、抽象类可以写普通方法
//3、抽象方法必须在抽象类中
//抽象的抽象：约束~
}
//抽象类的所有方法，继承了它的子类都必须要实现它的方法
public class A extends Action {
@Override
public void doSomething() {
}
}
(4)接口
普通类：只有具体实现
抽象类：具体实现和规范（抽象方法）都有！
接口：只有规范！自己无法写方法专业的约束！约束和实现分类：面向接口编程~
接口就是规范，定义的是一组规则，体现了现实世界中“如果你是…则必须能…"的思想。如果你是天使，则必须能飞。如果你是汽车，则必须能跑。如果你是好人，则必须干掉坏人。
接口的本质是契约，就像我们人间的法律一样。制定好后大家都遵守。
接口的精髓，是对对象的抽象，最能体现这一点的就是接口，为什么我们讨论设计模式都只针对具备了抽象能力的语言（比如C++、java、c#等），就是因为设计模式所研究的，实际上就是如何合理的去抽象。
声明类的关键字是class，声明接口的关键字是interface。
接口和类的区别：类有方法的实现，接口没有，接口只有方法的定义。
接口中所有定义的方法其实都是抽象的public abstract
接口中所有定义的属性都是常量，是public static final
//接口定义：
public interface UserService {
//常量 public static final
int AGE=99;
//接口中的所有定义其实都是抽象的public abstract
void add(String name);
void delete(String name);
void update(String name);
void query(String name);
}
//接口定义：
public interface TimeService {
void timer();
}
实现多继承-不同的接口不同方法继承
public class UserServiceimpl implements UserService,TimeService{
@Override
public void add(String name) {
}
@Override
public void delete(String name) {
}
@Override
public void update(String name) {
}
@Override
public void query(String name) {
}
@Override
public void timer() {
}
}
总结
1、接口不能被实例化~接口中没有构造方法
2、接口负责定义一些方法，让不同的人去实现
3、接口可以实现多个，用implements可以实现多个接口
4、实现接口必须要重写接口中的方法
(5)内部类
内部类就是一个类的内部在定义一个类，比如，A类中定义一个B类，那么B类相对A类来说就称为内部类，而A类相对B类来说就是外部类了。
1、成员内部类
2、静态内部类
3、局部内部类
4、匿名内部类
public class Application {
public static void main(String[] args) {
Outer outer = new Outer();
//通过外部类实例化对象内部类
Outer.Inner inner = outer.new Inner();
inner.in();
inner.getID();
}
}
public class Outer {
private int id;
public void out(){
System.out.println("这是外部类的方法");
}
public class Inner{
public void in(){
System.out.println("这是内部类的方法");
}
//获得外部类的私有属性
public void getID(){
System.out.println(id);
}
}
}
局部内部类、内部类
一个java类中可以有多个class类，但只能有一个public class
public class Outer {
public void method(){
//局部内部类
class Inner{
public void in(){
}
}
}
}
//一个java类中可以有多个class类，但只能有一个public class
class A{
}
public class Outer {
public static void main(String[] args) {
//没有名字去初始化类
new Apple();
//类同样可以调用方法,不用将实例保存到变量中
new Apple().eat();
new UserService(){
};
}
}
class Apple {
public void eat(){
System.out.println("1");
}
}
interface UserService{
}
8、异常
异常处理机制
·抛出异常
·捕获异常
异常处理五个关键字
try catch finally throw throws
在程序中使用自定义异常类，大体可以分为以下几个步骤：
1、创建自定义异常类
2、在方法中通过throw关键字抛出异常
3、如果在当前抛出异常的方法中处理异常，使用
public class Test {
public static void main(String[] args) {
int a=1;
int b=0;
try {//try监控区域
System.out.println(a/b);
}catch (ArithmeticException e){//catch 捕获异常
System.out.println("程序出现异常，变量b不能为0");
}finally {//处理善后工作
System.out.println("finally");
}
}
}
主动抛出异常:
在方法里面抛出异常是throw
在方法上抛出异常是throws
public class Test {
public static void main(String[] args) {
new Test().test(1,0);
}
public void test(int a,int b){
if (b==0){
throw new ArithmeticException();//主动抛出异常，一般在方法中使用
}
}
}