10、Java类与对象

最新推荐文章于 2024-08-07 11:15:21 发布
最新推荐文章于 2024-08-07 11:15:21 发布
阅读量122 收藏
点赞数
分类专栏： java基础 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ImBeen/article/details/124490954
版权

10、Java类与对象

类就是自定义的数据类型，对象就是一个具体的实例

10.1 基本介绍

  • 属性/成员变量/实例字段：是类的一个组成部分，一般是基本数据类型，也可以是引用类型（对象；数组）

    定义：访问修饰符 属性类型 属性名；若不赋值，则有默认值，规则和数组一致

  • Java内存结构分析：

    1. 栈：一般存放基本数据类型（局部变量）
    2. 堆：存放对象，数组等
    3. 方法区：常量池（常量，比如字符串）；类加载信息（属性信息，方法信息）

  • Java创建对象流程（简略）：

    1. 在方法区先加载类信息（属性和方法信息，且只会加载一次）
    2. 在堆中分配空间，进行默认初始化
    3. 把地址赋给对象
    4. 进行指定初始化，覆盖原来的初始化值
    5. 注意：对象的地址在堆中。对象的引用（对象名）在栈中，指向堆中对应的对象地址

  • Java成员方法的定义：

    访问修饰符 返回数据类型 方法名（形参列表…）{方法体；return返回值;}

    1. 访问修饰符：规定访问权限
    2. 返回数据类型：表示成员方法输出，void没有返回值
    3. 方法名：表示成员方法的输入
    4. 方法体：实现该方法的具体实现
    5. return 不是必须的。如void时可以不用return，或者只写return
    6. 一个方法最多有一个返回值，返回类型可以是任何类型，包括引用类型（数组，对象）
    7. 形参列表可以有0个参数，也可以有多个参数；参数类型可以为任何类型，包括引用类型，调用方法时，要对应参数列表传入相同类型或兼容类型的参数
    8. 方法定义时的参数称为形式参数（形参）；方法调用时传入的参数称为实际参数（实参）。实参和形参类型，个数，顺序必须一致。
    9. 方法里不能嵌套其他方法的定义
    10. 在两个方法在同一类中，一个方法可以直接调用另一个方法，不用创建对象
    11. 跨类调用方法，需要创建该类对象，再通过对象名调用该类方法；注意：跨类的方法调用和方法的访问修饰符相关；后续会细说

  • Java方法调用机制：

    1. 在栈中自动创建一个main栈，当程序执行到方法时，就会开辟一个独立的栈空间
    2. 当方法执行完毕，或者执行到return语句时，就会返回
    3. 返回到调用方法的地方
    4. 返回后，只需执行之后的语句

  • Java成员方法传参机制

    1. 基本数据类型的传参机制：基本数据类型传递的是值（值拷贝），形参的任何改变不会影响实参
    2. 引用数据类型的传参机制：引用数据类型传递的是地址（传递的也是值，但值是地址），可以通过形参影响实参

  • 练习：编写一个方法copyPerson，可以复制一个Person对象信息，返回复制后的对象；要求两个对象相互独立，只是属性相同

    Person person = new Person();
person.age = 10;
person.name = "Jack";
Tool T= new Tool();
Person newperson = T.copyPerson(person);
System.out.println(newperson.age);
System.out.println(newperson.name);
System.out.println(person.age);
System.out.println(person.name);

class Person{
    int age;
    String name;
}
class Tool{
    public Person copyPerson(Person p){
        Person newperson =new Person();
        newperson.age = p.age;
        newperson.name = p.name;
        return newperson;
    }
}

  • 递归练习1：给定整数n ,用递归的方式求出斐波那契1,1,2,3,5,8,13…第n个数为多少

    public class Test_0009 {
    public static void main(String[] args) {
        Fibonacci f = new Fibonacci();
        int num = f.fibonacci(8);
        System.out.println(num);

    }
}
class Fibonacci{
    public int fibonacci(int n ){
        if(n==1||n==2){
            return 1;
        }else{
            return fibonacci(n-1)+fibonacci(n-2);
        }
    }
}

  • 递归练习2： 迷宫问题

    int[][] map = {{1,1,1,1,1,1,1},
               {1,0,0,0,0,0,1},
               {1,0,1,1,0,0,1},
               {1,1,1,0,0,0,1},
               {1,0,0,1,0,0,1},
               {1,0,0,0,0,0,1},
               {1,0,0,0,0,0,1},
               {1,1,1,1,1,1,1}};
