Java面向对象程序设计:类的定义,静态变量,成员变量,构造函数,封装与私有,this概念与用法详解

本文实例讲述了Java面向对象程序设计:类的定义,静态变量,成员变量,构造函数,封装与私有,this概念与用法。分享给大家供大家参考,具体如下:

本文内容:

  • 什么是面对对象
  • 类的定义与对象实例化
  • 成员变量
    • 成员变量的有效范围
    • 成员变量的赋值
  • 静态变量、方法与实例变量、方法
  • 构造函数
  • 封装与私有
  • this关键字

注:函数和方法是一样东西。【由于我之前学习的时候有些书籍不是同样的说法,书看多了,我就习惯了不同情况下用不同的说法】

首发时间:2018-03-22


什么是面对对象:

  • 面向对象强调行为处于对象之中,并不直接执行行为,而是通过对象执行行为
  • 类是对象的抽象,对象是类的具体实例。 【可以说,人是一个类,而不同身份的你我他是一个具体实例。人这个类抽象出了我们人类共有的属性,而我们人是人类的各种属性的具体实例结果。】
  • 面向对象的基本特征:封装,继承,多态
    • 封装:比如一个对象把它的属性和方法都封装起来的话,它执行的属性和方法都是这个对象的,而不是其他对象的。
    • 继承:子类可以继承父类的属性和方法。比如“人类”继承了“哺乳类”的属性和方法,又增添人类独有的属性和方法。
    • 多态:一种多态是指同一个操作被不同对象执行时有不同的结果(比如:狗的say是“汪汪汪”,而猫的是"喵喵喵");另一种多态是根据对象的传入而决定执行不同的方法。【本质上这两个是一样的】

类的定义与对象实例化:

类的定义:

  • 类的定义包括两部分:类声明和类体
  • 类是java程序的基本要素
  • 定义类的格式:
    • 修饰符可以是public 或空: public代表即使不同包也能访问该类;而空代表只能该类只能在同一个包内访问。
    • 类体的内容包括变量的生命和方法的定义。【所以单独的定义是错误的,只能声明并同时定义】

对象实例化

  • 类的实例化就是创建一个对象:

    • 创建对象:类名 变量名 =new 类名()【类名()可以传入一些参数来初始化对象,由类的同名方法(构造方法,下面讲)定义能传入什么参数】

      • 匿名对象:简单来说就是没有变量名的实例化,直接使用new 类名()来执行操作,由于没有变量名来特异的标记一片内存空间,所以匿名对象一般只使用一次,比如new Dog().hello();
    • 调用方法或变量:对于实例方法或变量的可以直接使用对象来调用;而对于静态方法或变量,既可以使用对象,也可以使用类来调用。
class Dog{
  String name;
  int foot=4;
  Dog(){//这是一个构造函数
    this.name="旺财";
  }
  void hello() {
    System.out.println("hello,this is a dog");
  }
  static void static_hello() {
    System.out.println("hello,this is a dog too");
  }

}

public class Demo {

  public static void main(String args[]) {

    Dog d=new Dog();
    System.out.println(d.foot);//4
    d.hello();//hello,this is a dog
    d.static_hello();//hello,this is a dog too
    Dog.static_hello();//hello,this is a dog too

  }
}

成员变量:

成员变量的有效范围

  • 成员变量在整个类范围内有效,与变量声明的位置无关。方法中的局部变量从声明它的位置开始生效,并且只在方法体内有效。
  • 当局部变量跟成员变量同名时,如果想特别的使用成员变量,可以使用“this.变量名”
  • 成员变量有默认值,而局部变量没有默认值。

成员变量的赋值:

  • 可以使用构造函数来对一些成员变量初始化
  • 如果成员变量不是私有的,也可以直接取得变量名来赋值,比如dog.age=18

静态变量、方法与实例变量、方法:

根据变量、方法是否有static修饰可以分为实例变量,实例方法和静态变量(类变量),静态方法(类方法)

  • 静态变量,静态方法:

    • 被static修饰的成员的特点:

      • 随着类的加载而加载,优先于对象存在,静态成员内存位于方法区
      • 被所有对象所用享【所以可称为类变量或类方法】
      • 可以直接类名调用
      • 静态方法只能访问静态成员
      • 静态方法中不可以写this,super关键字
  • 实例变量、实例方法:

    • 实例变量、实例方法是对象的变量和方法,对象操作变量或方法也只是操作自己的变量或方法,不会影响其他对象。

