Java Review (七、面向对象----方法深入)

Code Review时学到的技巧之isAssignableFrom 📆 最近更新:2023年4月1日🍊 个人简介:通信工程本硕 for NJU💪、Java程序员🌕。做过科研paper,发过专利,优秀的程序员不应该只是CRUD。 阅读详情

方法是类或对象的行为特征的抽象,方法是类或对象最重要的组成部分, 但从功能上来看,方法完 全类似于传统结构化程序设计里的函数 值得指出的是, Java里的方法不能独立存在 ,所有的方法都必须定义在类里 ,方法在逻辑上要么属于类,要么属于对象。
 

方法的所属性

不论是从定义方法的语法来看,还是从方法的功能来看都不难发现方法和函数之间的相似性,实际上,方法确实是由传统的函数发展而来的,方法与传统的函数有着显著不同:

  • 在结构化编程语言里,函数是一等公民,整个软件由 一个个的函数组成
  • 在面向对象编程语言里,类才是一等公民,整个系统由一个个的类组成

在 Java 方法不能独立存在,方法必须属于类或对象,如果需要定义方法,则只能在类体内定义,不能独立定义个方法。

一旦将一个方法定义在某个类的类体内:

  • 如果这个方法使用了 static修饰 ,则这个方法属于这个类,
  • 如果没有使用static修饰则这个方法属于这个类的实例。

Java语言是静态的。一个类定义完成后,只要不再重新编译这个类文件,该类和该类的对象所拥有的方法是固定的,永远都不会改变。

方法不能独立存在,所以方法也不能像函数那样被独立执行,执行方法时必须使用类或对象来作为调用者 ,即所有方法都必须使用 类.方法 或 对象.方法 的形式来调用 。

这里可能产生 个问题: 同一个类里不同方法之间相互调用时,不就可以直接调用吗?这里需要指出:同 一个类的一个方法调用另外 个方时,如果被调方法是普通方法, 默认使用this 作为调用者;如果被调方法是静态方法,则默认使用类作为调用者。也就是说,表面上看起来某些方法可以被独立执行,但实际上还是使用 this 或者类来作为调用者。

方法属性总结:

  • 方法不能独立定义,方法只 能在类体里定
  • 从逻辑意义上来看,方法要么属于该类本身,要么属于该类 个对象
  • 永远不能独立执行方法,执行方法必须使用类或对象作为调用者

使用 static 修饰的方法属于这个类本身,使用 static 修饰的方法既可以使用类作为调用者来调用,可以使用对象作为调用者来调用。但是因为使用 static 修饰方法还是属于这个类的,因此使用该类的任何对象来调用这个方法时将会得到相同的执行结果,这是由底层依然是使用这些实例所属的类作为调用者。没有 static 修饰的方法属于该类的对象,不属于这个类本身。因此没有 static 饰的方法只能使用对象作为调用者来调用,不能使用类作为调用者来调用 。使用不同对象作为调用者来调用同 一个普通方法,可能得到不同的结果。

方法的参数传递机制

前面己经介绍了 Java 里的方法是不能独立存在的,调用方法也必须使用类或对象作为主调者果声明方法时包含了形参声明,则调用方法时必须给这些形参指定参数值,调用方法时实际传给形参的参数值也被称为实参。

那么, Java 的实参值是如何传入方法的呢?这是由 Java 方法的参数传递机制来控制的, Java 里方法参数传递方式只有一种值传递。所谓值传递,就是将实际参数值的副本(复制品)传入方法内,而参数本身不会受到任何影响。

Java 里的参数传递类似于《西游记》里的孙悟空,孙悟空复制个假孙悟空,这个假孙悟空具有和孙悟空相同的能力,可除以被砍头 但不管这个假孙悟空遇到什么事,孙悟空不会受到任何 与此类似,传入方法的是实际参数值的复制品,不管方法中对这个复制品如何操作,实际参数值本身不会受到任何影响。

基本类型的参数传递

方法参数传递效果实例

