Java教程

面向对象、类和对象、封装---------私有private、this关键字

本文主要是介绍面向对象、类和对象、封装---------私有private、this关键字,对大家解决编程问题具有一定的参考价值,需要的程序猿们随着小编来一起学习吧!

1、面向对象和面向过程

面向对象是让谁干什么

面向过程是按什么顺序来干(干活过程都有参与)

所以在工作中,面向对象更好。

例如:

以打扫办公室为例:面向过程就是将扫地、拖地、擦玻璃、擦门窗这几件事情排好(做好)顺序,先干啥再干啥,需要按照顺序一件一件的参与干活‘

面向对象就是打扫卫生时,小李拖地,小杨擦玻璃,小张擦门窗,小孙擦门窗,每个人干不同的活,最后将办公室打扫干净;

再比如:买电脑:面向过程就是查找想要的型号,询价零件、购买、组装、搬回家。在整个过程中我们参与了每一个细节,并且会感觉相当累。

面向对象就是找个专门懂得人帮忙查看配置、组装等,不需要亲历亲为具体怎么做,只要告诉这个人我们想要的具体需求即可。

 面向过程思维方式中更多的体现的是执行者(自己做事情),面向对象中更多的体现是指挥者(指挥对象做事情)。

2、类和对象

 (1)类在需求中的使用--------------类的定义方式及在代码中的实现

已将大象关进冰箱这个需求来举例:

需求:把大象装冰箱里

对象:大象、冰箱

分三步:

  第一步打开冰箱门

  第二部将大象装进去

  第三步关闭冰箱门

冰箱对象具备如下功能:

  冰箱打开

  冰箱存储

  冰箱关闭

------------1、创建冰箱的对象

  冰箱 bx = new 冰箱();  

-----------2、调用冰箱的功能

  对象.功能();

  bx.打开();

  bx.存储(new 大象());

  bx.关闭();

代码就是:

public class Daxiang {

}//先定义一个Daxiang类

 

public class Bingxiang {//再定义一个 Bingxiang,类名大写

public void open(){//方法

 System.out.println("冰箱打开了");
 }
public void save(Daxiang dx){
 System.out.println("将大象装进来");
 }
public void close(){ 
  System.out.println("冰箱关闭了"); 
  }
 }

 

public class Test {//定义一个测试的类public static void main(String[] args) {
        Bingxiang bx = new Bingxiang();//创建对象,new 一个对象Daxiang dx = new Daxiang();
        bx.open();//调用方法bx.save(dx);
        bx.close();
    }

}

 

l定义类的格式

public class 类名 {

  //可编写0至n个属性

      数据类型 变量名1;

      数据类型 变量名2;

  //可编写0至n个方法

  修饰符 返回值类型 方法名(参数){

  执行语句;

  }

  }

再以汽车为例:

汽车(事物)的特点(属性):

汽车的颜色。

轮胎个数。

事物的(功能):

运行。

-----------即:

--------------小汽车 {

------------------------------颜色;

------------------------------轮胎个数;

---------------------运行() { }

---------------------}

public class Car {
    String color;//颜色int number;--------------成员变量public void run() {//定义一个方法,
        System.out.println(color + ":" + number);
    }
}

 

类的真正意义就是在描述事物。属性和功能统称为事物中的成员。

事物的成员分为两种:成员属性和成员功能。

成员属性在代码中的体现就是成员变量

成员功能在代码中的体现就是成员方法

public class CarDemo {public static void main(String[] args) { /* *  测试:Car类中的run方法。         */// 1,创建Car的对象。给对象起个名字。Car c = new Car();// c是类类型的变量。c指向了一个具体的Car类型的对象。// 2,通过已有的对象调用该对象的功能。格式:对象.对象成员;// 3,可以该对象的属性赋值。c.color = "red";
        c.number = 4;
        c.run();
    }
}

 

(2)类和对象的区别

----------------类是对某一类事物的抽象描述,而对象用于表示现实中该类事物的个体。

例如:制作玩具的模型就是类,对象则是一个个玩具

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

第一个:定义位置不同:成员变量是在类中,局部变量是在方法中或者{}语句里面

第二个:在内存中的位置不同:局部变量在栈中的方法里,成员变量在堆中的类中

第三个:生命周期不同:局部变量随着方法的运行而出现在栈中,随着方法的弹栈而消失;成员变量则是随着类在存储在堆中,对象消失,成员变量才消失

