IT评测·应用市场-qidao123.com技术社区

标题: Java中类的成员先容 [打印本页]

作者: 饭宝 时间: 2024-9-3 03:38
标题: Java中类的成员先容
我的后端学习大纲
我的Java学习大纲

4.类的成员：

3.1.类的成员 -> 属性先容（成员变量）：

a.语法格式：

1.修饰符数据范例属性名 = 初始化值 ;
2.说明1: 修饰符
- 常用的权限修饰符有：private、缺省、protected、public
- 其他修饰符：static、final
3.说明2：数据范例
- 任何根本数据范例(如int、Boolean) 或任何引用数据范例。
4.说明3：属性名
- 属于标识符，符合命名规则和规范即可。

b.变量的分类：

1.成员变量和局部变量
- 在方法体外类体内声明的变量称为成员变量
- 在方法体内部声明的变量称为局部变量
2.成员变量和局部变量雷同点：
- 都有生命周期，都有作用域
- 先声明，后利用
3.成员变量和局部变量差异点：
- 局部变量除形参外，均需显式初始化
- 局部变量指的是界说在成员方法内的变量，存储在栈内，界说在方法内部，方法的形参，代码块内，构造器内部，构造器形参的变量都叫做局部变量
- 局部变量:不能用权限修饰符修饰，可以用final修饰
- 成员变量:是在类中界说的属性，存储在堆中（暂时先忽略掉static范例的属性）
- 成员变量:在声明时候指明其权限，权限修饰符不一样
- 成员变量：权限修饰符有 private,public,缺省，protected
- 成员变量的范例可以是任意范例的，包罗根本范例或者引用范例。成员变量假如不赋值，有默认值，默认值规则和数组的同等。
4.默认初始化值情况
- 属性会根据其范例有初始化值；局部变量没有初始化值，所以在利用局部变量之前肯定要举行显示赋值
- 当一个对象被创建时，会对此中各种范例的成员变量（属性）自动举行初始化赋值。除了根本数据范例之外的变量范例都是引用范例
成员变量(属性)可以被本类，也可以被其他类利用；而局部变量只能在本类中对应的方法利用

比较项 1成员变量局部变量声明的位置直接声明在类中方法形参或内部、代码块内、构造器内等修饰符private、public、static、final等不能用权限修饰符修饰，可以用final修饰初始化值有默认初始化值没有默认初始化值，必须显式赋值，方可利用内存加载位置堆空间或静态域内栈空间

3.2.类的成员 ->行为(方法)先容：

a.方法特点：

1.方法是类或对象行为特征的抽象，用来完成某个功能操作。在某些语言中也称为函数或过程
2.将功能封装为方法的目标是，可以实现代码重用，简化代码
3.Java里的方法不能独立存在，所有的方法必须界说在类里

b.方法的声明格式：

1.权限修饰符返回值范例方法名（参数范例形参1, 参数范例形参2, ….）｛// 方法体程序代码 ;return 返回值; ｝
- 权限修饰符：public,缺省,private, protected
- static、final、abstract来修饰的方法，后面再讲
- 返回值范例：
  - 没有返回值：void。
  - 有返回值，声明出返回值的范例。与方法体中“return 返回值”搭配利用
- 方法体：
  - 内里写完成功能的详细语句，可以是输入，输出，变量，分支，循环，方法的调用等，但是方法体中的方法内里不可以再次界说方法。即方法不可以嵌套界说
- 方法名：属于标识符，命名时遵照标识符命名规则和规范，“见名知意”
- 形参列表：
  - 可以包罗零个，一个或多个参数。多个参数时，中间用“,”隔开
  - 调用带参数的方法的时候，肯定要对应着参数列表传入雷同范例或者兼容范例的参数
  - 实参和形参的范例，个数，顺序必须得同等
- .返回值：方法在执行完毕后返还给调用它的程序的数据

c.代码练习：

