面向对象的案例解释代码含义;

-通过给定的题目分析类的属性与方法;

package Diyitongjin.Lianxi_01.shiuji;
/*定义一个类,用来模拟手机事物
*手机事物有两个组成部分
* 属性(成员变量)品牌,价格,颜色
* 行为(方法) 打电话,发短息
* 对应到类中,也有两个部分()
* */
public class Pnone {
    String brand; //品牌
    double price;//价格
    String color;//颜色
    //成员方法
    public void call(String who)//参数是谁打电话,参数就是谁。
    {
        System.out.println("给"+who+"打电话,请求援兵");
    }
    public void sendIdea(){//参数根据题目定  想有就有 无参  群发短信
        System.out.println("发个短信,祝福");
    }

}
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=

根据类进行实例化,创建对象,调用方法(有参方法要 传递值),成员变量(赋值)

package Diyitongjin.Lianxi_01.shiuji;
/*如何使用定义好的类
*
* 类是一种引用性数据,使用起来分为三个步骤;
*
* 1,导包
*   如果是用的目标类 和当前类位于一个包下 可以不用导包(省略导包不写)
*       否则需要import 导包
* 2.创建
* 类名称 对象名=new 类名称();
* 3.使用
* 调用成员变量 (对象名.属性)
* 调用成员 方法 (对象名.方法名)
* */
public class Shilihua {
    public static void main(String[] args) {
         Pnone ipone=new Pnone();//实例化类  创建一个手机对象

        System.out.println(ipone.brand);//null;  访问成员变量的默认值
        System.out.println(ipone.price);//0.0
        System.out.println(ipone.color);//null
        System.out.println("=====================");
        ipone.brand="ipone";
        ipone.price=9999;
        ipone.color="天空灰";
        System.out.println(ipone.brand);//ipone
        System.out.println(ipone.price);//9999
        System.out.println(ipone.color);//天空灰
        System.out.println("=====================");
        //调用成员方法
        ipone.call("王美丽护法");//含有一个String 类型的参数,所以在对调用方法的时候
        //给方法添加一个值(王美丽护法)
        ipone.sendIdea(); //没有参数的方法,在调用的时候不用,给值,
          直接打印输出方法的方法体内容

    }
}
==============================================================

成员变量 与局部变量的区别

1.定义的位置不同

局部变量:定义在方法内,成员方法的参数其实是一个局部变量;

成员变量:直接定义在类中,在方法外面

2.内存中的位置不一样

局部:在栈当中stack      成员 在堆当中 heap

3.生命周期不一样

局部:随着方法的进栈而出现,随着方法的出栈而消失

成员:随着对象创建而出现,随着对象被JVM回收而消失

4.默认值不一样

局部:必须赋值,不赋值,不能用

成员:如果没有赋值,有默认值。

============================================

一、Geter和Seter 用法

package Diyitongjin.Lianxi_01.person;
/*对类进行实例化的时候  其中如果 对象的 年龄属性不符合现实情况;但是却无法控制其
*取值范围,数据不安全,
* 解决办法;使用private;
* 一但使用private 关键字对成员进行了保护,那么超出了本类范围 ,就不能直接访问;
* 如果需要使用 private 修饰的成员变量,可以使用“简介访问”
* 为这个 private 成员变量 编写一对 Seter  Geter  方法
* */
public class Person {
    private int age;//保护属性  私有
    String name;
    //c成员方法
    public void show(){
        System.out.println("我叫"+name+", 今年"+age+"岁");
    }
    //专门用来设置成员变量数据的方法  Seter
    public void setAge(int num){//返回值类型必须是 void,
        // 参数类型 必须与与成员变量 类型一样
        if(num<0 ||num >200){//设置安全性,合理性检测,对数据进行把关
            System.out.println("数据错误");
        }else{
            age=num;
        }
    }//专门用来获取成员变量  数据的 方法;
    public int  getAge(){//返回值类型必须与成员变量 类型一样
        return age;//直接返回
    }
}
package Diyitongjin.Lianxi_01.person;

public class Dee {
    public static void main(String[] args) {
        Person m= new Person();
        m.show();
        m.name="王美丽";
        //m.age=-10;//不合理,错误写法 private 内容不能直接访问
        m.setAge(20);//用间接访问,能够保证数据的合理性,
        //在方法中可以限制方法体
        m.show();
    }
}

=====================================================

二、this关键字,解决重名问题; 

package LIANXI.this_01;
/*当局部变量和成员变量重名时,方法当中会根据“就近原则”使用;
* 如果需要区分一下,就要用到关键字,
* this.成员变量名   调用当前对象的成员变量
* this关键字的经典作用,将重名的成员变量和局部变量区分开
*
* 扩展
* this 关键字其实代表的是“当前对象”
* 记住一句话:通过谁调用的方法,谁就是 this 
* */
public class This_01 {
    String name;//姓名
    public void seeHello(String name){//对方的名字
        System.out.println(name+"你好。我是 "+this.name);
    }
}
package LIANXI.this_01;

public class Main {
    public static void main(String[] args) {
        This_01 n=new This_01();
        //设置自己的名字
        n.name="隔壁老王";
        n.seeHello("老李");
    }
}
===================================================
三、构造方法,就是专门用来创建对象的方法。当通过 new关键字创建对象时,其实就是在调用构造方法;