Maze m = new Maze();
m.findWay(map,1,1);
for(int i = 0;i< map.length;i++){
    for(int j = 0;j<map[i].length;j++){
        System.out.print(map[i][j]+" ");
    }
    System.out.println();
}
class Maze{
    /**
     * 1. findWay:表示找出迷宫路径
     * 2. 找到返回true
     * 3. i,j表示当前所在位置，初始化为1,1
     * 4。 规定map数组的含义：0表示可以走，1：表示障碍物，2：表示可以走，3：表示可以走，但是走过且走不通
     * 5. 当map[6][5]==2时，说明找到出口，打印此时map，2代表走过的路径
     */
    public Boolean findWay(int[][] map,int m,int n){
        if(map[6][5]==2){
            return Boolean.TRUE;
        }
        else{
            if(map[m][n]==0){
                map[m][n]=2;
                if(findWay(map,m+1,n)){
                    return true;
                }
                else if(findWay(map,m,n+1)){
                    return true;
                }
                else if(findWay(map,m-1,n)){
                    return true;
                }
                else if(findWay(map,m,n-1)){
                    return true;
                }
                else{
                    map[m][n]=3;
                    return false;
                }
            }else{
                return false;
            }
        }
    }
}

  • 递归练习3： 汉诺塔

    Hanoi hanoi = new Hanoi();
char A = 'A';
char B = 'B';
char C = 'C';
hanoi.move(4,A,B,C);
class Hanoi{
    //若有多个盘，可以看成两个盘即最下面和上面所有的盘（n-1）
    public void move(int n,char a,char b,char c){
        if(n==1){
            System.out.println(a+"->"+c);
        }
        else{
            //1. 先移动上面所有盘到b塔
            move(n-1,a,c,b);
            //2. 把a塔剩余的一个移动到c塔
            move(1,a,b,c);
            //3. 把b塔所有盘移动到c塔
            move(n-1,b,a,c);
        }
    }
}

  • 递归练习4：八皇后

    EightQueens eq = new EightQueens();
int num = eq.check(0);
System.out.println("num="+num);

class EightQueens{
    int[] arr = new int[8];
    int count = 0;
    public int check(int row){
        if(row ==8){
            for(int i =0;i< arr.length;i++){
                System.out.print(arr[i]+" ");
            }
            System.out.println();
            count++;
        }else{
            for(int column = 0;column< arr.length;column++){
                arr[row] = column;
                if(judge(row)){
                    check(row+1);
                }
            }

        }
        return count;
    }
    public Boolean judge(int row){
        for(int i =0;i<row;i++){
            if(arr[row]==arr[i] || Math.abs(row-i) == Math.abs(arr[row]-arr[i])){
                return false;
            }
        }
        return true;
    }
}

10.2 方法重载（overload）

  • Java中允许同一个类中存在多个同名方法，但要求形参列表（参数类型、个数或顺序至少有一样不同）不一致，只有返回类型不同不能称为方法重载

    方法重载好处：减轻取名的麻烦和记名的麻烦

    例如：System.out.println()方法中方法名相同但是形参列表不同，该方法可以接收不同的数据类型输出

10.3 可变参数

  • Java允许将同一个类中多个同名同功能但参数个数不同的方法，封装成一个方法，可以通过可变参数实现

  • 基本语法：访问修饰符 返回类型 方法名(数据类型… 形参名){方法体;}

  • 注意事项：可变参数的实参可以为0个或任意个；

    ​ 可变参数本质是数组；

    ​ 可变参数和普通类型参数一起放在形参列表中时，必须保证可变参数在最后

    ​ 一个形参列表中只能出现一个可变参数

    VarParameter vp = new VarParameter();