package com.jianqun.package01;
/**
* @author jianqun
* @email:1033586391@qq.com
* @creat 2022-01-31-23:15
*/
public class Object02 {
public static void main(String[] args) {
int [][] map = {{0,0,1},{0,0,2},{0,0,3}};
MyTools tools = new MyTools();
tools.printlnArr(map);
}
}
class MyTools{
public void printlnArr(int[][] map){
//遍历数组
for (int i = 0; i < map.length;i++){
for (int j = 0; j < map[i].length; j++){
System.out.println(map[i][j]);
}
}
}
}

复制代码

d.方法执行的内存加载机制

d1.图像剖析方法的加载机制

d2.成员方法利用中的留意事项：

1.一个方法只有一个返回值，假如需要返回多个值，则可以以数组形式返回。

package com.jianqun.package01;
/**
* @author jianqun
* @email:1033586391@qq.com
* @creat 2022-01-31-23:15
*/
public class Object02 {
public static void main(String[] args) {
AA aa = new AA();
int[] sumAndSub = aa.getSumAndSub(1, 1);
System.out.println("****两数相加********" + sumAndSub[0] + "******两数相减********" + sumAndSub[1]);
}
}
class AA{
public int[] getSumAndSub(int n,int m){
int[] ints = new int[2];
ints[0] = n + m;
ints[1] = n - m;
return ints;
}
}

复制代码

2.一个方法可以有0个参数，也可以多个参数
3.参数的范例可以是任意的，包罗根本范例或者引用范例
4.调用参数的时候，肯定对着参数列表传入雷同范例或者兼容范例的参数

e.成员方法的调用说明

e1.代码实现成员方法之间的调用

1.同一个类中的方法调用，可以直接调用
2.跨类调用方法，如A类调用B类中的方法的话，就需要通过对象名调用，如：对象名.方法名（参数）；

package com.jianqun.package01;
/**
* @author jianqun
* @email:1033586391@qq.com
* @creat 2022-02-01-0:48
*/
public class Object03 {
public static void main(String[] args) {
Ao ao = new Ao();
ao.m1();
}
}
class Ao{
public void print(int n){
System.out.println("print方法被调用");
}
public void sayOk(){
print(10);
System.out.println("继续执行sayOk方法");
}
public void m1(){
//创建B类方法
Bo b = new Bo();
b.hi();
}
}
class Bo{
public void hi(){
System.out.println("B类的hi方法被调用");
}
}

复制代码

f.方法传参机制：

f1.变量赋值：

f2.方法的形参传递机制：值传递

Java中方法的参数传递只有一种方式：值传递，即讲现实参数值的副本传入方法内，而参数本身不受影响
f2-1.根本数据范例的传参

根本数据范例，传递的是值，形参的任何改变都不影响实参

f2-2.引用数据范例的传参机制

引用数据范例传递的是地址:

1.例题1：
1.例题2：

// 类名：Object04.java
package com.jianqun.package01;
/**
* @author jianqun
* @email:1033586391@qq.com
* @creat 2022-02-01-10:15
*/
public class Object04 {
public static void main(String[] args){
Bb b = new Bb();
int[] arr = {1,2,3};
//调用方法，传递数组参数
b.test1(arr);
System.out.println("主方法中循环输出");
for (int a = 0; a < arr.length; a++) {
System.out.println(arr[a]);
}
}
}
class Bb{
public void test1(int[] arr){
arr[0] = 100;
System.out.println("类方法中循环输出");
//遍历数组
for (int a = 0; a < arr.length; a++) {
System.out.println(arr[a]);
}
}
}

复制代码

1.例题3：

package com.jianqun.package01;
/**
* @author jianqun
* @email:1033586391@qq.com
* @creat 2022-02-01-10:15
*/
public class Object05{
public static void main(String[] args){
Person p = new Person();
p.name = "李四";
p.age = 105;
B b = new B();
b.test2(p);
}
}
class Person{
String name;
int age;
}
class B{
public void test2(Person p){
Person person = new Person();
person.age = 10;
person.name = "张三";
}
}