第四个:初始化不同:成员变量随着类进入堆中,会被默认赋值为0或者null等,局部变量没有初始化值,手动赋值才行

 3、封装

1、封装概述

封装:在方法中,就是将具体的功能封装到方法中。在对象中就是将方法封装到类中。

面向对象的三个基本特征:封装、继承、多态

①封装的表现:

-------------方法就是一个最基本的封装体

-------------类其实也是一个封装体

②封装的好处:

---------------提高了代码的复用性

--------------隐藏了实现细节,向外部提供访问的方式,便于调用者使用,这是封装的核心,也可以说是封装的概念。

---------------提高了安全性

③封装的举例说明:就拿台式机的主机来说,主机有cpu、硬盘、主板等构成,如果主机外部不加一个外壳,那么内部的组成部分就裸露在外部,会变得很不安全

外壳就可以看成是一个封装,其上的USB等接口可以看成是其提供的让外部访问的方式。

(2)私有private

类中的属性的行为可以任意访问和使用,因此要使用关键字也是一个修饰符(私有private)。

例如:

package demo01;//privat:私有,可以修饰类,被修饰的成员只能在本类中访问public class Person { private int age;---------------私有化private String name;//对外提供公共访问方式public void setage(int a){if(a>=0&&a<130){
        age=a;
    }else {
    age=0;
    }
}public int getage(){//-----------------------鼠标右击------------Source------Generate Getters and Setterreturn age;
}public void setname(String n){
    name=n;
}public String getname(){return name;
}public void speak(){
    System.out.println("我叫"+name+",今年"+age+"岁");
}
}

package demo01;public class Text {public static void main(String[] args) {
        Person p=new Person();
        p.setname("佩奇");//-------------通过方法赋值。访问私有的对象属性
        p.setage(18);
        p.speak();
        System.out.println(p.getage());
        System.out.println(p.getname());
    }

}

 

l 总结:

类中不需要对外提供的内容都私有化,包括属性和方法。

以后再描述事物,属性都私有化,并提供setXxx getXxx方法对其进行访问。

l 注意:私有仅仅是封装的体现形式而已。

(3)this关键字

在方法中出现局部变量和成员变量同名时,可以添加this关键字来进行区分,可以在成员变量名前面加上this.来区别成员变量和局部变量

Public class Person {private int age;private String name;    public void speak() {this.name = "小强";this.age = 18;
        System.out.println("name=" + this.name + ",age=" + this.age);
    }
}

Public class PersonDemo {public static void main(String[] args) {
        Person p = new Person();
        p.speak();
    }
}

对象的内存解释

程序执行流程说明:

1、首先在数据和方法共享区读取.class文件,main方法。

2、 先执行main方法(压栈),执行其中的 Person p = new Person();

3、看到new一个对象则 在堆内存中开辟空间,并为其分配内存地址0x000,紧接着成员变量默认初始化(age = 0);将内存地址0x000赋值给栈内中的Person p 变量

4、继续执行p.setAge(30)语句,这时会调用setAge(int age)方法,将30赋值为setAge方法中的“age”变量;执行this.age = age语句,将age变量值30 赋值给成员变量this.age为30;

5、setAge()方法执行完毕后(弹栈),回到main()方法,执行输出语句System.out.println(),控制台打印p对象中的age年龄值。

 

4、继承

(1)继承的概述:

在程序中,继承描述的是事物之间的所属关系,通过继承可以使多种事物之间形成一种关系体系。

例如:

类的继承是指在一个现有类的基础上去构建一个新的类,构建出来的新类被称作子类,现有类被称作父类,子类会自动拥有父类所有可继承的属性和方法。

格式:

public   class 子类 extends 父类 {  }

集成的举例:

package damo03;public class Fu {int a=6;
}

package damo03;//在继承中,成员变量的特点://如果父类成员变量和子类成员变量同名,那么调用的是子类的成员变量//在继承中,子类只能继承父类可继承的成员,私有化的成员,可以继承,但是没法使用和操作,相当于没继承public class ZI extends Fu{//------------------继承父类int a=2;public void speak(){int a=3;
        System.out.println(this.a);
        System.out.println(super.a);
    }
}

package damo03;public class Text1 {public static void main(String[] args) {
    ZI bb=new ZI();
    bb.speak();
}
}

Zi类通过extends关键字继承了Fu类。