复制代码
<span style="color:#141418"><span style="background-color:#ffffff"><code class="language-java"><span style="color:#a626a4">public</span> <span style="color:#a626a4">class</span> <span style="color:#4078f2">PrimitiveTransferTest</span> {

	<span style="color:#a626a4">public</span> <span style="color:#a626a4">static</span> <span style="color:#a626a4">void</span> <span style="color:#4078f2">swap</span>(<span style="color:#986801">int</span> a, <span style="color:#986801">int</span> b) {
		<span style="color:#a0a1a7"><em>// 下面三行代码实现 的值交换</em></span>
		<span style="color:#a0a1a7"><em>// 定义一个临时变量来保存a的值</em></span>
		<span style="color:#986801">int</span> <span style="color:#986801">tmp</span> <span style="color:#ab5656">=</span> a;
		<span style="color:#a0a1a7"><em>// a的值赋给b</em></span>
		a = b;
		<span style="color:#a0a1a7"><em>// 把临时变量 tmp的值赋给b</em></span>
		b = tmp;
		System.out.println(<span style="color:#50a14f">"swap方法里,a的值是"</span> + a + <span style="color:#50a14f">"; b的值是"</span> + b);

	}

	<span style="color:#a626a4">public</span> <span style="color:#a626a4">static</span> <span style="color:#a626a4">void</span> <span style="color:#4078f2">main</span>(String[] args) {
		<span style="color:#986801">int</span> <span style="color:#986801">a</span> <span style="color:#ab5656">=</span> <span style="color:#986801">6</span>;
		<span style="color:#986801">int</span> <span style="color:#986801">b</span> <span style="color:#ab5656">=</span> <span style="color:#986801">9</span>;
		swap(a, b);
		System.out.println(<span style="color:#50a14f">"交换结束后,a变量 的值是"</span> + a + <span style="color:#50a14f">"; b变量 的值是 "</span> + b);

	}

}
</code></span></span>

结果:

复制代码
<span style="color:#141418"><span style="background-color:#ffffff"><code class="language-java">swap方法里,a的值是<span style="color:#986801">9</span>; b的值是<span style="color:#986801">6</span>
交换结束后,a变量 的值是<span style="color:#986801">6</span>; b变量 的值是 <span style="color:#986801">9</span>
</code></span></span>

从上面运行结果来看, swap()方法里 a和b的值是9、6 ,交换结束后,变量a、b的值依然是6、9 。

从这个运行结果可以看出 main()方法里的变量a和b并不是 wap()方法里的变量a和b。 swap()方法里的a和b只是main()方法里变量a和b的复制品。

实例程序的执行过程:

  • Java 程序总是从 main()方法开始执行, main()方法开始定义了a、b两个局部变量

在内存中的存储示意图如图一所示
 

图一:main()方法中定义了a、b变量存储示意图

在这里插入图片描述

  • 当程序执行 swap()方法时,系统进入 swap()方法,并将 main()方法中的变量a和b作为参数值传入swap()方法,传入swap()方法的只是a和b的副本,而不是a和b本身,进入 swap()方法后系统中产生了4个变量

在内存中的存储示意图如图二所示。
 

图二:main()方法中的变量作为参数值传入 swap()方法存储示意图

在这里插入图片描述

  • 在main()方法中调用swap()方法时,main()方法还未结束。因此,系统分别为main()方法和swap()方法分配两块栈区,用于保存main()方法和swap()方法的局部变量。main()方法中的a、b变量作为参数值传入swap()方法,实际上是在swap()方法栈区中重新产生了两个变量a、b,并将main()方法栈区中a、 b变量的值分别赋给swap()方法栈区中的a、b参数(就是对swap()方法的a、b形参进行了初始化)。 此时,系统存在两个a变量、两个b变量,只是存在于不同的方法栈区中而已。程序在swap()方法栈区中交换a、b两个变量的值, 实际上是对图三中灰色覆盖区域的a、b变量进行 交换,交换结束后swap()方法中输出a、b变量的值,看到a的值为9, b的值为6,此时内存中的存储示意图如图三所示:

图三:swap()方法中a、b交换之后的存储示意图

在这里插入图片描述
对比图三与图一两个示意图中main()方法栈区中a、b的值并未有任何改变,程序改变的只是 swap()方法栈区中的a、b。

这就是值传递的实质: 当系统开始执行方法时,系统为形参执行初始化, 就是把实参变量的值赋给方法的形参变量,方法里操作的并不是实际的实参变量。
 

引用类型的参数传递

前面看到的是基本类型的参数传递,Java对于引用类型的参数传递,一样釆用的是值传递方式。下面程序示范了引用类型的参数传递的效果。

引用类型的参数传递实例

复制代码
<strong><code class="language-java"><span style="color:#a626a4">class</span> <span style="color:#4078f2">DataWrap</span> {
	<span style="color:#986801">int</span> a;
	<span style="color:#986801">int</span> b;
}

<span style="color:#a626a4">public</span> <span style="color:#a626a4">class</span> <span style="color:#4078f2">ReferenceTransferTest</span> {
	<span style="color:#a626a4">public</span> <span style="color:#a626a4">static</span> <span style="color:#a626a4">void</span> <span style="color:#4078f2">swap</span>(DataWrap dw) {
		<span style="color:#a0a1a7"><em>// 下面三行代码实现dw的a、b两个成员变量的值交换</em></span>
		<span style="color:#a0a1a7"><em>//定义一个临时变量来保存dw对象的a成员变量的值</em></span>
		<span style="color:#986801">int</span> <span style="color:#986801">tmp</span> <span style="color:#ab5656">=</span> dw.a;
		<span style="color:#a0a1a7"><em>// 把dw对象的b成员变量的值赋给a成员变量</em></span>
		dw.a = dw.b;
		<span style="color:#a0a1a7"><em>// 把临时变量tmp的值赋给dw对象的b成员变量</em></span>
		dw.b = tmp;
		System.out.println(<span style="color:#50a14f">"swap方法里,a成员变量的值是"</span> + dw.a + <span style="color:#50a14f">"; b成员变量的值是"</span> + dw.b);
	}

	<span style="color:#a626a4">public</span> <span style="color:#a626a4">static</span> <span style="color:#a626a4">void</span> <span style="color:#4078f2">main</span>(String[] args) {
		<span style="color:#986801">DataWrap</span> <span style="color:#986801">dw</span> <span style="color:#ab5656">=</span> <span style="color:#a626a4">new</span> <span style="color:#4078f2">DataWrap</span>();
		dw.a = <span style="color:#986801">6</span>;
		dw.b = <span style="color:#986801">9</span>;
		swap(dw);
		System.out.println(<span style="color:#50a14f">"交换结束后,a成员变量的值是"</span> + dw.a + <span style="color:#50a14f">"; b成员变量的值是"</span> + dw.b);
	}
}
</code></strong>

结果:

复制代码
<strong><code class="language-java">swap方法里,a成员变量的值是<span style="color:#986801">9</span>; b成员变量的值是<span style="color:#986801">6</span>
交换结束后,a成员变量的值是<span style="color:#986801">9</span>; b成员变量的值是<span style="color:#986801">6</span>
</code></strong>

从上面运行结果来看,在swap()方法里,a、b两个成员变量的值被交换成功。不仅如此,当swap() 方法执行结束后,main()方法里a、b两个成员变量的值也被交换了。这很容易造成一种错觉:调用swap() 方法时,传入swap()方法的就是dw对象本身,而不是它的复制品。

程序的执行过程:

  • 程序从main()方法开始执行,main()方法开始创建了一个DataWrap对象,并定义了一个dw引用变量来指向DataWrap对象,这是一个与基本类型不同的地方。创建一个对象时,系统内存中有两个东西: 堆内存中保存了对象本身,栈内存中保存了引用该对象的引用变量。接着程序通过引用来操作DataWrap 对象,把该对象的a、b两个成员变量分别赋值为6、9。

