Java中类的成员先容

饭宝 · 2024-9-3 03:38:29

我的后端学习大纲
我的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个数开始，每个数都等于它前两个数的和。

package com.jianqun.package01;
/**
* @author jianqun
* @email:1033586391@qq.com
* @creat 2022-02-01-16:01
*/
public class Object06 {
public static void main(String[] args) {
To t = new To();
System.out.println("当n=7的时候，斐波那契数是:" + t.fibonacci(7));
}
}
class To {
/**
* 递归实现斐波那契数：1 1 2 3 5 8 13........
**/
public int fibonacci(int n){
if (n >=1){
if (n==1 || n==2){
return 1;
}else{
return fibonacci(n-1) + fibonacci(n-2);
}
}else{
System.out.println("输入的数据错误");
return -1;
}
}
}

复制代码

4.类的成员 -> 构造器（构造方法）Constructor

4.1.根本语法

1.[修饰符] 方法名(形参列表){方法体}
4.2.构造器作用

构造器的主要作用是创建新的对象及其对新对象的初始化，构造器是用来造对象的

4.3.构造器特点

1.构造器的修饰符可以是默认的，也可以是 public ,protected,private
2.构造器没有返回值
3.方法名和类名必须同等
4.参数列表和成员方法的规则一样
5.在创建对象的时候，系统会自动的调用该类的构造器完成对象的初始化
6.假如我们没有显示的调用构造器，系统就会默认利用无参构造器

4.4.构造器快速入门

package com.jianqun.package02;
/**
* @author jianqun
* @email:1033586391@qq.com
* @creat 2022-02-02-10:01
*/
public class Constructor01 {
public static void main(String[] args) {
//当我们new一个对象的时候，直接是通过构造器指定名字和年龄
//创建对象的时候就直接指定对象的名字和年龄
Person3 smith = new Person3("smith", 80);
System.out.println("p1的信息如下" + smith.name + smith.age);
}
}
class Person3{
String name;
int age;
//构造器
//构造器名字和类名一致
//构造器无返回值，不可以写void
//(String name, int age)是构造器的形参列表，和成员方法一个样
public Person3(String name, int age) {
this.name = name;
this.age = age;
}
}

复制代码

假如程序员没有自界说构造器，那么系统会自动默认生成一个无参构造器
一旦本身界说了构造器，那么默认的无参构造器就没了，除非本身显示定一下cc
一个类中可以含有多个构造器，构造器之间构成重载的关系

4.5.对象创建的流程分析

1.在方法区加载Person类
2.在堆中分配空间
3.完成对象的初始化，默认初始化中：age = 0;name = null;
4.显示初始化：age = 90；name = null;
5.构造器初始化：age = 20,name = “小倩”
6.把对象在堆中的地址返回给p(P就是对象的引用)

5.类成员-代码块

5.1.代码块有什么作用：

1.代码块又叫初始化快，属于类中的成员，类似于方法，是将逻辑语句封装在一个语法体中，通过{}包围起来
2.代码块分两类：静态代码块和非静态代码块，静态内部类随着类的加载而执行；非静态代码类随着对象的创建而执行
3.代码块作用是：初始化类、对象
4.代码块和方法不同的是：没有方法名，没有返回值，没有参数，只有方法体，且不能通过对象或者类来举行显示调用，而是加载类时候，或创建对象的时候来隐式调用

5.2.语法

修饰符{
//代码
}

复制代码

1.修饰符是可选的，要是写的话，也是只能写static
2.逻辑语句是可以为任意逻辑语句（输入，输出，方法调用，循环，判断）
3.;可以写，也可以不写

5.3.代码块利用的留意事项：

1.类加载的时机：

2.静态代码类与非静态代码类对比：

5.4.演示

a.案例演示1：代码块简化构造器中重复语句

代码块相当于另外一种形式的构造器（对构造器哟补充作用），可以做初始化操作
1.场景：当多个构造器中有雷同的重复语句时，可以初始化到代码块中，提高代码的重用性

2.代码块办理：代码块的调用要优先于构造器

b.案例演示2：代码块利用留意事项；

package com.jianqun.static_;
/**
* @author: jianqun
* @email: 1033586391@qq.com
* @creat: 2022-04-04-13:28
* @Description:
*/
public class CodeBlockDetail01 {
public static void main(String[] args) {
//1.创建对象实例，虽然创建了两个对象，但是静态代码块只被调用一次
CC cc1 = new CC();
CC cc2 = new CC();
//2.创建子类对象实例，父类也会被加载
AA aa2 = new AA();
//3.调用静类的静态成员时（静态属性和静态方法）
System.out.println(Cat.n1);
}
}
class CC{
static {
System.out.println("CC 静态代码块被调用");
System.out.println("==================");
}
{
System.out.println("普通代码块");
}
}
class Cat{
public static int n1 = 9999;
static {
System.out.println("==================");
System.out.println("Cat 静态代码块被调用");
}
{
System.out.println("Cat普通代码块");
}
}
class BB{
static {
System.out.println("BB 静态代码块被调用");
}
}
class AA extends BB{
static {
System.out.println("AA 静态代码块被调用");
}
}

复制代码

c.案例演示3：代码块、静态代码块、构造器调用顺序：

1.创建对象的时候，，在一个类中调用的顺序是：

package com.jianqun.static_;
/**
* @author: jianqun
* @email: 1033586391@qq.com
* @creat: 2022-04-04-13:28
* @Description:
*/
public class CodeBlockDetail02 {
public static void main(String[] args) {
FF ff = new FF();
}
}
class FF{
//静态属性初始化
private static int n1 = getN1();
//静态代码块
static {
System.out.println("AAA 静态代码块");
}
public static int getN1(){
System.out.println("getN1被执行了");
return 100;
}
}

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。

		自动登录	找回密码
密码			立即注册

Java中类的成员先容

本帖子中包含更多资源

0 个回复

快速回复

楼主热帖

标签云

浏览过的版块

Java中类的成员先容

本帖子中包含更多资源

0 个回复

快速回复

楼主热帖

标签云

浏览过的版块

登录参与点评抽奖加入IT实名职场社区