int sum = vp.sum(1,2,3,4);//这里可变参数数量为3个
System.out.println("可变参数和为："+ sum);
class VarParameter{
    //计算两个数的和、三个数的和、四个数的和...
    //可以使用方法重载，但是过于繁琐冗余
    //因为方法名相同，功能相同，只是参数个数不同，可以使用可变参数进行封装
    //int... 表示方法接收的是可变参数，即可以接收多个int类型的形参
    //可以当做数组使用
    public int sum(int... n){
        int result = 0;
        for(int i =0 ;i<n.length;i++){
            result +=n[i];
        }
        return result;
    }
}

10.4 变量作用域

  • 主要变量就是属性（成员变量）和局部变量

  • 局部变量一般是指在成员方法中定义的变量和代码块中的变量

  • 全局变量：也就是方法的属性，作用域为整个类体

  • 局部变量：除了属性之外的其他变量，作用域为定义它的代码块中

  • 全局变量可以不赋值直接使用，因为它有默认值；局部变量必须赋值后才能使用

  • 属性和局部变量可以重名，使用时遵从就近原则

  • 属性的生命周期长，伴随着对象的创建而创建，伴随着对象的销毁而销毁；局部变量生命周期较短，即在一次方法调用过程中创建->销毁

  • 作用域范围不同：全局变量（属性）：可以被本类使用或其他类（通过对象调用）使用

    ​ 局部变量：只能在本类中对应的方法中使用

  • 修饰符不同：全局变量（属性）可以加修饰符，也可以不加；局部变量不可以加修饰符

10.5 构造方法/构造器（constructor）

  • 基本语法：[修饰符] 方法名（形参列表）{方法体；}

  • 作用：主要完成对象的初始化

  • 构造器修饰符可以是默认的，也可以是public、protected、private

  • 构造器没有返回值

  • 方法名必须和类名一致

  • 参数列表和成员方法规则一致

  • 构造器调用由系统完成

  • 一个类可以定义多个不同的构造器；即构造器重载

  • 若程序员没有定义构造器，系统会自动给类生成一个默认无参构造器（默认构造器），使用javap指令反编译查看：javap 类名

  • 一旦定义了自己的构造器，默认构造器就被覆盖，就不能再使用默认的无参构造器了，除非显式的定义一下

    Constructor constructor1 = new Constructor(16,"Jack");
System.out.println("age:"+constructor1.age+"\tname:"+constructor1.name);
Constructor constructor2 = new Constructor(20);
System.out.println("age:"+constructor2.age);
Constructor constructor3 = new Constructor("Lucy");
System.out.println("name:"+constructor3.name);
Constructor constructor4 = new Constructor();
class Constructor{
    int age;
    String name;
    //构造器没有返回类型，也不能写void
    //方法名必须和类名一致
    public Constructor(int Page,String Pname){
        System.out.println("构造器被调用！完成对象属性的初始化~");
        age = Page;
        name = Pname;
    }
    public Constructor(int Aage){
        age = Aage;
    }
    public Constructor(String Aname){
        name = Aname;
    }
    public Constructor(){
        System.out.println("因为系统默认的无参构造器被覆盖，这里显式的创建无参构造器");
    }
}

  • Java创建对象流程（详细）：

    1. 在方法区先加载类信息（属性和方法信息，且只会加载一次）
    2. 在堆中分配空间，进行默认初始化
    3. 把地址赋给对象
    4. 进行指定初始化，覆盖原来的初始化值；这里先默认初始化（如int类型为0，String类型为null）；若有显式初始化，再执行显式初始化（如定义类时直接初始化int为某个具体数值，则将默认初始化改为对应的初始化 ）；最后再执行构造器的初始化（如定义了构造器，创建对象后先执行前面两次初始化，最后根据个构造器的初始化进行对应改变）
    5. 把对象在堆中的地址返回给栈中的对象的引用（对象名）
    6. 注意：对象的地址在堆中。对象的引用（对象名）在栈中，指向堆中对应的对象地址

  • this关键字：

    • java虚拟机会给每个对象分配this，代表当前对象。哪个对象调用，this就代表哪个对象
    • this可以用来访问本类的属性、方法、构造器
    • this用来区分当前类的属性和局部变量
    • 访问成员方法的语法：this.方法名(参数列表);
    • 访问构造器语法：this(参数列表) 注：只能在构造器中第一个语句调用其他构造器
    • this只能在类定义的方法中使用，不能在类定义的外部中使用
    ThisKeyWord tkw = new ThisKeyWord(100, "this关键字");
