精华内容
下载资源
问答
  • Java 类与对象

    千次阅读 2020-10-11 00:10:46
    Java 类与对象 ** 一、首先,我们需要了解一下面向对象和面向过程的基本概念。 1.面向过程:在分析出解决问题的时候,首先把问题分成若干个步骤,然后将每个步骤都定义为一个函数,函数定义好了就意味着这个问题的...

    **

    Java 类与对象

    **
    一、首先,我们需要了解一下面向对象面向过程的基本概念。

    1.面向过程:在分析出解决问题的时候,首先把问题分成若干个步骤,然后将每个步骤都定义为一个函数,函数定义好了就意味着这个问题的解决步骤已经确定,使用时候就可以直接调用就行;

    2.面向对象:将构成问题事务分解成各个对象,建立对象的目的不是为了完成一个步骤,而是为了描叙某个事务在整个解决问题的步骤中的状态和行为。面对对象中体现的是产生行为的各个对象之间的关系。

    3.面向对象与面向过程的关系:面向对象是一种现在最为流行的程序设计方法,几乎现在的所有应用都以面向对象为主了,最早的面向对象的概念实际上是由IBM提出的,在70年代的Smaltalk语言之中进行了应用,后来根据面向对象的设计思路,才形成C++,而由C++产生了Java这门面向对象的编程语言。

    但是在面向对象设计之前,广泛采用的是面向过程,面向过程只是针对于自己来解决问题。面向过程的操作是以程序的基本功能实现为主,实现之后就完成了,也不考虑修改的可能性,面向对象,更多的是要进行子模块化的设计,每一个模块都需要单独存在,并且可以被重复利用,所以,面向对象的开发更像是一个具备标准的开发模式。

    4.面向对象的一些基本上的特征
    (1)封装:保护内部的操作不被破坏;
    (2)继承:在原本的基础之上继续进行扩充;
    (3)多态:在一个指定的范围之内进行概念的转换。

    二、类与对象的基本概念
    (1)类:是抽象的概念集合,表示的是一个共性的产物,类之中定义的是属性和行为(方法);
    (2)对象:对象是一种个性的表示,表示一个独立的个体,每个对象拥有自己独立的属性,依靠属性来区分不同对象。
    总而言之,类是对象的模板,对象是类的实例。类只有通过对象才可以使用,而在开发之中应该先产生类,之后再产生对象。类不能直接使用,对象是可以直接使用的。换言之,类的主要作用是用来作为一个模板,我们可以根据类来创建出许许多多的对象,而这些对象都具有在类中定义的属性和方法。如下图所示:
    在这里插入图片描述
    三、类与对象的定义和使用
    在Java中定义一个类,使用关键字class就能够完成,语法如下:

    class 类名称 {
             属性 (变量) ;
             行为 (方法) ;
    }
    

    范例:定义一个学生Student类

    public class Student {
    	//这是学生的属性
    	int stusorce;//分数
    	String name;//学生的名字
    	
    	//这是判断学生的考试成绩是否及格的方法
    	public void exam(int sorce) {
    		if(sorce < 60) {
    			System.out.println("考试没通过!");
    		}
    		else if(sorce >= 60) {
    			stusorce += 5;
    			System.out.println("考试通过!");
    		}
    	}
    
    

    定义完类之后,肯定无法直接使用的。如果需要使用的时候,则需要依靠对象,那么类属于引用数据类型,则它的引用格式有以下两种:
    (1)格式一:声明并实例化对象

    类名称 对象名称 = new 类名称 () ;
    

    (2)先声明对象,然后实例化对象

    类名称 对象名称 = null ;
    对象名称 = new 类名称 () ;
    

    引用数据类型与基本数据类型最大的不同在于:引用数据类型需要内存的分配和使用。所以,关键字new的主要功能就是分配内存空间,也就是说,只要使用引用数据类型,就要使用关键字new来分配内存空间。

    当对象产生后,可以按照下面的方式进行类的操作:
    对象.属性:表示调用类之中的属性;
    对象.方法():表示调用类之中的方法。
    范例:使用对象操作类:

    package com.yf0927;
    
    public class Student {
    	//这是学生的属性
    	int stusorce;//分数
    	String name;//学生的名字
    	
    	//这是判断学生的考试成绩是否及格的方法
    	public void exam(int sorce) {
    		if(sorce < 60) {
    			System.out.println("考试没通过!");
    		}
    		else if(sorce >= 60) {
    			stusorce += 5;
    			System.out.println("考试通过!");
    		}
    	}
    	public static void main(String[] args) {
    		//
    		Student stu1 = new Student();//声明并实例化对象
    		stu1.stusorce=25;//利用对象调用类中的属性(操作属性内容)
    		stu1.name="小明";//操作属性内容
    		
    		stu1.exam(90);//调用类中的exam()方法
    		
    		System.out.println("学分是:"+stu1.stusorce);//输出学生的学分
    		
    		
    	}
    
    }
    
    
    展开全文
  • Java类与对象

    千次阅读 2019-04-30 11:48:25
    定义:表示一个客观世界中对一具有共同特征的事物的抽象。 =属性+方法。 在中的属性实际上就是相当于一个变量,有时还称为变量或成员。 方法是一些操作的行为。 格式 class 名称(首字母大写) [访问...

    定义:表示一个客观世界中对一类具有共同特征的事物的抽象。
    类=属性+方法。
    在类中的属性实际上就是相当于一个变量,有时还称为变量或成员。
    方法是一些操作的行为。
    格式

    class 类名称(首字母大写)
    			[访问权限]	数据类型		属性;
    			......
    			[访问权限]	返回值的数据类型	方法名称(参数1,参数2,...){
    			程序语句;
    			[return	表达式;]
    }
    

    由对象调用的方法不需要在方法前添加static。
    一个类定义完成之后不能直接使用,需要产生对象,对象需要使用固定的产生格式,这时类才能使用。

    对象

    定义:类的实例且在内存中有意义。
    创建对象其实是在调用构造器(构造器参考下文)。
    格式:

    类名		对象名称	=	null;		//声明对象
    对象名称=new	类名();			//实例化对象
    或
    类名	对象名称=new	类名();
    

    Java内存分布:
    在这里插入图片描述

    最简单的内存分析
    在这里插入图片描述
    访问对象中属性或方法
    访问属性:对象名称.属性名;
    访问方法:对象名称.方法名();

    Person	per=new Person();
    		per.tell();
    

    对象使用前必须实例化

    Person	per=null;
    		per.name="张三";
    		per.tell();
    结果:会出现常见的空指针异常
    Exception in thread "main" java.lang.NullPointerException
    

    垃圾回收机制(GC)

    public class ClassDemo02 {
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		People peo1=new People();
    		People peo2=new People();
    		peo1.age=10;
    		peo2.age=20;
    		peo2=peo1;
    		System.out.print("peo1的年龄为:");
    		peo1.tell();
    		System.out.print("peo2的年龄为:");
    		peo2.tell();
    	}
    }
    class People{
    	int age;
    	public void tell() {
    		System.out.println("年龄为:"+age);
    	}
    }
    

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    一个栈内存空间只能指向一个堆内存空间,如果要再指向需要先断开原有指向。
    只有当内存中垃圾达到一定数量才会自动启动GC。
    在这里插入图片描述
    对象生命周期:
    每次使用new关键字的时候,就会在内存开辟新的空间,此时对象开始存在.
    对象的结束:当堆中的对象,没有被任何变量所引用,此时该对象就成了垃圾,就等着垃圾回收器(GC)来回收该垃圾,当被回收的时候,对象被销毁了。
    回收垃圾的目的:释放更多的内存空间。

    封装性
    什么是封装?
    1.把对象的状态和行为看成一个统一的整体 , 将字段和方法放到一个类中。
    2.信息隐藏: 把不需要让外界知道的信息隐藏起来。尽可能隐藏对象功能实现细节,向外暴露方法,保证外界安全访问功能。

    类中的全部属性都必须封装。

    封装的好处:
    面向对象三大特征之一
    1.保证数据的安全
    2.提高组件的复用性

     格式:
    属性封装:private 属性类型 属性名称;
    方法封装:private 方法返回值 方法名称(参数列表){}
    

    setter和getter
    1、只要是被封装的属性,就必须使用setter和getter去设置和取得。
    2、Java存在反射机制,在各个程序中,反射机制都会利用setter和getter去设置和取得属性内容。

    什么是属性?
    属性和字段类似,也是一个成员变量。但是必须得要有getter/setter方法,有getter/setter方法才是属性,没有就是字段。一般属性都是私有的,公有的别人可以直接获取和设置值。

    修饰符:
    Java语言提供了很多修饰符,主要分为以下两类:
    访问修饰符
    非访问修饰符
    修饰符用来定义类、方法或者变量,通常放在语句的最前端。

    访问修饰符:
    Java中,可以使用访问控制符来保护对类、变量、方法和构造方法的访问。Java 支持 4 种不同的访问权限。
    default (即缺省,什么也不写): 在同一包内可见,不使用任何修饰符。使用对象:类、接口、变量、方法。
    private : 在同一类内可见。使用对象:变量、方法。 注意:不能修饰类(外部类)
    public : 对所有类可见。使用对象:类、接口、变量、方法
    protected : 对同一包内的类和所有子类可见。使用对象:变量、方法。 注意:不能修饰类(外部类)。
    在这里插入图片描述
    protected 需要从以下两个点来分析说明:
    子类与基类在同一包中:被声明为 protected 的变量、方法和构造器能被同一个包中的任何其他类访问;
    子类与基类不在同一包中:那么在子类中,子类实例可以访问其从基类继承而来的protected 方法,而不能访问基类实例的protected方法。

    非访问修饰符
    为了实现一些其他的功能,Java 也提供了许多非访问修饰符。
    static 修饰符,用来修饰类方法和类变量。
    final 修饰符,用来修饰类、方法和变量,final 修饰的类不能够被继承,修饰的方法不能被继承类重新定义,修饰的变量为常量,是不可修改的。
    abstract 修饰符,用来创建抽象类和抽象方法。
    synchronized 和 volatile 修饰符,主要用于线程的编程。

    构造方法
    作用:在对象实例化时为类中的属性初始化。
    编译器编译源文件时,会创建一个缺省的构造器,如果设置了默认值,默认值也是在构造器当中设置的。在类中找不到默认的构造器,通过反编译工具可以看到默认的构造方法。
    只要是类就一定存在构造方法——若未明确声明构造方法在编译时会自动生成无参构造方法。若手动生成构造方法将不会在编译时生成默认构造方法。
    注意事项:
    1、构造方法必须与类名一致(判断构造方法的特征之一)
    2、构造方法的声明处不能有任何返回值类型的声明。
    3、在构造器中,不需要使用return语句。其实构造器是有返回值的,返回的是当前创建对象的引用。

    匿名对象
    定义:未明确给出名称的对象。
    一般匿名对象只使用一次,而且只在堆内存中开辟空间——匿名对象实际上就是一个堆内存空间。

    //一般情况
    Person per = new Person("张三");
    per.tell();
    //匿名对象
    new Person(“张三”).tell();
    
    展开全文
  • Java类与对象小结

    2018-06-12 22:54:35
    (1)是组成Java源文件的基本元素,一个源文件是由若干个组成的。 (2)体可以有两种重要的成员:成员变量和方法。 (3)成员变量分为实例变量和变量。变量被该的所有对象共享,不同对象的实例变量...

         (1)类是组成Java源文件的基本元素,一个源文件是由若干个类组成的。
         (2)类体可以有两种重要的成员:成员变量和方法。
         (3)成员变量分为实例变量和类变量。类变量被该类的所有对象共享,不同对象的实例变量互不相同。
       (4)除构造方法外,其他方法分为实例方法和类方法。类方法不仅可以由该类的对象调用,也可以用类名调用;而实例方法必须由对象来调用。
         (5)实例方法既可以操作实例变量也可以操作类变量,当对象调用实例方法时,方法中的成员变量就是指分配给该对象的成员变量,其中的实例变量和其他对象的不相同,即占有不同的内存空间;而类变量和其他对象的相同,即占有相同的内存空间。类方法只能操作类变量,当对象调用类方法时,方法中的成员变量一定都是类变量,也就是说,该对象和所有的对象共享类变量。
         (6)通过对象的组合可以实现方法复用。
         (7)在编写Java源文件时,可以使用import语句引入有包名的类。
         (8)对象访问自己的变量以及调用方法受访问权限的限制。

         
    展开全文
  • Java类与对象练习题

    千次阅读 多人点赞 2018-12-10 19:59:29
    请定义一个交通工具(Vehicle)的其中有: 属性: 速度(speed)、 体积(size...最后在测试 Vehicle 中的 main()中实例化一个交通工具对象并通过方法给它初始化 speed,size 的值并且通过打印出来。另外调用加速、减速...
    1. 请定义一个交通工具(Vehicle)的类其中有: 属性: 速度(speed)、 体积(size)等,方法:移动(move())、设置速度(setSpeed(int speed))、加速 speedUp()、减速 speedDown()等。最后在测试类 Vehicle 中的 main()中实例化一个交通工具对象并通过方法给它初始化 speed,size 的值并且通过打印出来。另外调用加速、减速的方法对速度进行改变。
      public class Vehicle {
      private int size;
      private int speed;
      public static void main(String[] args) {
      Vehicle ve = new Vehicle();
      ve.setSize(10);//设置初始体积
      ve.setSpeed(30);//设置初始速度
      ve.move();//调用移动方法
      ve.speedUp();//给交通工具减速
      ve.speedDown();//加速

      }
      /** 行进 /
      public void move(){
      System.out.println("行进中…,速度 "+speed+“km/h” );
      }
      /
      * 设置速度 /
      public void setSpeed(int speed){
      this.speed = speed;
      System.out.println(“初始速度设置为:”+speed+" km");
      }
      /
      * 设置体积 /
      public void setSize(int size){
      this.size = size;
      System.out.println(“初始体积设置为:”+size+" m^3");
      }
      /
      * 加速20 /
      public void speedUp(){
      this.speed+=20;
      System.out.println(“速度增加20后为:”+speed+" km");
      }
      /
      * 减速10 */
      public void speedDown(){
      this.speed-=10;
      System.out.println(“减速10后为:”+speed+" km");
      }
      }

    2. 编写 Java 程序用于显示人的姓名和年龄。定义一个人类Person。 该类中应该有两个私有属性: 姓名 (name) 和年龄 (age) 。定义构造方法用来初始化数据成员。再定义显示(display()) 方法将姓名和年龄打印出来。在 main 方法中创建人类的实例然后将信息显示。
      public class Person {
      private String name;
      private int age;
      /** 在构造器中初始化成员变量 /
      public Person(String name,int age){
      this.name = name;
      this.age = age;
      }
      public static void main(String[] args) {
      Person p = new Person(“张三”,18);
      p.display();
      }
      /
      * 显示姓名和年龄 */
      public void display(){
      System.out.println(“姓名:”+name);
      System.out.println(“年龄:”+age);
      }
      }

    3. 定义一个圆类——Circle,在类的内部提供一个属性:半径®,同时 提供 两个 方 法 : 计算 面积 ( getArea() ) 和 计算 周长(getPerimeter()) 。 通过两个方法计算圆的周长和面积并且对计算结果进行输出。最后定义一个测试类对 Circle 类进行使用。
      public class Circle {
      private int r;
      /** 无参构造 /
      public Circle(){}
      /
      * 有参构造,初始化半径*/
      public Circle(int r){
      this.r=r;
      }
      /** 也可以使用setR方法初始化半径 */
      public void setR(int r){
      this.r = r;
      }
      /计算 面积 /
      public void getArea(){
      double area = Math.PI * r * r;//从Math工具类得到π的值
      System.out.println(“圆的面积为:”+area);
      }
      /
      计算 周长 /
      public void getPerimeter(){
      double zc = Math.PI * 2 * r;
      System.out.println(“圆的周长为:”+zc);
      }
      }
      /
      测试 */
      public class Test {
      public static void main(String[] args) {
      Circle c = new Circle(4);//初始半径为4,使用构造初始化
      c.getArea();
      c.getPerimeter();
      }
      }

    4. 构造方法与重载:定义一个网络用户类,要处理的信息有用户 ID、用户密码、 email 地址。在建立类的实例时把以上三个信息都作为构造函数的参数输入, 其中用户 ID 和用户密码时必须缺省时 email地址是用户 ID 加上字符串"@gameschool.com"。
      public class People {
      private String id;
      private String password;
      private String email;
      /** 无参构造 */
      public People(){

      }
      /** 全参构造 */
      public People(String id,String password,String email){
      this.id = id;
      this.password=password;
      this.email = email;
      }
      public People(String id,String password){
      this.id = id;
      this.password=password;
      this.email=id+"@gameschool.com";
      }
      public void show() {
      System.out.println(“编号:”+this.id);
      System.out.println(“密码:”+this.password);
      System.out.println(“邮件:”+this.email);
      }
      public static void main(String[] args) {
      //调用全参构造
      People p1 = new People(“sxt0001”,“123456”,"zhangsan@163.com");
      p1.show();
      //调用无参构造
      People p2 = new People(“sxt0002”,“654321”);
      p2.show();
      }
      }

    5. 定义一个类 Calculaion, 其中包含四个方法: 加(add()) 、 减(sub()) 、乘(times()) 和除(div()) 。 创建一个具有 main()函数的类。 在 main()函数中创建一个 Calculation 的实例对象并对其中的方法进行调用。

    public class Calculaion {
    private double a;
    private double b;
    public Calculaion(double a,double b){
    this.a=a;
    this.b=b;
    }
    public void add(){
    System.out.println(“a加b :”+(a+b));
    }
    public void sub(){
    System.out.println(“a减b :”+(a-b));
    }
    public void times(){
    System.out.println(“a乘b :”+(a*b));
    }
    public void div(){
    System.out.println(“a除以b :”+(a/b));
    }
    public static void main(String[] args) {
    Calculaion c = new Calculaion(7.0,3.0);
    c.add();
    c.sub();
    c.times();
    c.div();
    }
    }

    1. 定义一个类 Draw , 在 类 中 提供 3 个 方法:输出直角三角形(drawTrian()) 、 输出矩形(drawRec()) 及平行四边形(drawPra()) 。通过方法可以输出由“*” 组成的一个图形。 同时在类中包含两个属性:星号的个数(count) 、行数(lines) 。最后在测试类中进行调用。
      public class Draw {
      private int count, lines;
      public Draw(){}
      public Draw(int count, int lines){
      this.count=count;
      this.lines=lines;
      }
      /** 直角三角形 /
      public void drawTrina() {
      for (int i = 0; i < lines; i++) {//共lines行
      for (int j = 0; j < i; j++) {//每次增加1
      System.out.print("
      ");
      }
      System.out.println();//换行
      }
      }
      /** 输出矩形 /
      public void drawRec(){
      for (int i = 0; i < lines; i++) {
      for (int j = 0; j < count; j++) {//每行数量固定
      System.out.print("
      ");
      }
      System.out.println();
      }
      }
      /** 平行四边形 /
      public void drawPra(){
      for (int i = 0; i < lines; i++) {
      for(int k=0;k<i;k++){
      System.out.print(" “);
      }
      for (int j = 0; j < count; j++) {
      System.out.print(”
      ");
      }
      System.out.println();
      }
      }
      public static void main(String[] args) {
      Draw d = new Draw(5,5);
      //d.drawTrina();
      //d.drawRec();
      d.drawPra();
      }
      }

    2. 创建一个空调,并调用制冷、制热、通风功能。空调包含的属性有品牌、匹数、温度,功能有加热、制冷、通风等功能。
      public class AirConditioning {
      // 空调属性
      String name;
      String pinpai;
      String hp;// 匹数
      int tempeture;
      // 定义制冷行为
      void cool() {
      tempeture–;
      }
      // 定义加热行为
      void hot() {
      tempeture += 7;
      }
      //通风功能
      void ventilate(){
      System.out.println(“空气通畅,温度不变”);
      }
      // 主函数
      public static void main(String[] args) {
      AirConditioning kt = new AirConditioning();
      kt.hp = “2匹”;
      kt.tempeture = 20;
      kt.pinpai = “格力”;
      kt.cool();
      System.out.println(“空调的温度是” + kt.tempeture);
      kt.hot();
      System.out.println(“空调的温度是” + kt.tempeture);
      kt.ventilate();
      }
      }

    3. 定义一个表示学生信息的类 Student,要求如下:
      (1)类 Student 的属性如下:
      sNO 表示学号; sName 表示姓名; sSex 表示性别; sAge 表示
      年龄;sJava:表示 Java 课程成绩。
      (2)类 Student 带参数的构造方法:
      在构造方法中通过形参完成对成员变量的赋值操作。
      (3)类 Student 的方法成员:
      getNo():获得学号;
      getName():获得姓名;
      getSex():获得性别;
      getAge()获得年龄;getJava():获得 Java 课程成绩
      public class Student {
      String sNO ;
      String sName;
      String sSex;
      int sAge;
      int sJava;
      public Student(String sNO, String sName, String sSex, int sAge, int sJava) {
      this.sNO = sNO;
      this.sName = sName;
      this.sSex = sSex;
      this.sAge = sAge;
      this.sJava = sJava;
      }
      public String getsNO() {
      return sNO;
      }
      public String getsName() {
      return sName;
      }
      public String getsSex() {
      return sSex;
      }
      public int getsAge() {
      return sAge;
      }
      public int getsJava() {
      return sJava;
      }
      }
      (4) 根据类 Student 的定义,创建五个该类的对象,输出每个学生的信息,计算并输出这五个学生 Java 语言成绩的平均值,以及计算并输出他们 Java 语言成绩的最大值和最小值。
      public class Test {
      public static void main(String[] args) {
      Student s1 = new Student(“sxt0001”, “张三”, “男”,18,90);
      Student s2 = new Student(“sxt0002”, “李四”, “女”,15,92);
      Student s3 = new Student(“sxt0003”, “王五”, “男”,17,93);
      Student s4 = new Student(“sxt0004”, “赵六”, “男”,21,95);
      Student s5 = new Student(“sxt0005”, “钱七”, “男”,19,97);

      System.out.println("\t学号\t姓名\t姓别\t年龄\t成绩");
      System.out.println("\t"+s1.getsNO()+"\t"+s1.getsName()
      		+"\t"+s1.getsSex()+"\t"+s1.getsAge()+"\t"+s1.getsJava());
      System.out.println("\t"+s2.getsNO()+"\t"+s2.getsName()
      		+"\t"+s2.getsSex()+"\t"+s2.getsAge()+"\t"+s2.getsJava());
      System.out.println("\t"+s3.getsNO()+"\t"+s3.getsName()
      		+"\t"+s3.getsSex()+"\t"+s3.getsAge()+"\t"+s3.getsJava());
      System.out.println("\t"+s4.getsNO()+"\t"+s4.getsName()
      		+"\t"+s4.getsSex()+"\t"+s4.getsAge()+"\t"+s4.getsJava());
      System.out.println("\t"+s5.getsNO()+"\t"+s5.getsName()
      		+"\t"+s5.getsSex()+"\t"+s5.getsAge()+"\t"+s5.getsJava());
      int d = (s1.getsJava()+ s2.getsJava()+ s3.getsJava()
      		+ s4.getsJava()+ s5.getsJava())/5;
      System.out.println("java语言平均成绩:"+d);
      

      }
      }

    展开全文
  • java 类与对象-封装

    千次阅读 2017-10-18 18:20:19
    类与对象 类:是一类事物特征抽象的集合,表示的是一个共性的产物。类中包括属性(静态属性)和方法(动态属性)注:类中属性和方法也可以没有。对象:是抽象的具体化,换句话说对象就是按照类的模板创建的一个具体...
  • jni 操作 java 类与对象

    千次阅读 2018-06-12 10:53:57
    jni 操作 java DefineClass jclass DefineClass(const char *name, jobject loader, const jbyte* buf,jsize bufLen) { return functions-&gt;DefineClass(this, name, loader, buf, bufLen); } 从原始...
  • java类与对象练习

    千次阅读 2016-07-21 22:19:23
    需求: 使用java描述一个车修车厂两个事物, 车具备的公共属性:轮子数、 名字、 颜色 ,还 具备跑的功能行为。跑之前要检测轮子是否少于了4个,如果少于了4个,那么要送到修车厂修理, 修车厂修理之后,车的轮子...
  • 作为Java开发者,我们每天创建很多对象,但我们通常使用依赖管理系统,比如Spring去创建对象。然而这里有很多创建对象的方法,我们会在这篇文章中学到。 Java中有5种创建对象的方式,下面给出它们的例子还有它们的...
  • Java类与对象(一)

    千次阅读 2016-09-08 19:46:21
    本文为博主原创文章,更多内容点此访问类与对象的概念 类是具有一组相同属性和方法的对象的集合,它是一个模板 对象是类的具体实例化的一个个客观存在的实体 类是对象的抽象,对象是类的实体 类的基本结构权限修饰符...
  • java类与对象的内存分析

    千次阅读 2017-03-08 09:21:27
    先上一句java的经典思想总结, (class)是组织代码。 对象是封装数据 。 总结下: 组织代码, 封装数据。 一个里 有静态的属性(其实是变量),有动态的方法(其实就是函数) ,就像一个模板,批量生产对象...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 74,598
精华内容 29,839
关键字:

java类与对象

java 订阅