实例变量\方法跟静态变量\方法的区别好比:“泰迪狗类”比如有一个共有属性“狗种类名”,那么这个属性应该是所有泰迪狗都有的,并且是泰迪狗共享的,如果某一天人类想改泰迪狗的种类名称,那么应该是所有泰迪狗都改的(静态的);而每一只泰迪狗都有自己的主人,这是由每一只狗自身决定的,所以这是特有属性,即使这只狗换了主人,也不会影响别的狗。(实例的)


构造函数:

  • 构造函数是类中的一种特殊函数,构造函数的名字与类的名字相同,而且没有类型。
  • 构造函数负责对类对象的特定属性初始化。【比如每一只狗对象都有不同的名字,而狗类是一个模板,是没有名字的,而构造函数可以做到给狗定义名字。】
  • 类中可以有多个构造函数,它们以函数重载的方式存在。
  • 构造函数是没有类型的,是直接以“ 类名(){}” 作为函数。
  • 类中会默认有一个无参数的构造函数,如果定义了其他构造函数,那么这个默认的无参构造函数就会不默认存在了。
class Dog{
  String name;
  Dog(){
    this.name="旺财";
  }
  Dog(String name){
    this.name=name;
  }
}
public class Init_usage {

  public static void main(String args[]) {

    Dog d3=new Dog();
    Dog d4=new Dog("小菜");
    System.out.println(d3.name);
    System.out.println(d4.name);
  }
}

补充:

  • 构造函数之间可以相互调用,但要防止递归调用。

    • 调用其他构造函数来实现初始化在有多个变量需要初始化的时候有明显的代码节省。

封装与私有:

  • 类的封装的一个体现是变量和函数的私有化
  • 封装的准则:
    • 将不需要对外提供的内容都隐藏起来。
    • 将属性都隐藏,提供公共方法对其访问。
  • 私有化使类的非公共属性隐藏了起来,比如一个“人类”对象有自己的资产,一般只有自己才能知道自己有多少资产,并且不想直接给别人看到,但如果别人问题,还是会告诉别人的(隐藏了自己的资产情况,但是自己能够使用方法获得结果,这个方法是开放的,调用就是相当于别人问)。
  • 可以使用private来使变量和函数私有化,这样之后不能直接使用 对象.变量 或 对象.函数 来调用,只有对象内部的方法才能调用
  • 将变量或方法私有化之后,一般对外提供getXXX,setXXX方法进行访问,提高数据访问的安全性。
class Man{
  private int money;
  String name;
  Man(String name,int money){
    this.name=name;
    this.money=money;
  }
  int getmoney(){
    return money;
  }
  void setMoney(int money){
    this.money=money;
  }

}

public class Private_usage {

  public static void main(String[] args) {
    Man m=new Man("lilei",2000);
    System.out.println(m.name);//lilei
//    System.out.println(m.money);//报错的,因为私有了,不能访问
//    System.out.println(m.wife);//报错的,因为私有了,不能访问
    System.out.println(m.getmoney()); //2000
    m.setMoney(6000);
    System.out.println(m.getmoney());//6000

  }

}


this关键字:

  • this代表当前对象(调用函数时代表当前调用该函数的对象),比如在类中可以使用this.XXX来调用对象自己的变量或方法。
  • 当局部变量和成员变量同名时,可以用this关键字区分,this.XXX代表使用对象自身的变量
  • 类中的成员变量默认是带有this前缀的,但遇到同名时必须加以区分。
  • this加上参数列表(this(参数))的方式就是访问本类中符合该参数的构造函数
  • 用于调用构造函数的this语句必须放在第一行,因为初始化动作要优先执行
class Person{
  String name;
  int age;
  Person(String name,int age){
    this.name=name;
    this.age=age;
  }
  void hello() {
    this.sysprint();
//    sysprint();
  }
  void sysprint() {
    System.out.println("hello world!");
  }
}

public class This_usage {
  public static void main(String args[]) {
    Person p1=new Person("lilei",18);
    p1.hello();//hello world!

  }

}

更多关于java相关内容感兴趣的读者可查看本站专题:《Java面向对象程序设计入门与进阶教程》、《Java数据结构与算法教程》、《Java操作DOM节点技巧总结》、《Java文件与目录操作技巧汇总》和《Java缓存操作技巧汇总》

希望本文所述对大家java程序设计有所帮助。

(0)