System.out.println("num:"+tkw.num+"\ttype:"+tkw.type+"\t对象地址的哈希码值："+ tkw.hashCode());
ThisKeyWord tkw1 = new ThisKeyWord(20);
System.out.println("num:"+tkw1.num+"\ttype:"+tkw1.type+"\t对象地址的哈希码值："+ tkw1.hashCode());
tkw1.function2();
tkw.function3();
class ThisKeyWord{
    int num;
    String type;
    //如果我们的构造器的形参能直接写成属性名，就更加方便明了，但是出现一个问题，就是变量的作用域原则
    //下面的构造器形参的num、type是局部变量，而不是属性，导致使用下面构造器时，与本类的属性无关
//    public ThisKeyWord(int num,String type){
//        num = num;
//        type = type;
//    }
    //用关键词this关键字解决
    public ThisKeyWord(int num ,String type){
        //  this.  就是指向当前对象的属性
        this.num = num;
        this.type = type;
        System.out.println("this地址的哈希码值："+this.hashCode());
    }
    public ThisKeyWord(int num){
        this(19,"Tom");//这句要放在首句中
        this.num = num;

    }
    public void function1(){
        System.out.println("方法一！");
    }
    public void function2(){
        System.out.println("使用this调用同类方法：");
        //第一种方式：直接调用
        function1();
        //第二种方式：用this调用，区别后面继承时候讲解
        this.function1();

    }
    public void function3(){
        String type = "A";
        int num = 10;
        System.out.println("type="+ type + "\tnum=" + num );
        System.out.println("this.type= " + this.type + "\tthis.num="+ this.num);
    }
}

  • 练习:创建一个PersonDemo类，含有一个compareTo()方法来比较两个对象属性是否相同，返回true or false;

    PersonDemo p1 = new PersonDemo(18, "xiaoming");
PersonDemo p2 = new PersonDemo(20,"xiaohong");
boolean b = p1.compareTo(p2);
System.out.println(b);
class PersonDemo{
    int age;
    String name;
    public PersonDemo(){}
    public PersonDemo(int age,String name){
        this.age = age;
        this.name = name;
    }
    public Boolean compareTo(PersonDemo p){
        if(this.name.equals(p.name)&&this.age==p.age){
            return true;
        }
        else
            return false;
    }
}

10.6 课后练习

  1. 编写类A01，定义方法max,实现求某个double 数组最大值，并返回

    double[] arr = {1.15,3.2,8,6};
A01 a01 = new A01();
Double res = a01.max(arr);
if(res!=null){
    System.out.println("最大值为："+res);
}else{
    System.out.println("输入数组为空！");
}

class A01{
    public Double max(double[] arr){
        if(arr.length>0){
            double max = arr[0];
            for (int i = 1; i < arr.length ; i++) {
                if(arr[i]>max){
                    max = arr[i];
                }
            }
            return max;
        }
        else{
            return null;
        }
    }
}

  2. 编写类A02，定义方法find ,实现某字符串数组中的元素查找，并返回索引，若找不到，返回-1

    String[] srr={"Lucy","Ben","Jack","Tom"};