子类虽然没有定义int a=1;的属性和work()方法,但是却能访问这这个成员。这就说明,子类在继承父类的时候,会自动拥有父类的成员。

 

 继承的好处与注意事项:

好处:

1、提高了代码的复用性,

2、继承的出现让类与类之间产生了关系,提供了多态的前提。

 注意事项:

1、在Java中,类只支持单继承,不允许多继承,也就是说一个类只能有一个直接父类 

class A{}

     class B{}

     class C extends A,B{}  // C类不可以同时继承A类和B类

2、多个类可以继承一个父类

 class A{}

     class B extends A{}

     class C extends A{}   // 类B和类C都可以继承类A

(2)子父类中成员变量的特点

----------------Fu类中的成员变量是非私有的,子类中可以直接访问,若Fu类中的成员变量私有了,子类是不能直接访问的。当子父类中出现了同名成员变量时,在子类中若要访问父类中的成员变量,必须使用关键字super来完成。super用来表示当前对象中包含的父类对象空间的引用。

在子类中,访问父类中的成员变量格式:

super.父类中的成员变量

class Fu
{//Fu中的成员变量。int num = 5;
}

class Zi extends Fu
{//Zi中的成员变量int num = 6;void show()
    {//子父类中出现了同名的成员变量时//在子类中需要访问父类中非私有成员变量时,需要使用super关键字//访问父类中的numSystem.out.println("Fu num="+super.num); //访问子类中的num2System.out.println("Zi num2="+this.num);
    }
}

class Demo5 
{public static void main(String[] args) 
    {
        Zi z = new Zi(); //创建子类对象z.show(); //调用子类中的show方法    }
}

 (3)子类继承父类的的方法特点:直接继承和重写

当在程序中通过对象调用方法时,会先在子类中查找有没有对应的方法,若子类中存在就会执行子类中的方法,若子类中不存在就会执行父类中相应的方法。

class Fu{-----------------------------------------------------------------------------父类public void show(){---------------------------------------------------------------show方法
        System.out.println("Fu类中的show方法执行");
    }
}class Zi extends Fu{-------------------------------------------------------------------子类继承父类的方法public void show2(){---------------------------------------------------------------子类的show2方法
        System.out.println("Zi类中的show2方法执行");
    }
}public  class Test{public static void main(String[] args) {
        Zi z = new Zi();
        z.show(); //-------------------------------------------------------------------子类中没有show方法,但是可以找到父类方法去执行        z.show2();----------------------------------------------------------------------父类中没有show方法,就执行的父类中的方法
    }
}

 成员方法特殊情况——覆盖

子类中出现与父类一模一样的方法时,会出现覆盖操作,也称为override重写、复写或者覆盖。方法重写

class Zi extends Fu
{//子类复写了父类的show方法public void show()
    {
        System.out.println("Zi show");
    }
}

l 方法重写(覆盖)的应用:

当子类需要父类的功能,而功能主体子类有自己特有内容时,可以重写父类中的方法,这样,即沿袭了父类的功能,又定义了子类特有的内容。

例如:增加功能

比如手机,当描述一个手机时,它具有发短信,打电话,显示来电号码功能,后期由于手机需要在来电显示功能中增加显示姓名和头像,这时

可以重新定义一个类描述智能手机,并继承原有描述手机的类。并在新定义的类中覆盖来电显示功能,在其中增加显示姓名和头像功能。

class Phone{--------------------------------------------属性public void sendMessage(){
        System.out.println("发短信");
    }public void call(){
        System.out.println("打电话");
    }public void showNum(){
        System.out.println("来电显示号码");
    }
}

//智能手机类class NewPhone extends Phone{-----------------------继承父类属性    //覆盖父类的来电显示号码功能,并增加自己的显示姓名和图片功能public void showNum(){//调用父类已经存在的功能使用supersuper.showNum();//增加自己特有显示姓名和图片功能System.out.println("显示来电姓名");
        System.out.println("显示头像");
    }
}

 

 

public class Test {public static void main(String[] args) {new NewPhone().showNum();
    }
}

 

注意:

l 子类方法覆盖父类方法,必须要保证权限大于等于父类权限。

l 写法上稍微注意:必须一模一样:方法的返回值类型 方法名 参数列表都要一样。

总结:当一个类是另一个类中的一种时,可以通过继承,来继承属性与功能。如果父类具备的功能内容需要子类特殊定义时,进行方法重写。

 

这篇关于面向对象、类和对象、封装---------私有private、this关键字的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!