/*构造方法,就是专门用来创建对象的方法。
当通过 new关键字创建对象时,其实就是在调用构造方法;
*
*如何定义一个构造方法;,格式
* public 构造方法名(参数类型 参数名称){
*           方法体
*           //return;//通常最后一行 return省略不写
* }
* 调用构造方法的格式  就是创建对象的格式
* new 类名称();
 *注意:
 * 1,构造方法不能写返回值类型,连void 都不写
 * 2.构造方法的名称必须和所在的类名称完全一样,大小也要一样。
 * 
 */
public class Person {
            //构造方法
        public Person(){
            System.out.println("构造方法执行!");
        }
}
public class Dem_01 {
    public static void main(String[] args) {
        //创建一个Person类的对象
        Person one=new Person();//可以当做构造方法的名称
    }
}
2、构造方法也是一种方法,所以也可以进行方法重载(Overload)
重载,方法的名称相同,但是参数的列表不同
构造方法重载的好处;
定义一个无参的构造方法,可以直接new对象
定义一个重载的全参数的构造方法,可以再new对象的同时方便对成员变量进行赋值
public class Student {
    private String name;
    private int age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public Student(){
        System.out.println("无参的构造方法执行!");
    }
    public Student(int num){
        System.out.println("有参的构造方法执行!"+num);
        }
        public Student(String name,int age){
            this.age=age;
            this.name=name;
        }
}
public class Main_Student {
    public static void main(String[] args) {
        //调用无参的构造方法来创建对象
        Student one=new Student();
        //调用有参的构造方法来创建对象
        Student two=new Student(19);
        Student stu=new Student();
         stu.setAge(12);
         stu.setName("老王");

        Student xin=new Student("小心",10);
        //直接在new的时候通过构造方法给成员变量赋值
        System.out.println(xin.getName()+xin.getAge());
        //改变成员变量的值
        xin.setName("光头");
        System.out.println("姓名"+xin.getName()+"\t年龄"+stu.getAge());
    }
 }
3、构造方法的时候,注意事项;
       1.构造方法根本不写返回值类型,连void都不写;
        2.构造方法的名称和所在的类名称必须完全一样,大小写也必须一致
        3.构造方法也是可以重载的
        4.构造方法如果没有自定义,将会默认赠送一个。如果自定义了至少一个
         那么就不会再赠送默认的,如果想要就在自定义一个无参的构造方法;
    //如果没有定义任何构造方法,那么编译器将会默认赠送一个无参数。什么都不做的构造方
    法。样子如下
        public  Human(){}

================================================================

四、如何定义一个标准的类(POJO类plain Old Java Object)

        1.所有的成员变量变量需要使用 private 关键自私有

        2.为每一个成员变量编写一对 Gerter  Serter 方法。

        3.编写一个无参数的构造方法

        4.编写一个全参数的构造方法

注意事项:对于所有的数据类型,Getter 都必须叫getXx,Setter 都必须叫SetXxx ,但是有一个特例。

如果是基本数据类型中的Boolean值,那么setXxx规则不变,而getXxx需要写成isXxx的形式;

private Boolean male;

public void setMale(boolean male){

            this.male=male;

            }

练习

定义一个类;代表人,额外具有打招呼功能。根据类创建两个对象并赋值,让两个对象分别和对方打招呼;

package LIANXI.Man;

public class Man_01 {
    private String name;
    private  int age;

    public Man_01() {
    }

    public Man_01(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
    public void seeHello(String name){
        System.out.println(name+"你好.我是"+this.name+"我今年"+this.age);
    }
}
public class Moden_01 {
    public static void main(String[] args) {
        Man_01 man=new Man_01("亚瑟",23);
        Man_01 man1=new Man_01("后裔",54);
        man.seeHello(man1.getName());
        man1.seeHello(man.getName());
    }
}

====================================================

知识总结

1.面向过程:当需要实现一个功能的时候,每一个过程中的详细步骤和细节都要亲力亲为。

2.面向对象:当需要实现一个功能的时候,不关心详细的步骤细节,而是找人帮我做事;

3:类和对象的关系

        类是抽象的;通常不能直接使用;好像一张装备设计图;

        对象是具体的;根据一个类创建对象使用;也就是根据设计图把装备设计出来;

4,如何定义一个类:成员变量   成员方法

a)成员变量  直接定义在类中,在方法外变;

b)成员方法:去掉 static 关键字,其他的和普通的方法一样;

5.如何根据类创建对象: 格式    类名   对象名  =  new 类名();

6.如何使用这个对象

   a) 对象名.成员变量名 

    b)对象名.成员方法(参数);

7.局部变量和成员变量的不同;

定义位置不同

内存位置不同

生命周期不同

默认值不同

8.private关键字的用法:直接写在成员变量前面,类外面不能直接访问;确保安全性,间接访问

编写一对 Serter  Getter 方法。(特例 如果是Boolean getXxx 必须是isXxx的形式)

9.this关键字的用法      用来区分同名的成员变量的和局部变量  。成员不变量的前面写上 this 即可;

10.构造方法   专门用来创建对象的方法,通过new关键字创建对象就是在调用构造

a)构造方法  不能写返回值类型  void  也不能写

构造方法必须和所在的类名称完全一样,大小写也一样

构造方法也是可以重载的

构造方法如果没有定义,默认送一个,如果定义  就不再赠送

    


阅读更多
想对作者说点什么? 我来说一句

没有更多推荐了,返回首页

关闭
关闭
关闭