String tar = "Tom";
A02 a02 = new A02();
Integer res2 = a02.find(tar,srr);
if(res2!=null) {
    System.out.println(res2);
}else{
    System.out.println("输入数组为空！");
}

class A02{
    public Integer find(String tar, String[] srr) {
        if (srr.length > 0) {
            for (int i = 0; i < srr.length; i++) {
                if (tar.equals(srr[i])) {
                    return i;
                }
            }      
            return -1;
        }
        return null;
    }
}

  3. 编写类Book，定义方法updatePrice，实现更改某本书的价格，如：若价格大于150，则更改为150，若价格大于100，则更改为100，其他不变。

    A03 a03 = new A03(99);
System.out.println("书原价为："+a03.price);
double res3 = a03.updatePrice();
System.out.println("更改后的价格为："+res3);
class A03{
    double price;
    public A03(double price){
        this.price = price;
    }
    public double updatePrice(){
        if(this.price>150){
            this.price = 150;
            return this.price;
        }else if(this.price<150&&this.price>100){
            this.price = 100;
            return this.price;
        }
        else{
            return this.price;
        }
    }
}

  4. 编写类A04,定义方法copyArr实现数组的复制功能，输入旧数组，返回新数组，元素和旧数组一样

    A04 a04 = new A04();
Double[] a04Arr = {1.2,5.5,7.3,4.2};
Double[] res4 = a04.copyArr(a04Arr);
if(res4!=null){
    System.out.println("原数组哈希码值："+ a04Arr.hashCode());
    System.out.println("复制后哈希码值："+ res4.hashCode()+"\n复制后元素为：");
    for (int i = 0; i < res4.length; i++) {
        System.out.print(res4[i] + " ");
    }
}else{
    System.out.println("输入数组为空！");
}
class A04{
    public Double[] copyArr(Double[] arr){
        if(arr.length>0){
            Double[] copyarr = new Double[arr.length];
            for (int i = 0; i < arr.length; i++) {
                copyarr[i] = arr[i];
            }
            return copyarr;
        }else{
            return null;
        }
    }
}

  5. 编写类A05,定义属性半径，分别提供计算圆周长，圆面积的方法

    A05 a05 = new A05(1);
System.out.println("周长为："+a05.Perimeter());
System.out.println("面积为："+a05.Area());
class A05{
    double r;
    public A05(double r){
        this.r = r;
    }
    public double Perimeter(){
        double perimeter= 2*Math.PI*this.r;
        return perimeter;
    }
    public double Area(){
        double area = Math.PI*r*r;
        return area;
    }
}

  6. 编写类A06，定义两个属性表示操作数，定义四个方法完成加减乘除操作，并创建两个对象，分别测试。

    A06 a06 = new A06(1,0);
System.out.println("和为："+ a06.Add());
System.out.println("差为："+ a06.subtraction());
System.out.println("积为："+ a06.multiplication());
if(a06.y!=0){
    System.out.println("商为："+ a06.division());
}else{
    System.out.println("被除数为0！");
}
class A06{
    double x;
    double y;
    public A06(double x,double y){
        this.x = x;
        this.y = y;
    }
    public double Add(){
        return this.x + this.y;
    }
    public double subtraction(){
        return this.x - this.y;
    }
    public double multiplication(){
        return this.x * this.y;
    }
    public Double division(){
        if(this.y!=0){
            return this.x/this.y;
        }else{
            return null;
        }

    }
 }

  7. 编写类A07,属性有名字，颜色，年龄；定义方法show()输出其信息。

    A07 a07 = new A07("旺财", "黄色", 12);
a07.show();