此时系统内存中的存储示意图如图四所示。
 

图四:main()方法中创建了 DataWrap对象后存储示意图

在这里插入图片描述

  • main()方法中开始调用swap()方法,main()方法并未结束,系统会分别为main()和swap() 开辟岀两个栈区,用于存放main()和swap()方法的局部变量。调用swap()方法时,dw变量作为实参传入swap()方法,同样釆用值传递方式:把main()方法里dw变量的值赋给swap()方法里的dw形参,从 而完成swap()方法的dw形参的初始化。值得指出的是,main()方法中的dw是一个引用(也就是一个 指针),它保存了 DataWrap对象的地址值,当把dw的值赋给swap()方法的dw形参后,即让swap()方 法的dw形参也保存这个地址值,即也会引用到堆内存中的DataWrap对象。

图五显示了 dw传入swap()后的存储示意图。
 

图五:main()方法中的 dw 传入 swap()方法后存储示意图

在这里插入图片描述

  • 这种参数传递方式是不折不扣的值传递方式,系统一样复制了dw的副本传入swap() 方法,但关键在于dw只是一个引用变量,所以系统复制了 dw变量,但并未复制DataWrap对象。当程序在swap()方法中操作dw形参时,由于dw只是一个引用变量,故实际操作的还是堆内存中的DataWrap对象。此时,不管是操作main()方法里的dw变量,还是操作swap方法里的dw参数, 其实都是操作它所引用的DataWrap对象,它们操作的是同一个对象。因此,当swap()方法中交换dw 参数所引用DataWrap对象的a、b两个成员变量的值后,可以看到main()方法中dw变量所引用DataWrap 对象的a、b两个成员变量的值也被交换了。

为了更好地证明main()方法中的dw()和swap()方法中的dw是两个变量,在swap()方法的最后一行增加如下代码:

复制代码
<strong><code class="language-java"><span style="color:#a0a1a7"><em>//把dw直接赋值为null,让它不再指向任何有效地址</em></span>
dw = <span style="color:#0184bb">null</span>;
</code></strong>

执行上面代码的结果是swap()方法中的dw变量不再指向任何有效内存,程序其他地方不做任何修改。main()方法调用了 swap()方法后,再次访问dw()变量的a、b两个成员变量,依然可以输出9、6。 可见main()方法中的dw变量没有受到任何影响。实际上,当swap()方法中增加dw = null代码后,内存中的存储示意图如图五所不。
 

图五:将swap()方法的 dw 赋值为 null 后存储示意图

在这里插入图片描述


从图五来看,把swap()方法中的dw赋值为null后,swap()方法中失去了DataWrap的引用,不可再访问堆内存中的DataWraper对象。但main()方法中的dw变量不受任何影响,依然引用DataWrap对象,所以依然可以输岀DataWrap对象的a、b成员变量的值。

可变参数

JDK 1.5 开始,Java支持传递同类型的可变参数给一个方法。

方法的可变参数的声明如下所示:

复制代码
<strong><code class="language-java">
typeName... parameterName

</code></strong>

在方法声明中,在指定参数类型后加一个省略号(...) 。

一个方法中只能指定一个可变参数,它必须是方法的最后一个参数。任何普通的参数必须在它之前声明。

可变参数实例

