Java面向对象详细介绍（一）

//定义如下类：
class Car{
String color;
String name;
String model;
}
Car bm= new Car(); //创建对象
/*
“new Car()”  以Car类为模板，在堆空间里创建一个Car类对象
"Car bm" 创建了一个Car型引用变量，即可用来指向Car对象的对象引用
"=" 使对象引用指向创建的Car对象
*/

代码举例：

public class TestPerson {
    public static void main(String[] a){
         /*
             new Person()  在堆内存空间中创建了一个对象
             Person p1声明一个引用变量
             = 把对象在内存空间的地址赋给了左边的引用变量
         */
        Person p1=new Person();
        p1.name="张三";
        p1.age=18;
        Person p2=new Person();
        p2.name="李四";
        p2.age=15;
        Person p3=p2;//p2 p3指的是同一内存中对象的地址
        p3.name="王五";
        System.out.println(p1.name);//张三
        System.out.println(p2.name);//王五
        System.out.println(p3.name);//王五
    }
}

public class Person {
    String name;
    int age;
    public Person(){

    }
}

四.变量

1.成员变量：

public class Car {
    /*直接定义在类里面的内容，称为类的成员*/
    /*
    成员变量，类的属性，名词
        定义在类中，方法体外
        可以使用java中的任意数据类型(基本数据类型、引用数据类型)
        成员变量可以不为其默认赋值,java会为其默认赋值(构造方法中赋值)
        引用类型默认值 null
        整数   0
        浮点   0.0
        布尔值 false
        char  ' '
        创建对象时,会把成员变量给每个对象空间复制一份
        成员变量可以被成员方法,构造方法,代码块访问
        成员变量作用域为整个类体
        生命周期: 什么时候生(对象被创建), 什么时候销毁(对象被回收)
         */
    String color;
    String name;
    int price;
}

2.局部变量

public class Car{
    public void test(int x){
        /*
         局部变量
           在方法体内(成员方法,构造方法,代码块)
           局部变量可以使用java中任意的数据类型(基本类型,引用类型)
           局部变量不会被默认赋值
           只能作用域所在的代码块内
           生命周期: 什么时候生(方法被调用), 什么时候销毁(方法结束)
           方法的形参 也属于局部变量
        */
        /*
        int a;
        System.out.println(a); 错误，a没有进行初始化
        */
        System.out.println(x);
    }
}

五.方法的分类

1.构造方法

用来初始化对象的方法

public class Car{
 /*构造方法名与类名相同，没有返回值，不需要void修饰。
     new  Car();  类中默认是有一个无参的构造方法的,在默认的无参构造方法中为成员变量初始化        赋默认值。              
     一个类中可以定义多个构造方法.
        一旦类中定义了有参的构造方法,那么默认无参构造方法将不存在,除非显示定义无参构造方法   
     类中出现了多个名称相同的方法这一特征,称为方法重载.
     调用方法时如何区分这些名称相同的方法?
     可以通过参数的个数,类型,顺序来区分调用的具体是哪个方法
     注意: 方法的返回值与重载没有任何关系。
    */
    public Car(){
        System.out.println("无参构造方法");
    }
}

2.成员方法

public class Car{
    String color;
    String name;
    int price;
/*成员方法  类的行为  动词
    成员方法也可以重载*/
    public void run(){
        System.out.println(name+"以30km/s行驶");
    }
}

六.方法的重载

(1) 方法的重载是指同一个类中具有相同的名字，但参数不同的多个方法。

(2) 以参数的不同来区分：数量不同、类型不同、顺序不同

(3)方法重载和访问权限修饰符、返回值类型没有任何关系

1.构造方法的重载

public class Car{
     String color;
     String name;
     int price;
    public Car(){
        System.out.println("无参构造方法");
    }
    public Car(String a,String b,int c){
        System.out.println("3个参构造方法");
        name=a;
        color=b;
        price=c;
    }
    public Car(String a,String b){
        System.out.println("2个参构造方法");
        name=a;
        color=b;
    }
    public Car(int c,String a,String b){
        System.out.println("3个参构造方法");
        name=a;
        color=b;
        price=c;
    }
}

2.成员方法的重载

public class Car{
     String color;
     String name;
     int price;