相关推荐

  • Java构造函数与普通函数用法详解

    函数也被称为方法! 函数的作用及特点: 1.用于定义功能,将功能封装. 2.可以提高代码的复用性. 函数注意事项: 1.不能进行函数套用(不可以在函数内定义函数). 2.函数只有被调用才能被执行. 3.基本数据类型(String.int.-.)修饰的函数类型,要有return返回值. 4.void修饰的函数,函数中的return语句可以省略不写. 5.函数名可以根据需求进行命名. 代码示例:(有无函数/方法的区别) 无函数/方法代码例子: public class NoFunc { public

  • java泛型类的定义与使用详解

    本文为大家分享了java泛型类的定义与使用的具体代码,供大家参考,具体内容如下 当类中要操作的引用数据类型不确定时,可以定义泛型类完成扩展.下面是程序演示. package packB; class Student { //定义学生类 public String st = "student"; } class Worker { //定义工人类 public String wo = "worker"; } //定义泛型类 class Operate<type&g

  • java中成员变量与局部变量区别分析

    本文实例分析了java中成员变量与局部变量区别.分享给大家供大家参考.具体分析如下: 成员变量:在这个类里定义的私有变量,属于这个类. 创建以及使用成员变量 复制代码 代码如下: public class Person {     String name;     String Sex;     int age;     double Height;         public static void main(String arges[])     {         Person p=ne

  • 简单谈谈java中匿名内部类构造函数

    先看看下面的代码能不能编译通过: public static void main(String[] args) { List l1 = new ArrayList(); List l2 = new ArrayList(){}; List l3 = new ArrayList(){{}}; System.out.println(l1.getClass() == l2.getClass() ); System.out.println(l2.getClass() == l3.getClass() );

  • 浅谈Java成员变量与属性的区别(简单最易懂的解释)

    例一: 一个Student pojo类: public class Student{ private String name; private int age; public String getName(){ return this.name; } public void setName(String name){ this.name = name; } public int getAge(){ return this.age; } public void setAge(int age){ t

  • Java static(静态变量)和私有化功能与用法分析

    本文实例讲述了Java static(静态变量)和私有化功能与用法.分享给大家供大家参考,具体如下: 1.static作用主要有两方面:其一,当希望类中的某些属性被所有对象共享,则就必须将其声明为static属性:其二,如果一个类中的方法由类名调用,则可以将其声明为static方法. 2.需要注意的是,非static声明的方法可以去调用statci声明的属性和方法:但是static声明的方法不能调用非static类型的声明的属性和方法. 3.static方法调用static变量 public c

  • Java类的定义以及执行顺序学习教程

    类必须先定义才能使用.类是创建对象的模板,创建对象也叫类的实例化. 下面通过一个简单的例子来理解Java中类的定义: public class Dog{ String name; int age; void bark(){ // 汪汪叫 System.out.println("汪汪,不要过来"); } void hungry(){ // 饥饿 System.out.println("主人,我饿了"); } } 对示例的说明: public 是类的修饰符,表明该类是公

  • java构造函数示例(构造方法)

    TestCar.java 复制代码 代码如下: public class TestCar {    public static void main(String[] args) {        Car c1 = new Car();        c1.color = "red";        c1.brand = "xxx";//如果这辆汽车有很多属性,这样一一赋值不是很麻烦?有没有办法一生产出来就设定它的属性(初始化)吗?有~~~看下面          

  • java中静态变量和实例变量的区别详细介绍

    运行效果: 控制台效果: ================================================== 代码部分 ================================================== /hello_test/src/com/b510/test/StaticTest.java 复制代码 代码如下: /**  *   */ package com.b510.test; /**  * 在程序运行时的区别:实例变量属于某个对象的属性,必须创建了实例

  • Java中类的定义与实例化详解

    类的定义 面向对象的程序设计中,类可以看作是我们自定义的数据类型,那么,如何能更加优美,更加高效地定义它就显得尤为重要. 类中的成员有很多,每一部分都是十分关键的,毕竟"面向对象"在Java学习中真的很重要,许许多多的Java开发者定义出来的类等待着我们去使用,加油!攻克它! 直接上代码: package com.my.pac02; /** * @author Summerday * @date 2019/11/26 21:40 */ //类名和文件名一致,且包含main方法 publ

  • Java 重载、重写、构造函数的实例详解

    Java 重载.重写.构造函数的实例详解 方法重写 1.重写只能出现在继承关系之中.当一个类继承它的父类方法时,都有机会重写该父类的方法.一个特例是父类的方法被标识为final.重写的主要优点是能够定义某个子类型特有的行为. class Animal { public void eat(){ System.out.println ("Animal is eating."); } } class Horse extends Animal{ public void eat(){ Syste

  • Java中static静态变量的初始化完全解析

    静态变量初始化顺序 1.简单规则 首先先看一段最普遍的JAVA代码: public class Test { public static Test1 t = new Test1(); public static int a = 0; public static int b; public static void main(String[] arg) { System.out.println(Test.a); System.out.println(Test.b); } } class Test1

随机推荐