java类和对象类的构造方法初始化对象-cnblog

java类和对象

成员变量

权限修饰符 变量类型 变量名;

成员变量可以是任意类型,整个类是成员变量的作用范围

成员变量

成员方法

权限修饰符 返回值类型 方法名()

成员方法可以有参数，也可以有返回值，用return声明

权限修饰符

private	只能在本类使用，无法被其他类，或者其他包里的内容引入
public 开放所有权限，可以被其他引用
protectd 可以被子类引入，但是无法被其他包内部的类引入

类中的局部变量

只在他所在位置的{}内部互动，注意在嵌套的区域不可以重复的定义局部变量，比如for循环内部嵌套for循环，局部变量会受到影响

举例：java值交互

package nb;

import java.util.Arrays;

public class swap_ {
    public static void swap(int a[], int i, int j) {
        int t = a[i];
        a[i] = a[j];
        a[j] = t;
    }

    public static void main(String[] args) {
        int a[] = {1,2,3,4,5};
        swap(a,1,2);
        System.out.println(Arrays.toString(a));
    }
}

this关键字

this关键字用于表示本类当前的对象,当前对象不是某个new出来的实体对象，而是当前正在编辑的类,this关键字只能用于本类中

写两个小案例

package nb;

public class XiaoFei {
    public static int cs = 0 ;
    double amount;
    public XiaoFei(double amount){
        cs++;
        this.amount = amount;
    }

    public void output(){
        System.out.println("你有一笔大额消费,交易金额:"+amount+"元");
    }

    public static void main(String[] args) {
        XiaoFei  xiaoFei = new XiaoFei(1);
        xiaoFei.output();
        XiaoFei xiaoFei1 = new XiaoFei(2);
        xiaoFei1.output();
    }
}

package nb;

public class Mima {
    int count;
    int pwd =123456;
//    public Mima(){
//        this(123456);
//    }

    public Mima(int count){
        this.count = count;
    }
    public Mima(int count, int pwd){
        this.count = count;
        this.pwd = pwd;
    }

    public static void main(String[] args) {
        Mima mima = new Mima(123);
        System.out.println("账户:"+mima.count);
        System.out.println("密码:"+mima.pwd);
        Mima mima1 = new Mima(123,456);
        System.out.println("账户1:"+mima.count);
        System.out.println("密码1:"+mima.pwd);
    }
}

类的构造方法

构造方法是一个与类同名的方法，对象的创建就是通过构造方法完成的

构造方法没有返回值

构造方法的名称和本类的名称相同

package nb;

public class JiDam {
    int eggCount;
    int a;
    public JiDam(int eggCount){
        this.eggCount = eggCount;
    }

    public JiDam(){
        this(1);
    }

    public static void main(String[] args) {
        JiDam jiDam = new JiDam();
        System.out.println("煎蛋1:"+jiDam.eggCount);
        System.out.println(jiDam.a);
        JiDam jiDam1 = new JiDam(2);
        System.out.println("煎蛋2:"+jiDam1.eggCount);
    }
}

静态变量和静态方法

携带static的变量或者方法，可以被其他类调用，受权限标志符限制

package nb;

public class Counts_ {
    static int count = 0;
    String name;
    public Counts_(String name){
        this.name = name;
        count++;
    }

    public static void main(String[] args) {
        Counts_ counts = new Counts_("tom");
        System.out.println("我的名字是:"+counts.name+"我的号牌是:"+count);
        Counts_ counts1 = new Counts_("tom1");
        System.out.println("我的名字是:"+counts1.name+"我的号牌是:"+count);
        Counts_ counts2 = new Counts_("tom2");
        System.out.println("我的名字是:"+counts2.name+"我的号牌是:"+count);
    }
}

类的初始化

static{}定义的是一块静态区域，这个区域被称为静态

可以对类进行初始化

注意

在静态方法中，不可以使用this关键字
在静态方法中不可以调用非静态方法
局部变量不可以使用static进行声明

类的主方法

psvm就是java最常出现的方法，是主方法

对象

在java语言中，通过new创建对象，每实例化一个对象就会自动调用一次构造方法，实际上这个过程就是创建对象的过程

访问对象的属性和行为

使用new创建对象之后可以采用对象.类成员 来获取对象的属性和行为

写一个描述狗特征的案例

package nb;

public class Dog {
    String name;
    String Color;
    String vioce;
    public Dog(String name,String color,String voice){
        this.name = name;
        Color = color;
        this.vioce = voice;
    }
    public void call(){
        System.out.println(vioce);
    }

    public static void main(String[] args) {
        Dog dog = new Dog("毛毛","黑的","嗷呜");
        System.out.println(dog.Color+dog.name+dog.vioce);
        dog.call();
    }
}

对象的引用

People tom = new People();
类名		引用			对象的实体
tom是一段内存地址，用来标记new People()在内存中的位置

对象的销毁

每个对象都有生命周期，当声明周期结束时，分配给该对象的内存会被回收