复制代码

1.例题4：

package com.jianqun.day08;
public class TransferTest3 {
public static void main(String[] args) {
TransferTest3 transferTest3 = new TransferTest3();
transferTest3.first();
}
public void first(){
int i = 5;
Value value = new Value();
value.i = 25;
second(value,i);
System.out.println(value.i);//20
}
public void second(Value v,int i){
i = 0;
v.i = 20;
Value value = new Value();
v = value;
System.out.println(v.i + "::" + i);//15::0
}
}
class Value{
int i = 15;
}

复制代码

5.例题5：

重写println方法，这个标题并不是简朴得的数值交换，在实现的时候，不可以直接利用根本范例的数值交换

g.方法的overload(重载):

g1.根本概念

java中在同一个类中可以有同名方法的存在，但是要求形参列表不同等(参数个数不同或者参数范例不同)，跟方法的返回值，方法修饰符。方法参数的名称都没有任何关系

g2.重载的好处

可以减少方法起名字的贫苦
可以减小记方法名的贫苦

g3.实现重载

1.重载的方法名必须雷同
2.形参列表：必须不同（形参范例或者个数，参数名字无所谓）
3.返回范例：可以雷同，也可以不同

h.可变个数形参的方法：

1.是在JDK5.0新增的内容

h1.根本语法：

访问修饰符返回值类型方法名（数据类型... 形参名）
{
//代码
}

复制代码

h2.详细利用：

1.可变参数的个数可以是0或者多个
2.可变参数的实参可以是数组
3.可变参数的本质就是数组，也就是说可变个数形参的方法与同名的方法、参数范例雷同但形参是数组的情况不可以同时存在
4.可变参数可以与平凡型参数一起，但是必须保证可变参数在后面
5.一个形参只能有一个可变参数
6.可变参数的方法与本类中同名的但形参个数不同的方法之间构成了重载

package com.jianqun.package01;
/**
* @author jianqun
* @email:1033586391@qq.com
* @creat 2022-02-01-20:53
*/
public class Object08 {
public static void main(String[] args) {
int[] arr = {1,2,12};
HspMethod hspMethod = new HspMethod();
hspMethod.sum(arr);
}
}
class HspMethod{
// public int sum(int n1,int n2){
// return n1 + n2;
// }
// public int sum(int n1,int n2,int n3){
// return n1+ n2;
// }
/**
*
* 优化:使用可变参数进行优化
*/
public int sum(int... nums){
System.out.println("接受的参数个数量可变" + nums.length);
int res = 0;
for (int i = 0; i < nums.length; i++) {
res += nums[i];
}
System.out.println(res);
return res;
}
}

复制代码

i.递归方法:

1.递归方法：一个方法体内调用它自身
2.方法递归包罗了一种隐士的循环，它会重复执行某段代码，但是这种重复执行无需循环控制

i1.递归调用的内存分析

i2. 递归之阶乘举例分析：

i3. 递归的紧张原则

1.执行一个方法的时候，就会创建一个新的受保护的独立空间（栈空间）
2.方法的局部变量是独立的，不会相互影响
3.假如方法中利用的是引用范例变量（好比数组），就会共享该引用范例的数据
4.当一个方法执行完毕后，或者碰到return就会返回。遵守谁调用就把效果返回给谁，同时当方法执行完毕或者返回时，该方法就执行完毕了。

i4.实现斐波那契

斐波那契数列（Fibonacci sequence），又称黄金分割数列、因数学家列昂纳多·斐波那契（Leonardoda Fibonacci）以兔子繁殖为例子而引入，故又称为“兔子数列”，指的是这样一个数列：1、1、2、3、5、8、13、21、34、……
其规律很明显，从第3个数开始，每个数都等于它前两个数的和。