    public void run(){
        System.out.println(name+"以30km/s行驶");
    }
    public void run(int speed){
        System.out.println(name+"以"+speed+"行驶");
    }
    public void stop(){
        System.out.println(name+"停止");
    }
}

整体总结创建代码

package Day1;
public class Car {
   //成员变量  构造方法为其默认赋初始值 
    String color;
    String name;
    int price;
    //构造方法及重载
    public Car(){
        System.out.println("无参构造方法");
    }
    public Car(String a,String b,int c){
        System.out.println("3个参构造方法");
        name=a;
        color=b;
        price=c;
    }
    public Car(String a,String b){
        System.out.println("2个参构造方法");
        name=a;
        color=b;
    }
    public Car(int c,String a,String b){
        System.out.println("3个参构造方法");
        name=a;
        color=b;
        price=c;
    }
    //成员方法及重载
    public void run(){
        System.out.println(name+"以30km/s行驶");
    }
    public void run(int speed){
        System.out.println(name+"以"+speed+"行驶");
    }
    public void stop(){
        System.out.println(name+"停止");
    }

    public void test(int x){
        
        /*
        int a;  局部变量
        System.out.println(a); 错误，a没有进行初始化*/
        System.out.println(x);
    }
}

public class TestCar {
    public static void main(String[] args) {
        Car bm = new Car();   //在内存中开辟了一块空格，存储对象
        bm.name = "宝马";
        bm.color = "白色";
        bm.price = 4000000;
        bm.run();
        bm.stop();
        System.out.println(bm.price);
        Car bc = new Car();
        bc.name = "奔驰";
        bc.color = "黑色";
        bc.price = 8000000;
        bc.run();
        bc.stop();
        System.out.println(bc.price);
        //无参构造为成员变量赋默认值
        Car dz =  new Car();
        System.out.println(dz.name);    //null
        System.out.println(dz.color);   //null
        System.out.println(dz.price);   //0
        dz.test(10);
    }
}

运行结果：

无参构造方法  //验证了 类中默认有一个无参的构造方法，为成员变量进行初始化赋值
宝马以30km/s行驶
宝马停止
4000000
无参构造方法
奔驰以30km/s行驶
奔驰停止
8000000
无参构造方法
null  //无参构造方法赋值的结果
null
0
10

七.调用方法时参数的传递

基本类型传递的是该数据值本身。引用类型传递的是对对象的引用，而不是对象本身

1.值传递

(形参数类型是基本数据类型)：方法调用时，实际参数把它的值传递给对应的形式参数，形式参数只是用实际参数的值初始化自己的存储单元内容，是两个不同的存储单元，所以方法执行中形式参数值的改变不影响实际参数的值。

创建代码：

//值传递———— 基本类型作为参数
public class TestValue {
    public void test(int x){
        x=20;//x的值发生改变，和a无关
    }
    public static void main(String[] arg){
        TestValue t=new TestValue();
        int a=10;
        t.test(a);
        System.out.println(a); //10
    }
}

2.引用传递

(形参数类型是引用数据类型参数)：也称为传地址。方法调用时，实际参数是对象，这时实际参数与形式参数指向同一个地址，在方法执行中，对形式参数的操作实际上就是对实际参数的操作，这个结果在方法结束后被保留了下来，所以方法执行中形式参数的改变将会影响实际参数。

/*引用传递 (本质上也是值传递,只是为了和基本类型区分,称为引用地址传递)*/
public class TestRef {
    public void test(Person p){//p=p1=1001  指的是同一个对象
        p.name="李四";
    }
    public static void main(String[] args) {
        TestRef t=new TestRef();
        Person p1=new Person();//p1=1001  一个地址
        p1.name="张三";
        p1.age=20;
        t.test(p1);//引用类型  只是将对象的引用地址值传递
        System.out.println(p1.name); //李四
    }
}

小谭同学ha

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
Java面向对象详细介绍（一）

类是一个模板，它描述一类事物的属性和行为的集合.类是表示一个客观世界某类群体的一些基本特征抽象.类的声明格式为:[访问权限修饰符] [修饰符] class Car{ }访问修饰符有两种public，无(默认)修饰符：final,abstract关键字class用来定义一个（首字母大写）是以类为模板在内存中创建的实际存在的实例。
复制链接

扫一扫