JAVA基础——数组、面向对象

已于 2023-02-20 10:12:41 修改
阅读量1.4k 收藏 4
点赞数 1
文章标签： java java-ee
于 2023-02-15 14:34:50 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_56451428/article/details/128901165
版权

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

文章目录

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 数据结构——稀疏数组

稀疏数组介绍-来源bilibili狂神说Java

二、面向对象

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();//主动抛出异常，一般在方法中使用
        }
    }
}
willow3949
关注
java面向对象7：对象数组
kerryqpw的博客
12-31 275
对象数组的应用领域:歌曲播放器中，播放列表是对象数组; 订单中的商品列表; 贪食蛇的格子身体。 掌握对象数组是学习java的集合的基础。 对象数组 所谓对象数组，是对象的元素不是基本类型，而是引用类型。 Point[] ps = new Point[3]; ps[0] = new Point(1,2); ps[1] = new Point(3,4); ps...
Java基础语法——数组
weixin_52493276的博客
07-25 334
Java基础语法——数组的了解与应用。
Java中的对象数组
热门推荐
hgh1998的博客
05-09 1万+
Java对象数组 在创建后，基本数据类型数组可以直接对数组元素赋值、引用等操作；而自定义对象数组，需要对数组中的每个对象元素独立进行创建，然后才可以对其赋值、引用等操作，如果没有单独对每个对象元素创建，会导致空指针异常 1.基本数据类型数组 数组都要先声明、再创建后使用。基本数据类型数组的声明有以下几种格式（以int类型为例）：①int[]array；②int[]array=new int；③in...
Java对象数组
zhangyan_1010的专栏
05-22 1305
在Java中，对象数组是指由对象类型的元素组成的数组。与基本类型数组不同，对象数组可以存储对象的引用。对象数组的声明和初始化方式与基本类型数组类似。其中，ClassName 是指对象类型的类名，arrayName 是对象数组的名称，arrayLength 是数组的长度。对象数组在Java中具有广泛的用途。它们允许存储和操作多个对象的引用，使代码更加灵活和可扩展。无论是存储对象集合、实现数据结构还是进行排序和搜索，对象数组都是一个重要的数据结构。
java中的对象数组
m0_62642719的博客
04-08 2608
/* * 对象数组练习 * */ public class Demo6 { int age; String name; char gender; /* * 为所有属性进行赋值 * */ public void SetInfo(int a,String b,char c){ age = a; name = b; gender = c; } /* * 返回当前对象的个人信息 * */ public S.
Java基础教程：从基本数据类型到数组操作与面向对象实现
最新发布
09-23
另外，在面向对象章节中重点介绍了属性封装，提供了快捷生成get、set方法和构造器的具体操作指导。 适用人群：初学者及有一定 Java 编程基础的学习者。 使用场景及目标：适用于那些希望加深对 Java 基础概念理解的...
Java面向对象的编程——数组、集合框架
给我new一个亿的博客
06-14 2662
一、数组 1.数组的定义 数组是为了解决同类数据整合摆放而提出的，可以理解为一组具有相同类型的变量的集合，它的每个元素都具有相同的数据类型。 2.数组的声明 1.<data_type>[] <array_name>; 2.<data_type> <array_name>[]； 例如定义保存学生成绩的语法： 1.float[] scores; 2.float scores[]； 虽说两种写法都没错，但是按照Java语言的变成习惯，推荐各位采用第一种写
Java——（对象数组，Collection集合）
满眼星陈ya的博客
12-13 486
目录 1、对象数组的概述和使用 2、集合的由来及集合继承体系图 3、Collection集合的功能概述 4、Collection集合存储字符串并遍历 1、对象数组的概述和使用 数组作为容器，来存储元素，但是有一些不方便的地方，数组的长度是固定的，一旦定义，就不能改变。 有的时候，我们想要往数组中添加元素，或删除元素，就不是很方便了。 Java考虑到，我们能够更加容易的操作容器中的元素，给我们提供了另外一种容器，就是集合。 集合和数组的区别？ 数组长度是固定的，一旦定义，就不...
java初级基础——面向对象—案例：用户注册登录
Daw3on的博客
10-14 2996
java是面向对象的语言 概念点： 面向对象 面向过程 面向过程：将现实生活中的事物 按照发生的顺序使用代码顺序执行 面向对象：将现实生活中的事物，封装成对象，通过对象的实例化和调用，完成需求 重要概念 ： 抽象(暂讲一个) ： 将现实中的事物 抽取外部特征和方法 。使用类来表示 课题案例： 1.通过面向对象的思维 完成登陆注册系统 ； 1.1用户需要输入用户名 密码进行验证 1.2由登陆系统给出...
java对象数组
m0_64932024的博客
05-14 2938
●所谓对象数组，就是包含了一组相关的对象，但是在对象数组的使用中读者一定要清楚一点，数组一定要先开辟空间，但是因为其是引用数据类型，所以数组里面的每一个对象都是null值，则在使用的时候数组中的每一个对象必须分别进行实例化操作。●所谓对象数组，就是包含了一组相关的对象，但是在对象数组的使用中读者一定要清楚一点，数组一定要先开辟空间，但是因为其是引用数据类型，所以数组里面的每一个对象都是null值，则在使用的时候数组中的每一个对象必须分别进行实例化操作。♦类 对象数组名称[] new 类[数组长度]；
java-对象数组
weixin_56025182的博客
05-29 602
在创建对象数组时，我们需要首先使用 `new` 关键字创建一个数组对象，然后再为其分配内存空间，最后将实例对象存储到数组中。
java中对象数组
zry2580的博客
05-10 314
定义类Student，包含三个属性：学号number(int)，年级state(int)，成绩score(int)。 创建20个学生对象，学号为1到20，年级和成绩都由随机数确定。 问题一：打印出3年级(state值为3）的学生信息。 问题二：使用冒泡排序按学生成绩排序，并遍历所有学生信息 提示： 生成随机数：Math.random()，返回值类型double; 四舍五入取整：Math.round(double d)，返回值类型long。 代码实现： public class StudentTest {
Java值数组和对象数组
睡猫的博客
03-02 511
Java主数据类型数组里装的是主数据类型，如int，每个都是在堆了占空间的。 Java对象类型数组装的都是引用类型，就当时一堆指针，一堆“遥控器”，只有创建实例后，才指向堆里的实例。 Dog[ ] pets; pets = new Dog[7];  //产生7个指向null的Dog对象 pets[0] = new Dog(); //创建Dog实例，并让pets[0]指向该实例 再
java 数组对象
mutou_user的专栏
09-09 584
 java中数组到底是什么？ 1）不管在其他语言中是什么，数组在Java中可得看作一个对象，它有一些值得探讨的特性。 Java中的数组其实是一个对象，但是确实是一个特殊的对象，实在是太特殊了，以致我们都不好把它多做对象处理。 java是纯面向对象的语言，数组也是一个对象。 首先我们看一下表面现象，数组创建的时候采用的是如下语句： MyClass[] arr = ne
JAVA面向对象数组
2301_78096305的博客
05-11 1117
（4）数组变量引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量，数组本身就是对象，java中对象是堆中的，因此数组无论保存原始类型还是其他对象类型，数组对象本身是在堆中的。多维数组：可以看成是数组的数组，比如二维数组就是一个特殊的一维数组，其每一个元素都是一个一维数组。//打印数组元素用Arrays.toString。
Java 7教程：面向对象基础详解
Java语言程序设计教程（Java 7）——入门与提高篇03主要涵盖了面向对象编程的基础知识，这是Java编程的核心概念。下面将详细解释这些知识点。 3.1 面向对象的基本概念 面向对象编程（OOP）是一种编程范式，它基于...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

willow3949

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值