JAVA学习笔记

最新推荐文章于 2022-07-30 15:05:16 发布
最新推荐文章于 2022-07-30 15:05:16 发布
阅读量137 收藏
点赞数
分类专栏： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40478314/article/details/111566089
版权

break和continue

//break通过标号跳出循环
        da:for(int i=0;i<3;i++)
        {
            xiao:for(int j=0;j<3;j++)
            {
                System.out.println("j:"+j);
                if(j==2)
                {
                    break da;
                }
            }
        }
        
        //continue
        
        da:for(int i=0;i<3;i++)
        {
            xiao:for(int j=0;j<3;j++)
            {
                if(j==1)
                {
                    continue;
                }
                System.out.println("j:"+j);
            }
        }

数组排序

int[] arr = {33,2,56,7,23,90,32,22};
        //选择排序
        for(int i=0;i<arr.length-1;i++)
        {
            for(int j=i+1;j<arr.length;j++)
            {
                if(arr[i]>arr[j])
                {
                    int temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;
                }
            }
        }

int[] arr = {33,2,56,7,23,90,32,22};
        //冒泡排序
        for(int i=0;i<arr.length-1;i++)
        {
            for(int j=0;j<arr.length-1-i;j++)
            {
                if(arr[j]>arr[j+1])
                {
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }
        for(int i=arr.length;i>0;i--)
        {
            for(int j=0;j<i-1;j++)
            {
                if(arr[j]>arr[j+1])
                {
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }
        //选择排序
        for(int i=0;i<arr.length-1;i++)
        {
        	int num = arr[i];
        	int index = i;
        	for(int j=i+1;j<arr.length;j++)
        	{
        		if(arr[j]<num)
        		{
        			num = arr[j];
        			index = j;
        		}
        	}
        	swap(arr,i,index);
        }

查找
折半查找

public static int halfSearch(int[] arr,int key)
    {
        int max,min,mid;
        min = 0;
        max = arr.length-1;
        mid = (min+max)/2;
        while(arr[mid]!=key)
        {
            if(arr[mid]>key)
                max = mid-1;
            else if(arr[mid]<key)
                min = mid+1;
            if(max<min)
                return -1;
            mid = (min+max)/2;
        }
        return mid;
    }

给一个有序数组，拟插入一个元素，找到插入元素的位置

public static int halfSearch(int[] arr,int key)
    {
        int max,min,mid;
        min = 0;
        max = arr.length-1;
        mid = (min+max)/2;
        while(arr[mid]!=key)
        {
            if(arr[mid]>key)
                max = mid-1;
            else if(arr[mid]<key)
                min = mid+1;
            if(max<min)
                return min;
            mid = (min+max)/2;
        }
        return min;
    }

## 进制转换

 //将数字转换为16进制
    public static void toHex(int num)
    {
        for(int i=0;i<8;i++)
        {
            int temp = num & 15;
            if(temp>9)
                System.out.println((char)(temp-10+'A'));
            else
                System.out.println(temp);
            num = num >>> 4;//右移四位
        }
    }
    //将数字转换为16进制
    public static void toHex(int num)
    {
        trans(num,15,4,8);
    }
    //将数字转换为2进制
    public static void toBinary(int num)
    {
        trans(num,1,1,32);
    }
    //将数字转换为8进制
    public static void toOcl(int num)
    {
        trans(num,7,3,16);
    }
    public static void trans(int num,int base,int offset,int len)
    {
        if(num==0)
        {
            System.out.println('0');
            return ;
        }
        char[] chs = {'0','1','2','3','4',
                    '5','6','7','8','9',
                    'A','B','C','D','E','F'};
        char[] hex = new char[len];
        int pos = 0;
        while(num!=0)
        {
            int temp = num & base;
            hex[pos++] = chs[temp];
            num = num >>> offset;//右移四位
        }
        for(int i=len-1;i>=0;i--)
        {
            System.out.print(hex[i]);
        }
    }

二维数组

		int[][] arr = new int[3][2];//创建一个二维数组，包含3个一维数组，每个一维数组包含2个元素
        int[][] arr1 = new int[2][];//分别对二维数组的每一个一维数组进行初始化
        arr1[0] = new int[1];
        arr1[1] = new int[2];

面向对象
匿名对象

Car c = new Car();//实名
new Car().run()//匿名对象
/*
当对象只对对象方法调用一次时，可以使用匿名对象
*/

static关键字

/*
1，用于修饰成员
2，修饰的成员被所有对象共享
3，static随着类的加载就存在了，优先于对象存在
4，可以直接被类名所调用
5，静态修饰的数据是共享数据，对象中存储的是特有数据
*/
//成员变量与静态变量的区别
/*
1，生命周期不一样
   成员变量随着对象的创建而存在，随着对象被收回而释放
   静态变量随着类的加载而存在，随着类的消失而消失
2，调用方式不同
   成员变量只被对象调用
   静态变量不仅可以被对象调用，还可以被类调用
3，别名不同
   成员变量--实例变量
   静态变量--类变量
4，数据存储位置不同
   成员变量数据：堆内存的对象中，所以也叫对象的特有数据
   静态变量数据：方法区中的静态区，所以也叫对象的共享数据
*/
//static在使用过程中需要注意的细节
/*
1.静态方法只能访问静态成员（非静态方法既可以访问静态成员，也可以访问非静态方法）
2.静态方法不能使用super和this关键字
3.主函数是静态的
*/
//静态什么时候用
/*
1.静态变量
  对象中所具有的成员变量都是相同的，可以用static修饰
2.静态函数
  函数是否访问到对象中的特有数据（非静态变量），需要，函数非静态，不需要函数静态。
*/
class Person{
    public String name;//成员变量，实例变量
    private int age;
    static String country = "cn";//静态变量
}
public class javatest{
        public static void main(String args[]) {
            Person p = new Person();
            System.out.println(p.country);
            System.out.println(Person.country);
    }
}

静态代码块

class staticCodeDemo//用于给类进行初始化
{
    static
    {
        System.out.println("static run");
    }
    void show()
    {
        System.out.println("show run");
    }
}
public class javatest{
        public static void main(String args[]) {
            new staticCodeDemo().show();
            new staticCodeDemo().show();
    }
}

在这里插入图片描述

主函数

//主函数
/*
1.格式是固定的：public static void main(String args[])
2.被jvm所识别和调用
public:权限必须最大
static:不需要对象的，直接用主函数所属类名调用
void:主函数没有具体返回值
main:函数名
args[]:参数列表
*/

类方法要不要加静态？
先写一个数组工具集

public class arrayTool {
    public int getMaxIndex(int[] arr){
        int maxIndex = 0;
        for(int i=0;i<arr.length;i++)
        {
            if(arr[i]>arr[maxIndex])
            {
                maxIndex = i;
            }
        }
        return maxIndex;
    }
}

javatest.java调用

import java.io.*;
public class javatest{
        public static void main(String args[]) {
            int[] arr = {1,2,3,4,5,6,7};
            arrayTool arrayTool = new arrayTool();
            int maxIndex = arrayTool.getMaxIndex(arr);
            System.out.println("the max:"+maxIndex);
    }
}
/*
调用前需要new一个arrayTool对象，考虑加static
*/

方法

public class arrayTool {
    private arrayTool(){}//该类中的方法都是静态的，所以该类不需要创建对象
                        //为了保证不让其他程序创建该类对象，将构造函数私有化
    public static int getMaxIndex(int[] arr){
        int maxIndex = 0;
        for(int i=0;i<arr.length;i++)
        {
            if(arr[i]>arr[maxIndex])
            {
                maxIndex = i;
            }
        }
        return maxIndex;
    }
}

调用程序

import java.io.*;
public class javatest{
        public static void main(String args[]) {
            int[] arr = {1,2,3,4,5,6,7};
            int maxIndex = arrayTool.getMaxIndex(arr);
            System.out.println("the max:"+maxIndex);
    }
}

设计模式

//设计模式
/**
 * 对问题行之有效的解决方式，其实他是一种思想
 * 1.单例设计模式
 *      保证一个类在内存中的对象唯一性
 * 怎么保证对象唯一性？
 * 1.不允许其他程序用new创建该类对象
 * 2.在该类创建一个本类实例
 * 3.对外提供一个方法让其他程序可以获取该对象
 * 步骤：
 * 1.私有化该类构造函数
 * 2.用new在本类创建一个本类对象
 * 3.定义一个公用方法，将该对象返回
 */
class Singal{//饿汉式，类一加载，就有对象
    static Singal s = new Singal();
    private Singal(){}
    public static Singal getInstance()
    {
        return s;
    }
}
class Singal2{//懒汉式，调用getInstance方法时才有对象
    static Singal2 s = null;
    private Singal2(){}
    public static Singal2 getInstance()
    {
        if(s==null)
            s = new Singal2();
        return s;
    }
}
public class javatest{
        public static void main(String args[]) {
            Singal ss = Singal.getInstance();
            Singal sss = Singal.s;
    }
}

继承

/**
 * 当本类的成员和局部变量同名，用this区分
 * this代表本类对象引用
 * 当本类成员和父类成员同名，用super区分
 * super代表父类空间
 */
/**
 * 覆盖注意事项：
 * 1.子类方法覆盖父类方法时，子类权限必须大于等于父类权限。
 * 2.静态只能覆盖静态，或被静态覆盖
 */

/**
 * 子父类中构造函数的特点
 * 在子类构造对象时，父类的构造函数也运行了
 * 因为在子类的构造函数中第一行有个默认的隐式语句：super();
 * 子类的实例化过程：
 * 子类中的所有构造函数默认都会访问父类中的空参构造函数
 * 如果子类构造函数中用this();调用本类的构造函数，就没有super();调用父类构造函数了
 * 因为this();和super();只能在第一行，但是可以保证的是会有其他构造函数调用父类的构造函数。
 */
/**
 * 自类构造对象时先运行父类构造函数，再县式初始化自类成员变量
 */
class A{
    A(){
        show();
    }
    void show()
    {
        System.out.println("A run");
    }
}
class B extends A{
    int num = 9;
    B()
    {
        super();
        System.out.println("B run");
    }
    void show()
    {
        System.out.println("zi run ... "+num);
    }
}
public class javatest{
        public static void main(String args[]) {
            B b = new B();
            b.show();
    }
}

运行结果：
zi run ... 0
B run
zi run ... 9

在这里插入图片描述
final关键字
在这里插入图片描述
抽象類

/**
 * 特點：
 * 1.方法只有聲明沒有實現時，該方法就是抽象方法，用abstract修飾
 * 2.抽象方法只能放在抽象類裏面
 * 3.抽象類不能被實例化，因爲抽象方法沒有意義
 * 4.抽象類必須由其子類覆蓋完所有的抽象方法之後，該子類才能被實例化
 */
 /**
 * 1.抽象類有構造函數，可以為子類進行初始化
 * 2.抽象類可以不定義抽象方法，目的是不讓該類創建對象。AWT的適配器對象就是這種類
 * 通常這個類中的方法有方法體，但是卻沒有類容
 * 3.抽象關鍵字（abstract）不能和private，static，final共存
 */
abstract class demo{
    abstract void show();
}
class demoA extends demo{
    void show(){
        System.out.println("demoA run");
    }
}
public class javatest{
        public static void main(String args[]) {
            demoA b = new demoA();
            b.show();
    }
}

接口

/*
 abstract class AbsDemo
 {
     abstract void show1();
     abstract void show2();
 } 
 儅一個抽象類中的方法都是抽象方法的時候，可以將該抽象類用用另一種形式定義和表示
 接口：interface
 對於接口中常見的成員：這些成員都有固定的修飾符：
 1.全局變量：public   static final
 2.抽象方法：public   abstract
 得出結論：接口中的成員都是公共的
 */
 //一个类可以实现多个多个接口
interface Demo{
    public static final int NUM = 4;
    public abstract void show1();
    public abstract void ahow2();
}
//接口不可以實例化，只能由實現了接口的子類並覆蓋了接口中所有的抽象方法之後，該子類才可以實例化
//否則這樣的子類就是一個抽象類
class DemoImpl implements Demo{
    public void show1(){}
    public void ahow2(){}
}

public class javatest{
        public static void main(String args[]) {
            DemoImpl d = new DemoImpl();
            System.out.println(d.NUM);
            System.out.println(DemoImpl.NUM);
            System.out.println(Demo.NUM);
    }
}
//4
//4
//4

//接口的出现避免了单继承的局限性
interface CC{
    void show();
}
interface MM{
    void method();
}
interface QQ extends CC,MM{//接口与接口之间是继承关系，并且接口可以多继承
    void function();
}
class WW implements QQ{
    //覆盖三个方法
    public void show(){}
    public void method(){};
    public void function(){};
}

在这里插入图片描述
接口和抽象类的区别
在这里插入图片描述
多态
在这里插入图片描述

/**
 * 多态
 * Cat c = new Cat();
 * Animal a = new Cat();//一个对象两种形态
 * 父类引用指向子类对象
 * 一个对象对应着不同类型
 * 多态在代码中的体现：
 *      父类或者接口的引用指向其子类的对象
 * 多态的好处：
 * 		提高了代码的扩展性，前期定义的代码可以使用后期的内容
 * 多态的弊端：
 * 		前期定义的内容不能使用（调用）后期子类特有的内容
 * 多态的前提：
 * 		1.必须有关系，继承，实现
 * 		2.要有覆盖
 */
abstract class Animal{
    abstract void eat();
}
class Dog extends Animal{
    void eat(){
        System.out.println("啃骨头");
    }
    void LookHome(){
        System.out.println("看家");
    }
}
class Cat extends Animal{
    void eat(){
        System.out.println("吃鱼");
    }
    void CatchMouse(){
        System.out.println("抓老鼠");
    }
}
public class javatest{
    public static void main(String args[]) {
            Cat cat = new Cat();
            Dog dog = new Dog();
            method(cat);
            method(dog);
    }
    public static void method(Animal c){
        c.eat();
    }
}
//运行结果
//吃鱼
//啃骨头

Animal cat = new Cat();//自动类型提升，猫对象提升为动物类型,但是特有功能无法访问
                     //功能：限制对特有功能的访问
                     //专业讲：向上提升
cat.eat();
//如果还想用猫的特有功能，可以讲该对象向下转型
Cat cat_ = (Cat)cat;
cat_.eat();
cat_.CatchMouse();
//注意：对于转型，自始至终都是子类对象在做着变化。
//这样不对
//Animal a = new Animal();
//Cat c = (Cat)a;

多态类型判断：instanceof

if(c instanceof Cat){//instanceof 用于判断对象的具体类型。只能用于引用数据类型判断
	Cat c_ = (Cat)c;
	c_.CatchMouse();
}
else if(c instanceof Dog){
	Dog d_ = (Dog)c;
	d_.LookHome();
}
//通常在向下转型前用于健壮性的判断

/**
 * 多态时，成员的特点：
 * 1.成员变量
 *      编译时，参考引用型变量所属的类中是否有调用的成员变量，有，编译通过，没有，编译失败
 *      运行时，参考引用型变量所属的类中是否有调用的成员变量，并运行该所属类中的成员变量
 *      编译和运行都参考左边
 * 2.成员函数（非静态）
 *      编译时，参考引用型变量所属的类中是否有调用的函数，有，编译通过，没有，编译失败
 *      运行时，参考对象所属的类中是否有调用的函数。
 *      编译看左边，运行看右边
 * 3.静态函数
 *      编译和运行都看左边
 *      其实对于静态方法是不需要对象的，直接用类名进行调用
 */

内部类
在这里插入图片描述

//分析事物时，发现事物中还有事物，而且这个事物还在访问被描述事物的内容，这时还有的事物用内部类来描述
//内部类可以加修饰符private protect等
//如果内部类中定义了静态成员，该内部类也必须是静态的
class Outer{
    private int age = 10;
    class Inner{
        private int in_age;
        void show(){
            System.out.println("inner show"+age);
        }
    }
    public void method(){
        Inner i = new Inner();
        i.show();
    }
}

public class javatest{
    public static void main(String args[]) {
        Outer o = new Outer();
        o.method();
        //直接访问外部类中的内部类成员
        Outer.Inner in = new Outer().new Inner();
        in.show();
        //如果内部类是静态的，相当于一个外部类
        //Outer.Inner in = new Outer.Inner();
    }
}
//内部类在局部位置上，只能访问局部位置被final修饰的变量
//运行结果：
//inner show10
/**
 * 内部类访问特点：
 * 1.内部类可以直接访问外部类中的成员
 * 2.外部类
 */
class Outer{
    private int age = 10;
    static class Inner{
        private int in_age;
        void show(){
            System.out.println("inner show");
        }
    }
    public void method(){
        Inner i = new Inner();
        i.show();
    }
}

public class javatest{
    public static void main(String args[]) {
        Outer o = new Outer();
        o.method();
        Outer.Inner in = new Outer.Inner();
        in.show();
        //如果内部类是静态的，相当于一个外部类
    }
}

匿名内部类

/**
 * 匿名内部类，就是内部类的简写格式。
 *      前提：
 *      内部类必须继承或实现一个外部类或接口
 * 格式：new 父类or接口{子类内容}
 */
abstract class Demo{
    abstract void show();
}
class Outer{
    int num = 3;
    /*
    class Inner extends Demo{
        void show(){
            System.out.println("inner show   "+num);
        }
    }
    */
    public void method(){
        // Inner i = new Inner();
        // i.show();
        new Demo(){//匿名内部类：创建一个Demo子类对象
            void show(){
                System.out.println("inner show   "+num);
            }
        }.show();
    }
}

public class javatest{
    public static void main(String args[]) {
        new Outer().method();
        //如果内部类是静态的，相当于一个外部类
    }
}
//运行结果：
//inner show   3

/**
 * 匿名内部类的应用
 *      使用场景一：当函数参数是接口类型时，而且接口中的方法不超过三个
 *      可以用匿名内部类作为实际参数进行传递
 */
abstract class Inner{
    abstract void show1();
    abstract void show2();
}
class Outer{
    int num = 3;
    public void method(){
        Inner in = new Inner(){//匿名内部类：创建一个Demo子类对象
            void show1(){
                System.out.println("inner show1   "+num);
            }
            void show2(){
                System.out.println("inner show2   "+num);
            }
        };
        in.show1();
        in.show2();
    }
}

public class javatest{
    public static void main(String args[]) {
        // Outer o = new Outer();
        // o.method();
        show(new Inner(){
            public void show1(){}
            public void show2(){}
        });
    }
    public static void show(Inner in){
        in.show1();
        in.show2();
    }
}

Object

import javax.crypto.interfaces.PBEKey;
import javax.management.RuntimeErrorException;

/**
 * Object是所有类的根类，具备所有对象的共性内容
 * equals(Object obj):比较两个对象地址
 *      equals方法和equals方法覆盖
 * hashCode方法：返回该对象的哈希码值
 * getClass方法：返回此Object的运行时类
 * toString方法
 */
class Fu //extends Object
{
    Fu(){
        super();
    }
}
class Zi extends Fu{
    int age;
    Zi(int age){
        super();
        this.age = age;
    }
    //比较Zi的年龄，是否一样
    public boolean compare(Zi z){
        return this.age == z.age;
    }
    //public boolean equals(Zi z){//和父类Object的equals重载}
    //一般都会根据对象特有内容覆盖此方法，建立对象是否相同的依据。
    public boolean equals(Object obj)// Object obj = z//重写
    {
        if(!(obj instanceof Zi)){
            throw new ClassCastException("类型错误");
        }
        Zi z = (Zi)obj;
        return this.age==z.age;
    }
    public int hashCode(){
        return this.age;
    }
    public String toString(){
        return "Zi"+"#"+this.age;
    }
}

class objectDemo{
    public static void main(String[] args)
    {
        Zi z1 = new Zi(10);
        Zi z2 = new Zi(10);
        Demo d = new Demo();
        //System.out.println(z1==z2);//false
        //System.out.println(z1.equals(z2));//未覆盖equals：false
        //System.out.println(d.equals(z2));//false
        //System.out.println(z1.equals(z2));//覆盖equals后：true
        System.out.println(Integer.toHexString(d.hashCode()));//1555009629  5caf905d
        System.out.println(z1.hashCode());//10
        System.out.println(z1.getClass());//class Zi
        System.out.println(z2.getClass());//class Zi
        System.out.println(z1);//toString未覆盖：Zi@a
        //toString覆盖：Zi#10
    }
}
菜极的墨墨
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java instanceof 数组_【Java基础】-- instanceof 用法详解
weixin_39770226的博客
02-13 1484
1. instanceof关键字如果你之前一直没有怎么仔细了解过instanceof关键字，现在就来了解一下：instanceof其实是java的一个二元操作符，和=,这些是类似的，同时它也是被保留的关键字，主要的作用，是为了测试左边的对象，是不是右边的类的实例，返回的是boolean值。A instanceof B注意：A是实例，而B则是Class类下面使用代码测试一下：class A{}int...
Java关键字 - instanceof
Clearlight's Blog
09-05 235
一、instanceof介绍 用法 ： 引用变量 instance 类名(接口) 作用 ：它的作用是测试它左边的对象是否是它右边的类的实例，返回boolean的数据类型。 二、instanceof案例 package top.clearlight.coretech.keyword; import java.util.AbstractList; import java.util.ArrayLis...
java instanceof 数组,Java数组反射：IsArray的主场迎战的instanceof
weixin_30998047的博客
02-16 251
Is there a preference or behavior difference between using:if(obj.getClass().isArray()) {}andif(obj instanceof Object[]) {}?解决方案In general, use the instanceof operator to test whether an object is an ...
java 数组 instanceof_java判断对象是否为数组 并且取得数组的值 --- 用instanceof或则isArray() 方法...
weixin_31325725的博客
02-13 747
今天项目逻辑需要传个数组过去..然后调用一个通用方法.但是这个方法的参数是 object 如果改变这个参数类型 其他模块调用这个方法就会出现问题最后解决办法是在dao层加入了一个判断这是dao层代码public List findByProperty(String propertyName, Object value) {List list = new ArrayList();String qu...
java判断是否是数组_java判断对象是否是数组
weixin_42668301的博客
02-12 3699
1、从构造函数入手，obj instanceof Arraytypeof 和 instanceof 都可以用来判断变量，typeof方法返回一个字符串，来表示数据的类型; 但是typeof来判断数据类型其实并不准确。比如数组、正则、日期、对象的typeof返回值都是object，这就会造成一些误差。而instanceof 运算符用来测试一个对象在其原型链中是否存在一个构造函数的 prototype...
java数组定义与初始化，类型转换，instanceof的使用
Search,Research
06-10 2446
1、一维数组的声明方式： type var[]; 或type[] var; 声明数组时不能指定其长度（数组中元素的个数）， Java中使用关键字new创建数组对象，格式为： 数组名 = new 数组元素的类型 [数组元素的个数] 实例： TestNew.java： 程序代码： public class TestNew  {       public static void ma
Java学习笔记
11-21
Java学习笔记 1、连接数据库步骤 2、不同数据库的驱动程序和连接字符串 3、连接数据库常见问题 4、B/S结构和C/S结构的区别 5、如何处理中文乱码问题 6、使用JavaMail发送注册验证邮件 7、不安全的用户名密码验证 8、...
java学习笔记
12-22
构造方法6. Java Bean常用API第一部分1.引用类型的使用步骤2.Scanner类3.匿名对象4.Random类5.ArrayList集合5.String类6.static关键字7.Arrays数组工具类8.Math数学工具类继承与多态1.继承2.抽象类3.接口4.多态5....
java学习笔记总结
04-02
这份“java学习笔记总结”涵盖了作者在深入学习Java过程中积累的知识点和实践经验，旨在帮助读者理解和掌握Java的核心概念。 首先，Java的基础部分包括语法、变量、数据类型、运算符和流程控制。Java支持八种基本...
java判断是否为数组_JS如何判断是否是数组？
weixin_30895003的博客
02-25 235
1.通过instanceof判断instanceof运算符用于检验构造函数的prototype属性是否出现在对象的原型链中的任何位置，返回一个布尔值。let a = [];a instanceof Array; //truelet b = {};b instanceof Array; //false在上方代码中，instanceof运算符检测Array.prototype属性是否存在于变量a的原型...
java判断对象是否为数组 并且取得数组的值 --- 用instanceof或则isArray() 方法
热门推荐
猫儿
11-30 6万+
今天项目逻辑需要传个数组过去..然后调用一个通用方法.但是这个方法的参数是 object  如果改变这个参数类型 其他模块调用这个方法就会出现问题   最后解决办法是在dao层加入了一个判断                                  这是dao层代码                                     public List findByPr
使用 instanceof Array判断是否数组
欢迎小伙伴们的评论和私信，工作日基本都会上来看看的哈
12-09 4525
使用instanceof Array判断是否数组
java判断一个Object是否为数组
m0_67403073的博客
04-03 962
判断一个Object是否是一个数组一开始想到了用 Object instanceOf Array来判断,可是经过测试根本达不到目的,直到运用java的反射机制才完成了这个判断 public static boolean isArray0(Object obj){ if(obj == null){ return false; } return obj instanceof Array; } public static bool
instanceof java 报错_Java关键字(一)——instanceof
weixin_29570795的博客
02-16 665
instanceof 严格来说是Java中的一个双目运算符，用来测试一个对象是否为一个类的实例，用法为：其中 obj 为一个对象，Class 表示一个类或者一个接口，当 obj 为 Class 的对象，或者是其直接或间接子类，或者是其接口的实现类，结果result 都返回 true，否则返回false。注意：编译器会检查 obj 是否能转换成右边的class类型，如果不能转换则直接报错，如果不能确...
JavaSE数组基础练习题
活着~的博客
07-30 799
JavaSE数组基础练习题
【沈师PTA】JAVA程序设计-第2章习题集
weixin_52280614的博客
07-21 1万+
一、判断题 （ T ）语句 System.out.println(4+8+“Hello,world!”); 的输出结果是12Hello,world!。 （ T ）Java的字符类型采用的是Unicode编码，每个Unicode码占16个比特。 （ T ）boolean done = true; is a valid assignment statement. （ F ）The following answers is the correct way to declare a Boolean variable
深入理解Java中的二维数组
qq_40694640的博客
05-31 706
引言 最近做剑指offer里面的题时经常遇见二维数组相关的题型，对java中的二维数组的一些概念需要有个清晰的认知，特此记录下自己的总结。 Java中二维数组的初始化 1.直接以集合的形式写出二维数组的所有值 例如： int[][] array = {{1,2},{3,4}}; 这段代码可以初始化获得一个二维数组array，其具有2个1维数组，每个1维数组长度均为2。此时理解二维数组，二维数组本质上是一个一维数组即一个集合，集合中的每个元素同样是一个集合（一个一位数组），理解这个二维数组的本质便于理解
js中instanceof判断数组时的坑
斗师——Ace
07-08 1万+
添加小程序，兑换各种视频教程/数据资源。 1. instanceof在判断数组是，即会把数组当做Array类型，又会把数组当做Object类型，都会返回true。要严格验证一个数组，最好是用constructor，能严格区分数组和对象。注意：大部分情况都可以用instanceof判断是否是数组，但是在判断一个变量是对象或非对象时，会存在坑，如： if (arr instanceof Ob...
instanceof typeof isArray
csdn_zcq的博客
01-29 218
typeof typeof 是一个一元运算，放在一个运算数之前，运算数可以是任意类型。 返回以下结果: “number” “string” “undefined” “boolean” “function” “object” 判断一个变量是否存在可以用typeof ，而不能用if(a)，应为a未定义会报错。 经常会在js里用到数组,比如 多个名字相同的input, 若是动态生成的, 提交时就需要判断...
java 学习笔记 xmind
最新发布
01-02
Java 学习笔记 XMind 是一款专门用于整理和管理 Java 学习内容的思维导图软件。通过 XMind，我们可以将 Java 相关的知识点、重点、代码案例、类库等内容进行整理和分类，方便我们进行学习和复习。 首先，我用 XMind...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值