class A07{
    String name;
    String color;
    int age;
    public A07(String name,String color,int age){
        this.name = name;
        this.color = color;
        this.age = age;
    }
    public void show(){
        System.out.println("名字为："+ this.name);
        System.out.println("颜色为："+ this.color);
        System.out.println("年龄为："+ this.age);
    }
}

  8. 编写类A08，属性有（姓名、年龄、性别、工作、薪水）,要求提供三个构造器可以分别初始化（姓名、年龄、性别、工作、薪水）（姓名、年龄、性别、）（姓名），要求充分福永构造器

    class A08{
    String name;
    int age;
    char sex;
    String job;
    double sar;
    public A08(String name){
        this.name = name;
    }
    public A08(String name,int age,char sex){
        this(name);
        this.age = age;
        this.sex = sex;
    }
    public A08(String name,int age,char sex,String job,double sar){
        this(name, age, sex);
        this.job = job;
        this.sar = sar;
    }
}

  9. 定义一个Circle类，包含一个double的radius属性代表半径，findArea()方法返回圆的面积

    定义PassObject,在类中定义方法printAreas(Circle c,double times)

    在printAreas方法打印1到times之间每个整数的半径值和对应的面积

    在main中调用printAreas()，输出

    Circle circle = new Circle();
PassObject passObject = new PassObject();
double times = 5.5;
passObject.printAreas(circle,times);
class Circle{
    double radius;
    public Circle(){}
    public Circle(double radius){
        this.radius = radius;
    }
    public double findArea(){
        return Math.PI*radius*radius;
    }
    public void setRadius(double radius){
        this.radius = radius;
    }
}
class PassObject{
    public void printAreas(Circle c,double times){
        System.out.println("Radius\tArea");
        for (int i = 1; i <= times; i++) {
            //c.radius = i;     这里可以直接用c.radius来赋值改变属性，因为radius是public的，可以直接访问，当不是public时，需要用get/set来改变
            c.setRadius(i);
            System.out.println(i+"\t\t"+c.findArea());
        }

    }
}

  10. 设计一种类，可以和电脑猜拳，并显示结果清单。0表示石头；1表示见到；2表示布

    FingerGuess fingerGuess = new FingerGuess();
Play play = new Play();
int time = 5;
play.play(fingerGuess,5);
class FingerGuess{
    int finger;
    int comGuessNum;