复制代码
<strong><code class="language-java">
<span style="color:#a626a4">public</span> <span style="color:#a626a4">class</span> <span style="color:#4078f2">VarargsDemo</span> {
    <span style="color:#a626a4">public</span> <span style="color:#a626a4">static</span> <span style="color:#a626a4">void</span> <span style="color:#4078f2">main</span>(String args[]) {
        <span style="color:#a0a1a7"><em>// 调用可变参数的方法</em></span>
        printMax(<span style="color:#986801">34</span>, <span style="color:#986801">3</span>, <span style="color:#986801">3</span>, <span style="color:#986801">2</span>, <span style="color:#986801">56.5</span>);
        printMax(<span style="color:#a626a4">new</span> <span style="color:#4078f2">double</span>[]{<span style="color:#986801">1</span>, <span style="color:#986801">2</span>, <span style="color:#986801">3</span>});
    }
    
    <span style="color:#a0a1a7"><em>//定义了形参可变的方法</em></span>
    <span style="color:#a626a4">public</span> <span style="color:#a626a4">static</span> <span style="color:#a626a4">void</span> <span style="color:#4078f2">printMax</span>( <span style="color:#986801">double</span>... numbers) {
        <span style="color:#a626a4">if</span> (numbers.length == <span style="color:#986801">0</span>) {
            System.out.println(<span style="color:#50a14f">"No argument passed"</span>);
            <span style="color:#a626a4">return</span>;
        }
       <span style="color:#a0a1a7"><em>//numbers被当成数组处理</em></span>
        <span style="color:#986801">double</span> <span style="color:#986801">result</span> <span style="color:#ab5656">=</span> numbers[<span style="color:#986801">0</span>];
 
        <span style="color:#a626a4">for</span> (<span style="color:#986801">int</span> <span style="color:#986801">i</span> <span style="color:#ab5656">=</span> <span style="color:#986801">1</span>; i <  numbers.length; i++){
            <span style="color:#a626a4">if</span> (numbers[i] >  result) {
                result = numbers[i];
            }
        }
        System.out.println(<span style="color:#50a14f">"The max value is "</span> + result);
    }
}

</code></strong>

结果:

复制代码
<strong><code class="language-java">The max value is <span style="color:#986801">56.5</span>
The max value is <span style="color:#986801">3.0</span>
</code></strong>

递归方法

一个方法体内调用它自身 被称为方法递归 方法递归包含了某种隐式的循环,它会重复执行某段代码,但这种重复执行无须循环控制。

