精华内容
下载资源
问答
  • 使用Java的String操作字符串子串。 实验内容: 1.写一个程序提示用户键入某一货币数量(以分为单位),该程序应计算出如何用最少量1元,50分,10分1分硬币得到该数目。如195分最少可以用一个1元硬币,1个50分...
  • java类的组成部分

    2020-12-03 21:03:42
    成员变量可以使用Java语言中任何一种数据类型(包括基本类型引用类型)。 在定义成员变量时可以对其初始化,如果不对其初始化,Java使用默认值对其初始化。 成员变量在创建对象时候会从中复制一份到对象中。...

    类由属性,方法,构造方法 ,内部类 ,代码块这5个部分组成
    也就是说只有这5个部分才可以出现在类中,本篇博客介绍前三个

    类中变量

    成员变量

    1. 成员变量是定义在类中,方法体之外的变量。
    2. 成员变量可以使用Java语言中任何一种数据类型(包括基本类型和引用类型)。
    3. 在定义成员变量时可以对其初始化,如果不对其初始化,Java使用默认的值对其初始化。
    4. 成员变量在创建对象的时候会从类中复制一份到对象中。
    5. 成员变量可以被类中方法、构造方法和特定类的语句块访问。
    6. 成员变量的作用范围为整个类体。

    局部变量

    1. 在方法、构造方法或者语句块中定义的变量被称为局部变量。
    2. 局部变量可以使用Java语言中任何一种数据类型(包括基本类型和引用类型)。
    3. 局部变量在使用前必须初始化赋值。
    4. 变量声明和初始化都是在方法中,方法结束后,变量就会自动销毁。

    类变量

    类变量:(也叫静态变量)类变量也声明在类中,方法体之外,但必须声明为static类型。

    构造方法

    构造方法也叫做构造器,它的结构为

    [修饰符列表] 构造方法名 (形参列表){
       构造方法体
    }
    
    • 构造方法没有返回值(与返回值为空不同)。
    • 构造方法名与类名相同。
    • 构造方法是类的方法,可以对对象进行初始化操作。
    • 如果在一个类中没有定义构造方法的话,系统会为这个类提供一个缺省的构造方法,称为缺省构造器,这个构造方法没有形式参数,也没有具体的语句。
    • 构造方法可以重载 ,可以定义多个不同参数的构造方法,构造方法之间也可以相互调用。
    • 构造方法可以继承 , 子类可以继承父类的构造方法。

    类中的方法

    成员方法, 静态方法, 构造方法

    三种方法都可以重载,这里补充一下方法重载

    方法重载

    方法的重载是指一个类中可以定义有相同的名字,但参数不同的多个方法。 调用时,会根据不同的参数表选择对应的方法。

    方法重载的条件

    1.同一个类中 2.方法名相同

    3.参数不同(数量不同,类型不同,顺序不同)

    注意:方法重载跟方法的返回值类型,访问权限没有任何关系

    成员方法:成员方法是定义在类中。这种方法在创建对象的时候创建。

    构造方法:用来创建对象的方法

    /**
     * 人类
     */
    public class Person {
    
           /*
              成员变量
            */
           String name;
           int age;
    
           /*
              构造方法
              方法名与类名相同,没有返回值,不需要void修饰
              一个类中可以拥有多个构造方法(方法重载)
              如果类中没有显示的声明构造方法,类中会默认有一个无参构造方法
              一旦类中定义了有参的构造放法,默认无参的构造方法会被覆盖, 建议显示的写出来.
            */
           public  Person(){
               System.out.println("Person构造方法1");
           }
    
           public Person(String n,int a){
                  name = n;
                  age = a;
                  System.out.println("Person构造方法2");
           }
    
           public Person(String n){
                  name = n;
                  System.out.println("Person构造方法3");
           }
    
           public Person(int n,int a){
                  System.out.println("Person构造方法4");
           }
    
           public Person(int a,String n){
                  System.out.println("Person构造方法5");
           }
    
    
           /*
           成员方法
           语法格式:
     	   修饰符  返回值类型  方法名 ( 参数列表) {
      	   方法体语句;
           [return 返回值]
          } 
            */
           public void eat(){
    
           }
           public void eat(int a){
    
           }
           public void eat(int a,int b){
    
           }
           public void eat(String a,int b){
    
           }
        //类方法:(也叫静态方法)类方法也声明在类中,但必须声明为static类型
           public static void study(){
    
           }
        
           public static void study(int a){
    
           }
    
    展开全文
  • 1.数组 概念:是一种容器,可同时存放多个数据值。 特点:(1)数组是一种引用数据类型。...左侧数据类型:即数组中保存数据统一类型。 左侧中括号:代表是一个数组,而不是变量。 左侧数组名称:给数

    目录

    1.数组

    动态初始化数组的格式:

    默认值规则

    静态初始化数组的格式:

    静态方式的省略格式

    注意:

    2.java的内存划分

    3.数组内存图

    4.数组常见的问题

    5.面向对象

    (1)类和对象

    (2)对象的创建及使用

    (3)对象的内存图

    (4)成员变量和局部变量的区别

    三大特征之封装性

    private关键字的作用及使用

    this关键字

    构造方法(方法名字是类名,不需要返回值类型)

    定义一个标准的类


    1.数组

    概念:是一种容器,可同时存放多个数据值。

    特点:(1)数组是一种引用数据类型。(2)数组中的多个数据,类型必须统一。(3)数组长度再程序运行期间不可改变。

    数组的初始化:在内存中创建一个数组,并向其中赋予一些默认值。

    初始化方式:(1)动态初始化(指定长度)。(2)静态初始化(指定内容)。

    动态初始化数组的格式:

    数据类型[] 数组名称=new 数据类型[数组长度];

    左侧数据类型:即数组中保存的数据的统一类型。

    左侧的中括号:代表是一个数组,而不是变量。

    左侧的数组名称:给数组取的名字。

    右侧的new:代表创建数组的动作。

    右侧的数据类型:必须和左侧的数据类型保持一致。

    右侧中括号的数字:表述数组的长度,该数组可以保存数据的数量,并且是int数字。

    例如:int[] arrrayA = new int[300]; double[] arrayB = new double[100];

    注意:使用动态初始化的时候,其中的元素将会自动拥有一个默认值,

    默认值规则

    (1)整数类型,默认为0。

    (2)浮点类型,默认为0.0。

    (3)字符类型,默认为‘\u0000’  ,这个是一个字符的特殊写法,\u表示使用unicode,后面4位表示16进制;在unicode中,16进制为0000的字符是不可见字符,打印不可见。

    (4)布尔类型,默认值false。

    (5)引用类型,默认值null。

    静态初始化数组的格式:

    (1)标准格式

    数据类型[] 数组名称=new 数据类型[] {元素1,元素2,...}

    例如:int[] arrayA = new int[] {5,15,25};    String[] arrayB = new String[] {"Hello","World! ","Java"};

    静态方式的省略格式

    数据类型[] 数组名称 = {元素1,元素2,元素3,...};

    例如: int[] arrayA = {10,20,30};

    注意:

    (1)虽然静态初始化没有直接告诉长度,但是可以根据大括号中的元素具体内容,可以自动推算出来长度。

    (2)静态初始化标准化格式可以拆分成两个步骤,先定义一个静态数组变量,然后再初始化。

    (3)动态初始化也可以拆分成两个步骤。

    (4)静态初始化一旦使用省略格式,就不能拆分成两个步骤了。

    (5)静态初始化也有默认值过程,只不过系统自动马上将默认值替换成了大括号中的具体数值。

     使用建议:如果不确定数组当中的具体内容,用动态初始化;否则,已经确定了具体内容,用静态初始化。

    访问数组元素进行获取:

    如果直接打印数组名称,得到的是数组对应的内存地址哈希值。例如:[I@75412c2f     前面的[表示数组,I表示int数据类型,后面的数字和字母串表示十六进制的内存地址。

    访问数组元素的格式:数组名称[索引值]    其中索引值是一个int数字,代表数组元素中的排序编号,从0开始。

    2.java的内存划分

    java内存需要分成5个部分。

    1.栈(stack):存放的都是方法中的局部变量。方法的运行一定要在栈中。

    局部变量:方法的参数,或者是方法{}内部的变量。

    作用域:一旦超出作用域,立刻从栈内存中消失。

    2.堆(Heap):凡是new出来的东西都在堆中。

    特点:(1)堆内存里面的东西都有一个地址值:16进制。(2)堆内存里面的数据都有默认值,规则和动态初始化默认值规则一致。

    3.方法区(Method Area):存储.class相关信息,包含方法的信息。

    4.本地方法栈(Native Method Stack):与操作系统相关。

    5.寄存器(PC Register):与CPU相关。性能非常高。

    3.数组内存图

    一个数组的内存图:

    两个数组的内存图:

    一个引用指向同一个数组的内存图:

    两个引用指向同一个数组的内存图:

    4.数组常见的问题

    (1)如果访问数组元素的时候,索引编号并不存在,那么将会发生数组索引越界异常。ArrayIndexOutOfBoundsException.原因:索引编号写错。解决:修改成存在的正确索引编号。

    (2)空指针异常。所有的数据类型,都可以赋值为一个null值,但是代表什么都没有。数组必须进行new初始化才能使用其中的元素。如果只是赋值了一个null值,没有进行new创建,那么将会发生空指针异常。NullPointerException。原因:忘了new。解决:补上new。

    public class ArrayNull {
        public static void main(String[] args) {
            int[] array = null;
            array = new int[3]; // 补上new
            System.out.println(array[2]);
        }
    }
    

    获取数组的长度。格式:数组名称.length  这将会得到一个int数字,代表数组的长度。数组一旦创建,程序运行期间,长度不可改变。

    数组作为方法的参数,传递进去的其实就是数组的地址值。数组作为方法的返回值,返回的也是数组的地址值。

    5.面向对象

    面向过程:当需要实现一个功能的时候,每一个具体的步骤都要亲力亲为,详细处理每一个细节。

    面向对象:当需要实现一个功能的时候,不关心具体的步骤,而是找一个已经具有该功能的人来帮我做事。

    特点:面向对象思想是一种更加符合我们思考习惯的思想,它可以将复杂的事情简单化,并将我们从执行者变成了指挥者。面向对象的语言中,包含了三大基本特征,即封装、继承和多态。

    (1)类和对象

    类:是一组相关属性和行为的集合。可以看成一类事物的模板,使用事物的属性特征和行为特征来描述该类事物。

    属性:就是该事物的相关信息。对应java中就是成员变量。

    行为:就是该事情能做什么。对应Java中就是成员方法。

    对象:是一类事物的具体体现。

    类和对象的关系:

    • 类是对一类事物的描述,是抽象的。
    • 对象是一类事物的实例,是具体的。
    • 类是对象的模板,对象是类的实体。

     类的定义格式:

    public class ClassName {  // 类的定义格式
        // 成员变量
        // 成员函数
    }

    定义类:就是定义类的成员,包括成员变量和成员方法。

    成员变量:和以前定义变量几乎是一样的。只不过位置发生了。直接定义再来类当中,方法外。因为之前的变量都要定义在方法内部。例如:String name; int age;

    成员方法:和以前定义方法几乎是一样的,只不过把static去掉,static的作用(知识点待填)。例如:public void eat() {}; public void sleep(){};

    (2)对象的创建及使用

    通常情况下,一个类不能直接使用,需要根据类创建一个对象,才能使用。

    《1》导包:指出需要使用的类,以及路径。  import 包名称.类名称。对于和当前类属于同一个包的情况,可以省略导包语句不写。

    《2》创建的格式:类型名 对象名 = new 类名称()

    《3》使用分为两种情况:使用成员们变量(对象名.成员对象名)和成方法(对象名.成员方法名)

    (3)对象的内存图

    一个对象的内存图:

     两个对象使用同一个方法的内存图:

    两个引用指向同一个对象的内存图:

    使用对象类型作为方法的参数,以及内存图

    使用对象类型作为方法的返回值,以及内存图

    (4)成员变量和局部变量的区别

    注意:方法的参数也是局部变量,参数在调用的时候,必然会被赋值。

    1. 定义位置不一样。局部方法:定义在方法的内部。成员变量:定义在方法的外部,直接写在类中。
    2. 作用范围不一样。局部变量:只有方法中才可以使用,出了方法就不能再用。成员变量:整个类全都可以通用。
    3. 默认值不一样。局部变量:没有默认值,如果要想使用,必须手动进行赋值。成员变量:如果没有赋值,规则和数组默认值一样。
    4. 内存的位置不一样。局部变量:位于栈内存。成员变量:位于堆内存。
    5. 生命周期不一样。局部变量:随着方法进栈而诞生,随着方法出栈而消失。成员变量:随着对象创建而诞生,随着对象被垃圾回收而消失。

    三大特征之封装性

    封装就是将一些信息隐藏起来,对于外界不可见。

    封装在Java中的提现:

    1. 方法就是一种封装
    2. 关键字private也是一种封装

    private关键字的作用及使用

    问题描述:定义Person的年龄时,无法阻止不合理的数值被设置进来。

    解决方案:用private关键字将需要保护的成员变量进行修饰。好处:那么外边无法直接访问只能间接访问,间接的方式能够组织那些不合理的数据被设置进来,提高了代码的安全性。

    格式:private + 成员变量,例如: private int age;

    一旦使用了private进行修饰,那么本类当中仍然可以随意访问。但是,超出本类范围之外就不能直接访问了。

    间接访问private成员变量,就是定义一对Getter/Setter,方法命名必须叫setXxx或者getXxx规则。对于Getter来说,不能有参数,返回值类型和成员变量对应;对于Setter来说,不能有返回值,参数类型和成员变量对应。

    public class Person{
      String name; //姓名
      private int age; //年龄
      private boolean male;
      public void show(){
        System.out.println("我叫: "+ name +", 年龄:"+ age );
      }
    // 这个成员方法,专门用于设置私有成员变量age的值
      public void setAge(int num){
        age=num;
      }
    // 这个成员方法,专门用于获取私有成员变量age的值
      public int getAge(){
        return age;
      }
    // 对于布尔型基本数据类型
      public void setMale(boolean b){
        male=b;
      }
      public boolean isMale(){
        return male;
      }
    }

    注意:对于基本类型中的Boolean值,Getter方法一定要写成isXxx的命名规则形式,而Setter方法命名规则不变。

    this关键字

    问题描述:当方法中的局部变量和成员变量重名的时候,根据“就近原则”,优先使用局部变量。

    解决方案:如果需要访问本类中的成员变量,需要使用格式:this.成员变量。this变量可以解决重名分不开的问题。“通过谁调用的方法,谁就是this”
    因为this一定是写在方法里面的,

    public class Person{
      String name;
      public void sayHello(String name){
        System.out.println(name+",你好。我是"+name);
      }
    }
    // 实例化调用
    public class DemoPerson{
      public static void main(String[] args){
        Person person=new Person();
        person.name="jupy";
        person.sayHello("tobey");  //tobey,你好。我是tobey。采用就近原则,不能访问成员变量。
      }
    }
    // 修改Person类当中的方法,使用this关键字
    public class Person{
      String name;
      public void sayHello(String name){
        System.out.println(name+",你好。我是"+this.name);
      }
    }
    // 那么上述输出就会变成,tobey,你好。我是jupy

    构造方法(方法名字是类名,不需要返回值类型)

    构造方法是专门用来创建对象的方法,当我们使用关键字new来创建对象时,其实就是在调用构造方法。

    格式: 

    public 类名称(参数类型 参数名称){

      方法体;

    }

    注意事项:

    1. 构造方法的名称必须和所在的类名称完全一样,就连大小写也是一样。构造方法虽然是一个方法,但是不适用小驼峰,使用的是大驼峰规则,并且不需要自己起名字。
    2. 构造方法不要写返回值类型,连void都不写。
    3. 构造方法不能return一个具体的返回值。
    4. 如果没有编写任何构造方法,那么编译器会默认赠送一个构造方法,没有参数、方法体什么事情都不做。即public Student(){}
    5. 一旦编写了至少一个构造方法,那么编译器将不再赠送。
    6. 构造方法也是可以进行重载。重载:方法名称相同,参数列表不同。

    定义一个标准的类

    标准类通常要拥有以下四个组成部分:

    1. 所有的成员变量都要使用private关键字修饰。
    2. 为每一个成员变量编写一对Getter/Setter方法。
    3. 编写一个无参数的构造方法。
    4. 编写一个全参数的构造方法。

    这样标准的类也叫做Java Bean。

    package demo2;
    
    public class Student {
        private String name; // 姓名
        private int age; // 年龄
    
        public String getName() {
            return name;
        }
    
        public Student() {
        }
    
        public Student(String name, int age) {
            this.name = name;
            this.age = age;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public int getAge() {
            return age;
        }
    
        public void setAge(int age) {
            this.age = age;
        }
    }
    
    //下面是上面类的使用
    package demo2;
    
    public class Demo02Student {
        public static void main(String[] args) {
            Student stu1 = new Student();
            stu1.setName("迪丽热巴");
            stu1.setAge(20);
            System.out.println("姓名:"+stu1.getName()+",年龄:"+stu1.getAge());
            System.out.println("========================================");
    
            Student stu2 = new Student("古力娜扎",21);
            System.out.println("姓名:"+stu2.getName()+",年龄:"+stu2.getAge());
            stu2.setAge(22);
            System.out.println("姓名:"+stu2.getName()+",年龄:"+stu2.getAge());
        }
    }
    
    展开全文
  • 1: Java 类的定义形式 一个完整的 Java 类通常由下面六个部分组成: 包定义语句 import 语句 类定义{ 成员变量 构造方法 成员方法 } 其中:只有类定义“{}”是不可或缺的,其余部分都可以根据需要来定义。 类=...

    1: Java 类的定义形式
    一个完整的 Java 类通常由下面六个部分组成:
    包定义语句
    import 语句
    类定义{
    成员变量
    构造方法
    成员方法
    }
    其中:只有类定义和“{}”是不可或缺的,其余部分都可以根据需要来定义。

    类=属性+行为

    访问修饰符

    Java 语言允许对类中定义的各种属性和方法进行访问控制,即规定不同的保护等级来限
    制对它们的使用。为什么要这样做?Java 语言引入类似访问控制机制的目的在于实现信息
    的封装和隐藏。Java 语言为对类中的属性和方法进行有效地访问控制,将它们分为四个等级:
    private, 无修饰符, protected, public,具体规则如下:


    变量和方法可以处于四个访问级别中的一个:公共,受保护,无修饰符或私有。类可以
    在公共或无修饰级别。
    变量、方法或类有缺省(无修饰符)访问性,如果它没有显式受保护修饰符作为它的声
    明的一部分的话。这种访问性意味着,访问可以来自任何方法,当然这些方法只能在作为对
    象的同一个包中的成员类当中。
    以修饰符 protected 标记的变量或方法实际上比以缺省访问控制标记的更易访问。一个
    protected 方法或变量可以从同一个包中的类当中的任何方法进行访问,也可以是从任何子
    类中的任何方法进行访问。当它适合于一个类的子类但不是不相关的类时,就可以使用这种
    受保护访问来访问成员。

    类定义

    Java 程序的基本单位是类,你建立类之后,就可用它来建立许多你需要的对象。Java
    把每一个可执行的成分都变成类。

    类的定义形式如下:

    <权限修饰符> [一般修饰符]    class    <类名> {

                            [<属性定义>]

                            [<构造方法定义>]

                            [<方法定义>]

            }

    这里,类名要是合法的标识符。在类定义的开始与结束处必须使用花括号。你也许想建
    立一个矩形类,那么可以用如下代码:

    public class Rectangle{

            ......//矩形具体的属性和方法

    }

    构造方法

    什么是构造方法

    类有一个特殊的成员方法叫作构造方法,它的作用是创建对象并初始化成员变量。在创
    建对象时,会自动调用类的构造方法。

    构造方法定义规则

    Java 中的构造方法必须与该类具有相同的名字,并且没有方法的返回类型(包括没有
    void)。另外,构造方法一般都应用 public 类型来说明,这样才能在程序任意的位置创建类
    的实例--对象。

    示例

    下面是一个 Rectangle 类的构造方法,它带有两个参数,分别表示矩形的长和宽:

    public class Rectangle{
    public Rectangle(int w,int h) {
    width=w;
    height=h;
    }

    }

    说明
    每个类至少有一个构造方法。如果不写一个构造方法,Java 编程语言将提供一个默认的,
    该构造方法没有参数,而且方法体为空。
    注意:如果一个类中已经定义了构造方法则系统不再提供默认的构造方法。

    属性
    属性是什么

    简单点说,属性就是对象所具有的静态属性。


    定义规则
    Java 类中属性的声明采用如下格式:

    访问修饰符 修饰符 类型 属性名称=初始值;

    访问修饰符:可以使用 四种不同的访问修饰符中的一种,包括 public(公共的)、
    protected(受保护的),无修饰符和 private(私有的)。public 访问修饰符表示属性可以
    从任何其它代码调用。private 表示属性只可以由该类中的其它方法来调用。protected 将
    在以后的课程中讨论。
    修饰符:是对属性特性的描述,例如后面会学习到的:static、final 等等。
    类型:属性的数据类型,可以是任意的类型。
    属性名称:任何合法标识符
    初始值:赋值给属性的初始值。如果不设置,那么会自动进行初始化,基本类型使用缺
    省值,对象类型自动初始化为 null。

    说明
    属性有时候也被称为成员变量、实例变量、域,它们经常被互换使用。

    方法
    方法是什么

    方法就是对象所具有的动态功能。


    定义规则
    Java 类中方法的声明采用以下格式:

    访问修饰符 修饰符 返回值类型 方法名称 (参数列表) throws 异常列表 {方法体}

    访问修饰符:可以使用 四种不同的访问修饰符中的一种,包括 public(公共的)、
    protected(受保护的),无修饰符和 private(私有的)。public 访问修饰符表示方法可以
    从任何其它代码调用。private 表示方法只可以由该类中的其它方法来调用。protected 将
    在以后的课程中讨论。
    修饰符:是对方法特性的描述,例如后面会学习到的:static、final、abstract、
    synchronized 等等。
    返回值类型:表示方法返回值的类型。如果方法不返回任何值,它必须声明为 void(空)。
    Java 技术对返回值是很严格的,例如,如果声明某方法返回一个 int 值,那么方法必须从
    所有可能的返回路径中返回一个 int 值(只能在等待返回该 int 值的上下文中被调用。)

    方法名称:可以是任何合法标识符,并带有用已经使用的名称为基础的某些限制条件。
    参数列表:允许将参数值传递到方法中。列举的元素由逗号分开,而每一个元素包含一
    个类型和一个标识符。在下面的方法中只有一个形式参数,用 int 类型和标识符 days 来声
    明:public void test(int days){}
    throws 异常列表:子句导致一个运行时错误(异常)被报告到调用的方法中,以便以
    合适的方式处理它。异常在后面的课程中介绍。
    花括号内是方法体,即方法的具体语句序列。


    示例
    比如现在有一个“车”的类——Car,“车”具有一些基本的属性,比如四个轮子,一个
    方向盘,车的品牌等等。当然,车也具有自己的功能,也就是方法,比如车能够“开动”—
    —run。要想车子能够开动,需要给车子添加汽油,也就是说,需要为 run 方法传递一些参
    数“油”进去。车子跑起来过后,我们需要知道当前车辆运行的速度,就需要 run 方法具有返回值“当前的速度”。
    package cn.javass.javatest;
    public class Car {// 车这个类
    private String make;// 一个车的品牌
    private int tyre;// 一个车具有轮胎的个数
    private int wheel;// 一个车具有方向盘的个数

    public Car() {
    // 初始化属性
    make = "BMW";// 车的品牌是宝马
    tyre = 4;// 一个车具有4个轮胎
    wheel = 1;// 一个车具有一个方向盘
    }
    /**
    * 车这个对象所具有的功能,能够开动
    * @param oil 为车辆加汽油的数量
    * @return 车辆当前运行的速度
    */
    public double run(int oil) {
    // 进行具体的功能处理
    return 200.0;
    }
    }


    形参和实参
    形参:
    就是形式参数的意思。是在定义方法名的时候使用的参数,用来标识方法接收的
    参数类型,在调用该方法时传入。
    实参:就是实际参数的意思。是在调用方法时传递给该方法的实际参数。

    比如:上面的例子中“int oil”就是个形式参数,这里只是表示需要加入汽油,这个方
    法才能正常运行,但具体加入多少,要到真正使用的时候,也就是调用这个方法的时候才具
    体确定,加入调用的时候传入“80”,这就是个实际参数。
    形参和实参有如下基本规则:
    (1):形参和实参的类型必须要一致,或者要符合隐含转换规则
    (2):形参类型不是引用类型时,在调用该方法时,是按值传递的。在该方法运行时,
    形参和实参是不同的变量,它们在内存中位于不同的位置,形参将实参的值复制一份,在该
    方法运行结束的时候形参被释放,而实参内容不会改变。
    (3):形参类型是引用类型时,在调用该方法时,是按引用传递的。运行时,传给方法
    的是实参的地址,在方法体内部使用的也是实参的地址,即使用的就是实参本身对应的内存
    空间。所以在函数体内部可以改变实参的值。

    如何使用一个 Java 类


    1:new 关键字
    假如定义了一个表示日期的类,有三个整数变量;日、月和年的意义即由这些整数变量
    给出。如下所示:
           class MyDate 
    int day;
    int month;
    int year;

    名称 MyDate 按照大小写的有关约定处理,而不是由语意要求来定。

    那么怎么来使用这个类呢:在你可以使用变量之前,实际内存必须被分配。这个工作是
    通过使用关键字 new 来实现的。如下所示:
    在一个方法体中,声明


    MyDate today;
          today = new MyDate();

    第一个语句(声明)仅为引用分配了足够的空间,而第二个语句则通过调用对象的构造方
    法为构成 MyDate 的三个整数分配了空间。对象的赋值使变量 today 重新正确地引用新的对
    象。这两个操作被完成后,MyDate 对象的内容则可通过 today 进行访问。
    关键字 new 意味着内存的分配和初始化,new 调用的方法就是类的构造方法。

    使用一个语句同时为引用 today 和由引用 today 所指的对象分配空间也是可能的。
          MyDate today = new MyDate();


    如何使用对象中的属性和方法
    要调用对象中的属性和方法,使用“.”操作符。
    例如:
         today.day = 26;
         today.month = 7;
         today.year = 2008;

    this 关键字
    关键字 this 是用来指向当前对象或类实例的,功能说明如下:


    点取成员
    this.day 指的是调用当前对象的 day 字段,示例如下:
    public class MyDate {
    private int day, month, year;
    public void tomorrow() {
        this.day = this.day + 1;
          //其他代码
    }
    }

        Java 编程语言自动将所有实例变量和方法引用与 this 关键字联系在一起,因此,使用
    关键字在某些情况下是多余的。下面的代码与前面的代码是等同的。
    public class MyDate {
    private int day, month, year;
    public void tomorrow() {
        day = day + 1; // 在 day 前面没有使用 this 
        //其他代码
    }
    }

    区分同名变量
    也有关键字 this 使用不多余的情况。如,需要在某些完全分离的类中调用一个方法,并
    将当前对象的一个引用作为参数传递时。例如:
    Birthday bDay = new Birthday (this);
    还有一种情况,就是在类属性上定义的变量和方法内部定义的变量相同的时候,到底是
    调用谁呢?例如:
    public class Test{
    int i = 2;
    public void t(){
        int i = 3; //跟属性的变量名称是相同的
        System.out.println(“实例变量 i=”+ this.i);
        System.out.println(“方法内部的变量 i=”+ i);
    }
    }

    也就是说:“this.变量”调用的是当前属性的变量值,直接使用变量名称调用的是相
    对距离最近的变量的值。

    作为方法名来初始化对象
    也就是相当于调用本类的其它构造方法,它必须作为构造方法的第一句。示例如下:
    public class Test {
    public Test(){
    this(3);//在这里调用本类的另外的构造方法
    }
    public Test(int a){

    }
    public static void main(String[] args) {
    Test t = new Test();
    }   
    }

    set和get方法:

    有GET和SET是为了封装private的数据,这样做是面向对象设计的思想。向外提供接口,而不让外面直接调用自己的成员。提供对属性值进行有效性验证的方法,防止随意改动属性的值

    展开全文
  • 类的定义 类的重要性:是Java程序的基本组成单位

    类的定义

    类的重要性:是Java程序的基本组成单位
    类是什么:是对现实生活中一类具有共同属性和行为的事物的抽象,确定对象会拥有的属性和行为。

    类的组成:属性和行为
    属性:在类中通过 成员变量 来体现(类中方法外的变量)
    行为:在类中通过 成员方法 来体现(和前面的方法相比去掉static关键字即可)

    在这里插入图片描述

    对象的使用

    创建对象

    在这里插入图片描述
    package one.hundred;

    public class PhoneDemo {
    public static void main(String[] args) {
    //创建对象
    Phone p = new Phone();

        System.out.println(p.brand);
        System.out.println(p.price);
        //使用成员变量
        p.brand = "小米";
        p.price = 3000;
        System.out.println(p.brand);
        System.out.println(p.price);
        //使用成员方法
        p.call();
        p.message();
    }
    

    }

    展开全文
  • java-类的结构及使用

    2017-07-19 19:40:00
    面向对象基本概念 对象实质是:属性+行为 类: -----类是具有共同属性行为的对象的集合 -----类定义了对象的属性方法 -----通过类可以实例化多个该类的对象,每个对象的属性值不同,可以说类...Java类的基...
  • 使用JavaDateCalendar Java 语言Calendar(日历),Date(日期), DateFormat(日期格式)组成Java标准一个基本但是非常重要部分. 日期是商业逻辑计算一个关键部分. 所有开发者都应该能够计算未来...
  • 形式:将数据行为组合在一起,并对对象的使用者隐藏数据实现方式 类和对象概念是什么?他们是什么关系? 面向对象编程特点是什么?几个重要特征分别是什么? 中几个主要的组成部分是什么? 封装有什么...
  • 对变量,方法和类等要素命名时使用的字符。 命名规则: 由26个英文字母大小写 ,0-9,_ , 或 $ 组成. 数字不可以开头 不可以使用关键在保留字,但可以包含关键字保留字。 Java中严格区分大小写,长度无限制。 ...
  • 1、抽象类的基本概念 若在一个类中要定义一个没有方法体的方法,可以利用abstract关键字进行抽象方法定义,而包含抽象方法的类就可以使用abstract来定义为抽象类。 为什么会出现抽象类的概念?有什么作用? 类的...
  • Java中正则表达式的基本使用

    千次阅读 2016-11-25 09:44:25
    这里主要介绍的是Java中的正则类的基本使用。学了这些基本类的学习后,就可以查看更深入的正则规则。 学了本篇内容你就学习了Java正则的40%剩下的50%~60%需要读者查看API,学习更好的匹配规则更多的相关练习!!...
  • Java 语言Calendar(日历),Date(日期), DateFormat(日期格式)组成Java标准一个基本但是非常重要部分. 日期是商业逻辑计算一个关键部分. 所有开发者都应该能够计算未来日期, 定制日期显示格式, 并将...
  • Java的基本语法 编写Java程序时,应注意以下几点: 1、大小写敏感:Java是大小写敏感的,这就意味着标识符Hello与hello是不同的。...当保存文件的时候,你应该使用public类的类名作为文件名保存(切记J...
  • java 类和对象

    2020-11-23 20:38:26
    一、面向对象的基本概念: ...二、和对象的定义和使用: 在java中定义,使用关键字class来完成。 class 名称{ 属性; 方法 } 例如:定义一个Person: public class Person { // 定义属性 String name; St
  • java内部类的使用

    2016-05-11 13:50:00
    内部类不是很好理解,但说白了其实也就是一个类中还包含着另外一个类 如同一个人是由大脑、肢体、器官等身体结果组成,而内部类相当于其中的某个器官之一...实例1:内部类的基本结构 //外部类 class Out { p...
  • Java类和对象

    2020-05-17 11:27:00
    对象的基本概念 ... 由类构造对象的过程称为创建类的实例 ,用 Java 编写的所有代码都位于某个类的内部。 类对象的使用: 1.定义一个class类 //定义一个class类 class 类名称 { 属性 (变量) ;
  • Java内部类的使用

    2016-02-29 22:35:00
    内部类不是很好理解,但说白了其实也就是一个类中还包含着另外一个类 如同一个人是由大脑、肢体、器官等身体结果组成,而内部类相当于其中的某个器官之一...实例1:内部类的基本结构 1 2 3 ...
  • Java 语言Calendar(日历),Date(日期), DateFormat(日期格式)组成Java标准一个基本但是非常重要部分. 日期是商业逻辑计算一个关键部分. 所有开发者都应该能够计算未来日期, 定制日期显示格式, 并将...
  • 主要涉及了类的组成、构造方法、基本数据类型引用数据类型的默认值 案例二 主要涉及重载this关键字的使用以及构造方法的作用 ...
  • Java内部类的使用小结

    2017-08-15 19:14:00
    java中的内部类总结 内部类不是非常好理解。但说白了事实上也就是一个类中还包括着另外一个类 如同一个人是由大脑、肢体、器官等身体结果组成。而内部类相当于当中的某个器官之...实例1:内部类的基本结构 ...
  • 关键字: 如何使用javadatecalendar Java 语言Calendar(日历),Date(日期), DateFormat(日期格式)组成Java标准一个基本但是非常重要部分. 日期是商业逻辑计算一个要害部分. ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 873
精华内容 349
关键字:

java类的基本组成和使用

java 订阅