    public void setFinger(int finger){
        this.finger = finger;
    }
    public int computerNum(){
        Random random = new Random();
        comGuessNum = random.nextInt(3);
        return comGuessNum;
    }
}
class Play{
    public void play(FingerGuess f,int times){
        Scanner scanner = new Scanner(System.in);
        System.out.println("电脑\t 我\t 结果");
        for (int i = 1; i <= times; i++) {
            System.out.println("请输入你要出的0~2：");
            int userNum = scanner.nextInt();
            if(userNum==0||userNum==1||userNum==2){
                f.setFinger(userNum);
                f.computerNum();
                int comGuessNum = f.computerNum();
                System.out.println("我的出拳："+ userNum + "电脑出拳："+comGuessNum);
                if(userNum==comGuessNum){
                    System.out.println("平局");
                    continue;
                }
                else if((userNum==0&&comGuessNum==1)||(userNum==1&&comGuessNum==2)||(userNum==2&&comGuessNum==0)){
                    System.out.println("用户赢！");
                    continue;
                }else{
                    System.out.println("电脑获胜！");
                    continue;
                }
            }else{
                System.out.println("输入有误");
                break;
            }
        }
    }
}
ImBeen
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JAVA SE(基础 第2篇) 面向对象编程（初级）
07-28 157
面向对象初级
java中对象作为参数_java中对象引用，特别作为参数时候注意事项
weixin_28900073的博客
02-16 439
1、基础知识1Byte=8bitByte和byte一个是对象，一个是基本数据类型而已，都是8bit2、java中对象引用和值传递：(1)、java中若一对象当作参数就是相当于，将变量对应的指向的地址内容传递进去了如下面代码：public class Test {public static void main(String[] args) {StringBuffer a = new StringBu...
JAVA运算的类型兼容原则_Java基础语法回顾(一)
weixin_42128141的博客
03-02 813
Java基础语法Java规范image.pngJava字节码java程序是以".java"为扩展名，当我们编写完java程序后,要执行程序需要经过两个阶段：编译和运行。编译器执行编译程序的称为编译器，java将java源文件编译成为字节码(bytecode)。字节码是高度优化的指令集合，但是字节码并不能直接被计算机所执行，这些指令只有java运行时系统执行(又称Java虚拟机，Java Vitua...
Java基础——类和对象
explorer363的博客
04-26 3万+
本篇博客介绍了Java中类和对象的基本内容，看完本篇博客后，希望大家能对类和对象能有进一步的了解
java类与对象实验报告心得体会_java类和对象实验报告(共10篇).doc
weixin_39878745的博客
12-19 3693
java类和对象实验报告(共10篇)java类和对象实验报告(共10篇) java类与对象实验报告篇二：JAVA语言实验报告(类和对象)JAVA程序设计实验报告学生：学号：班级：专业：实验六 ........................................................................................................
【Java】类和对象详解
qq_61635026的博客
06-15 6595
面向对象（Object-oriented）是一种程序设计的方法和编程范式，它以对象作为程序的基本单位，通过封装、继承、多态等概念来组织和实现程序逻辑。面向对象的编程思想强调将问题分解为对象的集合，每个对象具有自己的状态（属性）和行为（方法），并通过相互之间的消息传递来实现协助和交互。类（Class）是用来对一个实体（对象）进行描述的，主要包括实体（对象）的属性和行为的描述。在Java语言中，类是面向对象编程的基本组织单位，它是对象的模版或者蓝图，描述了对象的属性和行为。
java类与对象实验报告心得体会_java类和对象实验报告(共10篇)
weixin_39941847的博客
12-19 4293
java类和对象实验报告(共10篇) 为了适应公司新战略的发展，保障停车场安保新项目的正常、顺利开展，特制定安保从业人员的业务技能及个人素质的培训计划java类和对象实验报告共10篇JAVA程序设计实验报告学生学号班级专业实验六3实验目的.3实验要求.3实验基本内容.3题目一.3题目二.6题目三构造一个矩形类Rectangle，包含求矩形周长和面积的方法.6实验小结.7实验目的理解面向对象的基本概...
JAVA 面向对象 类 对象 封装
热门推荐
程序媛泡泡的博客
05-07 6万+
面向对象概念 面向对象其实是一种编程思想，通过它可以把生活中复杂的事情变得简单化，从原来的执行者变成了指挥者。 面向对象是基于面向过程而言的。 面向过程强调的是过程,比如: 打开冰箱门 2. 把大象放进去 3. 关上冰箱门 面向对象强调的是结果,比如: 什么样的冰箱?什么样的大象?谁负责把大象装进去? 而不是关注那个负责的人怎么把大象装冰箱里. 衣服脏了，直接让女盆友去处理,等着穿干净的就可以了。你不关注中间的过程,只要找好对象就可以了~ 再比如.我们想吃一道菜,无需考虑是怎么传菜,怎么做菜的,只需点菜即
Java对象与Java类
KOOKNUT的博客
07-29 4075
文章目录1.面向对象是什么?2.Java类1.什么是类2.Java类类的结构Java类的格式3.java对象4.类和对象5.类中的变量，方法1.变量分类2.方法分类6.方法重载7.对象与引用基本类型和引用类型的区别:值传递与引用传递8.static关键字概念static属性static方法代码块9.类的加载执行10.包包的概念：包的作用：包（package）的命名规范：访问权限修饰符11.面向对象语言的三大特征1.封装2.多态3.继承12.类于类之间的关系1.关联关系(has-a)2.依赖关系(uses-a
java类与对象实验报告心得体会_java上机实验心得体会报告（大全五篇）
weixin_42325867的博客
12-29 2万+
北京联合大学信息学院“面向对象程序设计”课程上机实验报告题目：JAVA上机实验心得体会 姓名(学号)：专业：计算机科学与技术编制时间：2012年12月19日版本：1.0.0指导教师：北京联合大学-信息学院编制 实验1 熟悉Java运行环境实验目的：熟悉JDK环境和操作，编写简单的Java应用程序。心得体会：在该实验中，我碰到的问题是JDK环境变量的设置。解决方法是通过查阅资料书和网上搜索相关解决...
java类和对象原理与用法分析
08-25
Java类和对象原理与用法分析 Java类和对象是Java编程语言的基础概念，它们是面向对象编程（OOP）的核心内容。类和对象的概念、功能、原理、使用技巧与操作注意事项都是Java开发者必须掌握的知识点。 类和对象的...
JAVA类与对象及数组习题
10-16
JAVA类与对象及数组习题 JAVA类和对象及数组是JAVA编程语言的基础概念。下面是关于JAVA类和对象及数组的习题，涵盖了构造方法、继承、多重继承、变量声明、数组初始化等方面的知识点。 1. 构造方法的调用方式： ...
java类和对象实验.pdf
10-04
Java 类和对象实验 在 Java 编程语言中，类和对象是最基本的概念。类是对现实世界的抽象，对象是类的实例。类定义了对象的属性和行为，而对象是类的实例，拥有自己的状态和行为。 1. 类的定义 在 Java 中，类的...
Java类和对象的概念-Java教程共3页.pdf.zip
11-25
以上就是关于"Java类和对象的概念"的一些核心知识点。理解并熟练掌握这些概念对于编写高效、可维护的Java代码至关重要。通过深入学习和实践，你可以创建出复杂的系统，充分利用Java的面向对象特性。
Java面向对象流程图
12-08
1. **类与对象** 类是面向对象编程的基础，可以看作是创建对象的模板或蓝图。它定义了对象的状态（数据成员，也称为属性或字段）和行为（成员函数，也称为方法）。对象则是类的实例，拥有类所定义的属性和方法。 2...
【Spring Boot】高效配置管理: 易用性与灵活性并重
weixin_68020300的博客
08-07 1253
本文探讨了Spring Boot中多样化的配置读取方法及其应用场景，强调了配置管理的重要性，并展示了Spring Boot如何通过灵活多变的配置选项简化这一过程。此外，文章还展望了配置管理领域未来的技术趋势和发展方向。对于任何希望深入了解Spring Boot配置管理的开发者来说，这是一篇不容错过的好文。
C++ - 函数重载
jiaowenjie的专栏
08-06 329
/打印的是第二个函数的地址。//打印的是第一个函数的地址。-> 重载函数在本质上是相互独立的不同函数。-> 函数返回值不能作为函数重载的依据。-> 重载函数的函数类型不同。**3.函数默认参数和函数重载****函数重载的注意事项：****4.函数重载的本质**
伐木工 (100%用例)D卷 (Java&&Python&&C++&&Node.js&&C语言)
荆赫同艺的博客
08-07 233
一根 4米长的树木，伐木工不需要切割为 2*2，省去切割成本，直接整根树木交易，为 4*1，收益最大为 4。方式二: 3,2,2,3，但方式二，伐木工多切割一次，增加了切割成本却卖了一样的价格，因此并不是最优收益。一根 2 米长的树木，伐木工不切割，为2*1，收益最大为 2。一根5 米长的树木，伐木工切割为 2*3,收益最大为 6。输出最优收益时的各个树木长度，以空格分隔，按升序排列。一根 10 米长的树木，伐木工可以切割。方式一:3,4,4，也可以切割为。
Spring事务
最新发布
c1tenj2的博客
08-07 436
以银行转账为例，一次转账操作伴随着一个账户的扣钱和另一个账户的加钱，这个流程是一个原子操作，要么同时发生，一气呵成，要么都不做。AccountServiceImpl实现AccountService接口，里面只有一个转账方法AccountMapper以及其映射文件account数据库测试代码用1/0模拟程序运行时出现异常的情况由于没有开启事务，出现了莫名其妙少了100块钱的情况，说明这个事务不是连续的。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值