例如有如下数学题 己知有 个数列:只0) = ,只 1) ,只 + 2) = 2*j n+l) + j(时
其中n是大于大于0的整数,求f(10)的值。这个题可以使用递归来求得。下面程序将定义一个fn方法,用于计算f(10) 的值。

复制代码
<strong><code class="language-java"><span style="color:#a626a4">public</span> <span style="color:#a626a4">class</span> <span style="color:#4078f2">Recursive</span> {
	<span style="color:#a626a4">public</span> <span style="color:#a626a4">static</span> <span style="color:#986801">int</span> <span style="color:#4078f2">fn</span>(<span style="color:#986801">int</span> n) {
		<span style="color:#a626a4">if</span> (n == <span style="color:#986801">0</span>) {
			<span style="color:#a626a4">return</span> <span style="color:#986801">1</span>;
		} <span style="color:#a626a4">else</span> <span style="color:#a626a4">if</span> (n == <span style="color:#986801">1</span>) {
			<span style="color:#a626a4">return</span> <span style="color:#986801">4</span>;
		} <span style="color:#a626a4">else</span> {
			<span style="color:#a0a1a7"><em>// 方法中调用它自身 就是方法递归</em></span>
			<span style="color:#a626a4">return</span> <span style="color:#986801">2</span> * fn(n - <span style="color:#986801">1</span>) + fn(n - <span style="color:#986801">2</span>);
		}
	}

	<span style="color:#a626a4">public</span> <span style="color:#a626a4">static</span> <span style="color:#a626a4">void</span> <span style="color:#4078f2">main</span>(String[] args) {
		<span style="color:#a0a1a7"><em>// 输出 fn (10) 的结果</em></span>
		System.out.println(fn(<span style="color:#986801">10</span>));

	}
}
</code></strong>

方法的重载

Java允许同一个类里定义多个同名方法,只要形参列表不同就行。如果同一个类中包含了两个或两 个以上方法的方法名相同,但形参列表不同,则被称为方法重载。
从上面介绍可以看岀,在Java程序中确定一个方法需要三个要素。

  • 调用者,也就是方法的所属者,既可以是类,也可以是对象。
  • 方法名,方法的标识。
  • 形参列表,当调用方法时,系统将会根据传入的实参列表匹配。

方法重载的要求就是两同一不同:同一个类中、方法名相同,参数列表不同。至于方法的其他部分, 如方法返回值类型、修饰符等,与方法重载没有任何关系。

复制代码
<strong><code class="language-java"><span style="color:#a626a4">public</span> <span style="color:#a626a4">class</span> <span style="color:#4078f2">OverLoad</span> {
   <span style="color:#a0a1a7"><em>//下面定义了两个test()方法,但方法的形参列表不同</em></span>
   <span style="color:#a0a1a7"><em>//系统可以区分这两个方法,这被称为方法重载</em></span>
	<span style="color:#a626a4">public</span> <span style="color:#a626a4">void</span> <span style="color:#4078f2">test</span>() {
		System.out.println(<span style="color:#50a14f">"无参数"</span>);
	}

	<span style="color:#a626a4">public</span> <span style="color:#a626a4">void</span> <span style="color:#4078f2">test</span>(String msg) {
		System.out.println(<span style="color:#50a14f">"重载的 test 方法 "</span> + msg);
	}

	<span style="color:#a626a4">public</span> <span style="color:#a626a4">static</span> <span style="color:#a626a4">void</span> <span style="color:#4078f2">main</span>(String[] args) {
		<span style="color:#986801">OverLoad</span> <span style="color:#986801">ol</span> <span style="color:#ab5656">=</span> <span style="color:#a626a4">new</span> <span style="color:#4078f2">OverLoad</span>();
        <span style="color:#a0a1a7"><em>//调用testO时没有传入参数,因此系统调用上面没有参数的testO方法</em></span>
		ol.test();
        <span style="color:#a0a1a7"><em>//调用testO时传入了一个字符串参数</em></span>
       <span style="color:#a0a1a7"><em>//因此系统调用上面带一个字符串参数的testO方法</em></span>
		ol.test(<span style="color:#50a14f">"hello"</span>);
	}
}
</code></strong>

Java 允许重载任何方法, 而不只是构造器方法。因此,要完整地描述一个方法,需要指出方法名以及参数类型。这叫做方法的签名(signature)。

FPGA加速SNN实现MNIST手写数字识别的实践与优化 脉冲神经网络(SNN)作为第三代神经网络模型,采用生物启发的脉冲事件驱动机制,在处理时序信号时具有天然能效优势。其核心原理是通过神经元仅在接收足够输入脉冲时激活的稀疏特性,大幅降低计算能耗。在FPGA硬件加速领域,SNN通过量化优化、硬件友好型神经元模型设计等关键技术,可在边缘计算场景实现超高能效比。本文以MNIST手写数字识别为案例,详细解析了从6bit量化策略到双缓冲流水线设计的完整优化路径,最终在Xilinx Kintex-7平台实现97.54%识别准确率的同时,功耗仅231mW,能效比达81,712 阅读详情

相关推荐

Windows平台MuJoCo仿真环境配置与Qt集成实战

本文详细介绍了在Windows平台上配置MuJoCo物理仿真环境并与Qt框架集成的完整实战流程。内容涵盖从环境准备、库文件配置、项目创建到核心代码编写的每一步,重点解决了Windows下常见的编译链接错误和路径问题,帮助开发者在Windows系统中高效搭建机器人仿真与可视化控制开发环境。

weixin_29221753的博客 178

Java Review 基础复习(一)

主要是针对初学java的同学们一个基础性的复习,这是其中第一篇

Learner_Chen的博客 1992

nrf52840的uart0与uart1双串口使用

nrf52840的uart0与uart1双串口使用 项目原使用nrf52832,后面由于项目需要用到双串口,改用nrf52840,官方的例程没看到使用uart1的,找遍全网都没找到uart1的使用资料,有些不负责任的网文居然说40也只有一个uart,吓得俺赶紧又查看了一次datesheet,O得K、木鸭梨 SDK代码uart驱动中,搜索到uart1的驱动部分,说明官方驱动有uart1支持的 自己动手,丰衣足食吧,下面以nRF5_SDK_17.0.0_9d13099版本,在examples\ble_per

chhen168的博客 5628

Java review--反射

深入讲解了Java反射,并结合动态代理,对反射进行了进一步的剖析。

随手记 821

Arduino创意作品实战案例:手把手教你做温控风扇

通过这个实用的arduino创意作品,轻松实现温度感应与风扇自动控制,结合传感器与编程逻辑,打造智能散热系统,是入门者理想的arduino创意作品实践项目。

weixin_42311427的博客 610

第二十七届华东杯数学建模A 题 跳台滑雪问题 完整思路模型及代码

考虑到滑行过程中的空气阻力和摩擦力对速度的影响,我们引入了不同姿态下运动员迎风面积和空气阻力系数的变化,利用牛顿第二定律建立加速度表达式,并通过数值模拟比较常见姿态下的终端速度。针对问题二,我们构建了二维空中飞行动力学模型,结合起跳速度、身体迎角、滑雪板倾角等因素,模拟运动员在空中飞行的轨迹与姿态变化,采用欧拉法对运动过程进行仿真,优化飞行路径和稳定性。仿真结果表明,运动员应在起跳后保持滑雪板与身体成“V”字形打开、重心略后倾的姿态,以增强升力、延长飞行距离并提高姿态得分。,并模拟出跳跃的轨迹和最终得分。

lichensun的博客 3212

如何进行代码REVIEW

一、代码REVIEW的利与弊 软件工程中,最后都落实在代码的实现上,软件要运行的没有问题,除了软件架构和系统设计设计到位,代码实现也是至关重要的一部分,再好的设计如果软件代码实现有问题,软件也不能跑起来。 代码编写的质量直接影响软件程序运行,所以不同的阶段都有措施来进行软件代码的质量检查。其中代码REVIEW是对代码质量非常有用的检查办法,对提供代码质量和程序运...

昆仑山上一棵草 1万+

彻底解决tplink路由器无法访问部分https网站

彻底解决tplink无法访问部分https网站

renkai721的专栏 8767

Java-代码审核CodeReview要点总结

1.颗粒度划分要细例如:当分组循环一个请求一个服务时,如果其中的一个请求抛出异常,应该在catch中捕获,记录错误日志,让循环继续进行2.非空判断和边境检查对数组和集合的判断对map的key值判断对list的值得判断3.错误码和异常抛出的合理划分4....

路漫漫的博客 3133

MATLAB 开发项目实例 1000 例专栏之第37例:基于Simulink的无人机飞行控制系统设计

通过上述项目实例,我们成功地使用Simulink设计和仿真了一个无人机的飞行控制系统。这个项目展示了从无人机建模、路径规划、控制器设计到仿真验证的完整流程。Simulink的可视化和模块化特性使得系统的建模和仿真更加直观和高效。

xiaoheshang_123的博客 164

YOLOv11改进策略【SPPF】| AIFI : 基于Transformer的尺度内特征交互,在降低计算成本的同时提高模型的性能

本文记录的是基于AIFI模块的YOLOv11目标检测改进方法研究。AIFI是RT-DETR中高效混合编码器的一部分,利用其改进YOLOv11模型,

Limiiiing的博客 2241

java代码review收获_Java Review (七、面向对象----方法深入)

@方法是类或对象的行为特征的抽象,方法是类或对象最重要的组成部分, 但从功能上来看,方法完全类似于传统结构化程序设计里的函数 值得指出的是, Java里的方法不能独立存在 ,所有的方法都必须定义在类里 ,方法在逻辑上要么属于类,要么属于对象。方法的所属性不论是从定义方法的语法来看,还是从方法的功能来看都不难发现方法和函数之间的相似性,实际上,方法确实是由传统的函数发展而来的,方法与传统的函数有着显...

weixin_33791941的博客 233

Matlab波动光光学系统

波动光学是一种研究光波传播过程的理论,按照其处理的信息类型不同,可以分为相干和非相干波动光学,相干波动光学可以用作特定光学系统的分析和设计,其主要依赖物理光学和电磁波的基本原理,以及光学干涉和衍射的经验方程式,其中光波传播过程是以复数形式表示的,包括振幅和相位两个方面。近年来光学技术得到了广泛的应用和发展,波动光光学系统是其中一种重要的光学系统,它主要是利用波动光学原理,通过计算机模拟实现各种光学系统的设计、分析和优化,可应用于大气光传输、光束整形、分析系统的衍射和干涉特性,包括利用。

weixin_50547796的博客 262

2024年Java最新Java Review (七、面向对象----方法深入),阿里java应届生面试题目

既已说到spring cloud alibaba,那对于整个微服务架构,如果想要进一步地向上提升自己,到底应该掌握哪些核心技能呢?就个人而言,对于整个微服务架构,像RPC、Dubbo、Spring Boot、Spring Cloud Alibaba、Docker、kubernetes、Spring Cloud Netflix、Service Mesh等这些都是最最核心的知识,架构师必经之路!下图,是自绘的微服务架构路线体系大纲,如果有还不知道自己该掌握些啥技术的朋友,可根据小编手绘的大纲进行一个参考。

2401_84692382的博客 785

jdk-8u144-linux-x64.tar.gz.

该资源为搭建Linux系统Java环境用,资源的后缀为tar.gz格式的压缩包

温度PID控制PLC程序

温度PID稳定控制程序,适用于欧姆龙PLC,对其他PLC也具有很大参考价值

Java最新Java Review (七、面向对象----方法深入)(1),dubbo+zookeeper面试

笔者已经把面试题和答案整理成了面试专题文档本文已被CODING开源项目:【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录需要这份系统化的资料的朋友,可以点击这里获取[外链图片转存中…(img-WMKytEVC-1715370567311)][外链图片转存中…(img-62yEb6Zl-1715370567311)][外链图片转存中…(img-fmrsw8qe-1715370567312)][外链图片转存中…(img-aLb22NGi-1715370567312)]

2401_84585234的博客 719

Devexpress16.2.6破解工具

Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具

Java Review (零、初识)

2020年在匆匆忙忙慌慌乱乱中就这么度过了,我们迎来了新一年,互联网的发展如此之快,技术日新月异,更新迭代成为了这个时代的代名词,坚持下来的技术体系会越来越健壮,JVM作为如今是跳槽大厂必备的技能,如果你还没掌握,更别提之后更新的新技术了。更多JVM面试整理:《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》点击传送门即可获取!大厂必备的技能,如果你还没掌握,更别提之后更新的新技术了。[外链图片转存中…(img-JVFlJpl5-1711975359620)]

2301_81749759的博客 762

Data-Structures-and-Algorithm-Analysis-in-Java.pdf

作者: Weiss, Mark A. 出版社: Addison Wesley Data Structures and Algorithm Analysis in Java is an “advanced algorithms” book that fits between traditional CS2 and Algorithms Analysis courses. In the old ACM Curriculum Guidelines, this course was known as CS7. This text is for readers who want to learn good programming and algorithm analysis skills simultaneously so that they can develop such programs with the maximum amo...

JAVA代码Review总结

1. 代码Review的目的 一般团队很难在Review中要求极致的代码质量,毕竟是项目而非艺术品。你很难通过Review要求程序进化为完美的程序,很难要求程序员都达到很高的水准,所以常见团队的Review更多的是达成一定的共识,底线是质量可以做到项目要求的高度。而更优秀代码的探讨可以作为锦上添花的讨论,根据情况推荐而不强求。 本文尝试总结下自己评审中遇到的通用问题,项目或业务名称通过简称来替...

qrycsa的博客 264

Java Review (六、面向对象----类和对象)

文章目录

三分恶的博客 1250
上一篇: Java Review (六、面向对象----类和对象)
下一篇: Java Review (八、面向对象----成员变量和局部变量)
加班不秃顶
博客等级 码龄7年 1822粉丝 599原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值