精华内容
下载资源
问答
  • 一、封装将数据和行为组合一起。实体类中的成员变量就是数据,行为就是对应的getter、setter方法,同时这也是这种一种规范,叫做“访问器”。遵循这个规范的好处,你可以看这个回答(Java中的实体类中的属性有必要...

    面向对象语言的三大特征:“封装”、“继承”、“多态”。Java就是一门面向对象语言,所以Java实体类也应该满足这个三个特征,里面一些你觉得很奇怪的地方都可以通过这三个特征解释。

    一、封装

    将数据和行为组合在一起。实体类中的成员变量就是数据,行为就是对应的getter、setter方法,同时这也是这种一种规范,叫做“访问器”。遵循这个规范的好处,你可以看这个回答(Java中的实体类中的属性有必要设置成private的码?set,get方法有必要么? - 赵北云的回答 - 知乎)。

    补充:getter/setter方法可以进行鉴权、日志,而使用private是无法做到的。

    二、继承

    Java所有类都继承自Object类,你的实体类也一样,所以你的实体类会有一些默认的方法,这些方法你都可以直接使用。

    这几个方法可以解释“为什么你的实体类在HashSet中无法去重?(hashcode、equals)”,“为什么你直接输出实体类打印一堆很乱的字符串?(tostring)”,“JVM(finalize)”,“多线程(wait、notify等)”,“怎么用类描述一个类?(getClass)”,“深浅拷贝(clone)”

    三、多态

    直接使用继承Object的方法,能满足你的需要吗?如果你思考过上面的问题,你就会发现,有些方法并不好用,比如“将实体类放在HashSet中,明明两个对象的字段值都一样,这个hashset居然不给我去重?”,于是你就会去重写(重写与重载区别?)hashcode和equals方法。于是在继承层次中出现两个同名方法,表现出了不同的形态,这就是多态。

    所以,直接使用属性和调用getter和setter的区别就是“是否遵循一些特征和规范”。

    展开全文
  • 今天复习了下Java面向对象的封装,下面分享下我的复习心得! 1.使用private关键字修饰某个成员变量后,这个成员变量可以被同一包的其它访问吗? 2.Java程序,代码封装带给我们的好处是什么? 下面我通过...

    今天复习了下Java面向对象的封装,下面分享下我的复习心得!

    1.使用private关键字修饰某个成员变量后,这个成员变量可以被同一包中的其它类访问吗?
    2.在Java程序中,代码封装带给我们的好处是什么?

    下面我通过两个简单的例子来回答这两个问题

    第一题:编写一个类,代表老师,要求:
    具有属性:姓名、年龄
    具有行为:自我介绍
    老师的最小年龄要求:22岁

    package study;
    
    public class Teacher {
    	/*
    	 * 封装就是将属性私有化,增加了数据访问限制,增强了程序的可维护性
    	 */
    	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) {
    		/*
    		 * 限制年龄
    		 */
    		if(age<22){
    			System.out.println("错误!最小年龄应该为22!");
    			this.age=22;
    		}else{
    			this.age = age;
    		}
    	}
    	public String jieshao(){
    		return "大家好!我叫"+name+";我今年"+age+"岁!";
    	}
    	public static void main(String[] args) {
    		Teacher t=new Teacher();
    //		t.name="孔子";
    //		t.age=56;
    		t.setName("老子");
    		t.setAge(15);
    		System.out.println(t.jieshao());
    	}
    }
    通过上面这个例子,可以看出代码封装可以限制数据访问,提高了代码的可维护性!回答了第二问。

    第二题:编写一个类,代表学生,要求:
    具有属性:姓名、年龄
    具有行为:自我介绍
    学生的最大年龄要求:21岁

    package study;
    
    public class Student {
    	public String name;
    	public 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) {
    		if(age>22){
    			System.out.println("错误!学生年龄小于22!");
    			this.age=18;
    		}else{
    			this.age = age;
    		}
    	}
    	public String jieshao(){
    		return "大家好,我叫"+name+",今年"+age+"岁!";
    	}
    	public static void main(String[] args) {
    		Student s=new Student();
    		s.setName("jack");
    		s.setAge(25);
    		System.out.println(s.jieshao());
    		Teacher t=new Teacher();
    		t.setName("tom");
    		t.setAge(18);
    		System.out.println(t.jieshao());
    	}
    }
    

    从代码中可以看出Teacher类和Student类都在study包中,Teacher类用private修饰属性,Student用public修饰属性。同时可以看出第二题调用了Teacher类,即可以被同一包中的其他类访问。下面输出结果:

    错误!学生年龄小于22!
    大家好,我叫jack,今年18岁!
    错误!最小年龄应该为22!
    大家好!我叫tom;我今年22岁!

    从结果也可以看出使用了封装可以限制老师和学生的年龄。亲们,我讲的对么

    展开全文
  • 网址 第四章 面向对象的概念和 Java 实现-2 回顾 对象由状态和行为组成 是具有相同属性和行为的一组对象的集合 封装是隐藏对象实现细节的过程以便不让用户看到 的变量和方法可被该的实例访问 圆点符号用于访问...
  • 你听过这个笑话吗?你有对象吗?...这是一种抽象思想,我们将一件事物提取出特征和行为,将特征定义为属性,将行为封装成方法。如,一个人,特征有姓名、年龄、性别、职业等等,行为有吃饭、睡觉、学...

    你听过这个笑话吗?你有对象吗?没有的话就new一个吧!

    但是此对象非彼对象哦~

    1.什么是对象?

    Java是一门面向对象的语言(OOP),在Java中,有一句话叫:万事万物皆为对象。

    我们生活中的每一件东西都可以看作是一个对象,包括我们本身都是一个对象。

    这是一种抽象的思想,我们将一件事物提取出特征和行为,将特征定义为属性,将行为封装成方法。

    如,一个人,特征有姓名、年龄、性别、职业等等,行为有吃饭、睡觉、学习等等。

    2.什么是面向对象?

    面向过程:了解面向对象前,先了解面向过程。我们之前所编写的程序都是面向过程的,分析解决问题的步骤,然后按照步骤第一步做什么,第二步做什么......如果将步骤写成了方法,就依次调用方法。适合处理简单的问题。

    面向对象:而面向对象是一种抽象的分类的思想,分析解决问题需要从哪几个方面出发,即有哪几个分类,然后对这些分类进行单独的面向过程的思考,每一个分类需要具体的完成什么。用于处理复杂的问题。

    例:

    面向过程:一个人要喝水,那么他首先就看看杯子里有没有水,有的话就喝水,没有的话,就倒水再喝水。

    面向对象:现在要建一栋房子,这就更复杂了,首先需要分为三大类,需要设计人员设计图纸,需要建筑人员建房子,需要装修人员装修;而设计人员怎么设计图纸,建筑人员怎么建造,装修人员怎么装修又是每一个分类的具体细节。

    而我们到最后要用Java来完成的东西,肯定是复杂的,所以面向对象思想极其重要。我们主要从以下思考出发:

    对象有哪些?对象的特征(属性)和行为(方法)是什么?对象与对象的关系是什么?

    3.类与对象的关系

    我们知道,不管使用什么思想,Java的代码一定是编写在类中的,所以我们的对象也肯定是在类中的,而上述我们又提到,我们要在类中定义对象的特征(属性)和行为(方法),所以我们可以总结面向对象编程的本质:

    面向对象编程的本质:以类的形式组织代码,以对象的形式组织(封装)数据。

    那类是对象是什么关系呢?

    从认识论的角度来看:我们先确定了对象,再为该对象书写一个类。(我们确定了学生为一个对象,就需要定义一个对应的学生类,在类 中书写学生的特征(属性)和行为(方法));

    从代码运行角度来看:我们是先有了类,再使用类创造了对象。(我们代码的运行首先会加载该学生类,再运行该类中的代码,如对象操 作等内容)。

    所以,类与对象的关系总结如下:

    类是对象的模板。(在类中定义了对象的属性和行为,即提供了对象的基本框架。)

    对象是类的实例。(我们通过类来创建对象。)

    类是具有共同属性和行为的对象的抽象。(一个学生类,张三是学生,李四也是学生,他们拥有姓名、性别、学号等,也有共同的行为,学习。)

    4.类的定义

    之前,我们没有具体的探究过类的定义,直接使用的是IDEA中自动生成的模板,我们现在再来看一下这个模板:

    package com.dh.oop;

    public class OopDemo01 {

    }

    权限修饰符

    自动生成的类中的权限符为最大的public,我们换成其它的修饰符会怎么样呢?

    868987f8533d11e4697744ab0efef9a7.png

    99d754881950082caf59f977a4986d7b.png

    db5087c77dd4286e4db4f140ea218d7a.png

    可以看到,只能用public或者是default这两个权限修饰符来修饰类,protected和private是不能用来修饰类的!

    其实也不难理解,因为类是Java的最小单位,我们解决问题就是通过一个一个类联合起来的,如果权限符为protected和private了,就有了很大的访问局限,这个类差不多就是个单独的类,和别的类没什么关系,那这个类的意义也就不大了。就像煮饭,菜刀拿来切菜,但是你把菜刀锁进了柜子里,只有拥有那把钥匙的厨师才能使用它,那这菜刀存在的意义就不大了。

    那可以定义多个类吗?

    5c7d220a3fcdc56578acd2f7dc8bd51b.png

    0cb25562d89a594978c63f67bc64bb86.png

    我们可以看到,在一个.java文件中,可以定义多个类,但是只能有一个被public修饰。

    但是一般不建议在一个java文件中书写多个类,一个java文件一般只书写一个类,不就是多建一个java文件的事嘛,也不麻烦对不对

    class

    Java使用class关键字来定义一个类。

    类名

    类名的定义要符合标识符的命名规则,最好见名知意,一般为驼峰命名法,每个单词的首字母都大写。

    需要注意的是:在同一个包下的类不允许重名,在不同包下的类允许同名。

    注意:

    在类体中不能直接出现可执行语句,会直接红色波浪线报错

    if、switch、while、do...while、for;

    打印语句;

    赋值语句;

    ......

    5.对象的声明和使用

    首先,我们要在类中定义对象的属性和方法:

    package com.dh.oop;

    //学生类

    public class Student {

    //属性和方法是同一级别的

    //属性

    public String name;

    public int age;

    public char sex;

    public int num;

    //方法

    public void study(){

    System.out.println("学生学习");

    }

    //程序入口:main方法

    public static void main(String[] args) {

    }

    }

    成员变量、局部变量、类变量

    之前我们都是将变量直接定义在方法内部的,现在却定义在了方法的外部。这里就涉及到了成员变量和局部变量的概念了。

    成员变量:定义在类的内部,方法的外部。具有默认值(整数为0,浮点数为0.0,布尔值为false,char为'',引用为null);

    别名:实例变量。

    作用域:类中。(本类中可直接使用,其他类也可能可以使用对象调用,具体看是否有权限)

    使用方法:对象.变量调用,this.变量名调用,直接调用。

    局部变量:定义在方法的内部。没有默认值,必须赋初始值才能使用,否则使用会报错;

    作用域:定义的那个方法中。

    使用方法:在方法中直接使用。

    类变量:被static修饰的变量,也是成员变量的一种。**该变量属于类,凌驾于对象之上,只有一份,给所有的实例对象共享。

    别名:静态变量。

    作用域:类中。(本类中可直接使用,其他类也可能可以使用对象调用或者类名调用,具体看是否有权限)

    注意:只能修饰成员变量,不能修饰局部变量。

    使用方法:在static方法中直接使用,可以通过对象.变量名调用,也可以直接使用类名.变量名调用。

    (可能有些现在不理解的,会慢慢在后续讲到~)

    成员变量和局部变量可重名,重名时遵循就近原则:

    package com.dh.oop;

    public class Student {

    public String name = "张三";

    public static void study(String name){

    System.out.println(name +"在学习");

    }

    public static void main(String[] args) {

    study("李四");

    }

    }

    局部变量和成员变量都为name,但是输出结果为李四在学习,可以证明,使用的是局部变量:

    728ae672891615665f3b4aadecb943da.png

    对象的声明

    语法:类名 对象名 ;

    Student student;

    对象的声明可以在类体中,也可以在方法中。

    对象的实例化

    语法:对象名 = new 类名();

    student = new Stdent();

    扩展:在类体中实例化自身而导致的栈溢出问题

    针对上述在类体中声明对象,如果该对象是在static方法中实例化的话,注意对象也需要定义成static。如果直接在类体中实例化对象,当其他方法中有实例化对象的操作时,会发生栈溢出错误:

    package com.dh.oop;

    public class StudentDemo {

    public String name;

    public int age;

    StudentDemo s = new StudentDemo();//栈溢出

    public static void main(String[] args) {

    StudentDemo studentDemo = new StudentDemo();

    }

    }

    d43490ed70a4cb3c77b11861dd629a06.png

    错误原因分析:在main方法中new一个对象的话,会初始化该类的成员变量,变量里又有new操作,又要去初始化成员变量,又有new,然后就一直得在栈里开辟空间,就会导致栈溢出错误。

    解决方案:将需要在类中实例化的对象定义成static。

    原理:如果是static的话,只在首次new的时候开辟内存,new新对象的时候,再就不会开辟新的内存,直接指向第一个,就不会栈内存不够而溢出了。

    边声明边实例化

    语法:类名 对象名 = new 类名();

    //声明一个student对象

    Student student = new Student();

    //可声明多个,不可重名

    Student student1 = new Student();

    //student和student是不同的两个对象

    推荐使用这种方法!

    对象的赋值和使用

    语法:

    属性的赋值:对象名.变量名 = 值;

    属性的使用:对象名.变量名;

    方法的使用:对象名.方法(【参数】);

    //属性的使用

    student.name = "zhangsan";

    student.age = 18;

    student.sex = '男';

    student.num = 001;

    System.out.println(student.name+"\t"+student.age+"\t"+student.sex+"\t"+student.num);

    //方法的使用

    student.study("李四");

    不同的对象可以自定义其自己的属性值

    //不同的对象可以有不同的属性

    student1.name = "lisi";

    student1.age = 19;

    student1.sex = '男';

    student1.num = 002;

    System.out.println(student1.name+"\t"+student1.age+"\t"+student1.sex+"\t"+student1.num);

    //不同的对象调用方法

    student1.study("lisi");

    总代码:

    package com.dh.oop;

    public class Student {

    //可以赋初值,如果不赋值的话也会有默认值

    public String name = "张三";

    public int age;

    public char sex;

    public int num;

    //成员方法

    public void study(String name){

    System.out.println(name+"在学习");

    }

    public static void main(String[] args) {

    //声明一个student对象

    Student student = new Student();

    //可声明多个,但不可重名

    Student student1 = new Student();

    //属性的使用

    student.name = "zhangsan";

    student.age = 18;

    student.sex = '男';

    student.num = 1001;

    System.out.println(student.name+"\t"+student.age+"\t"+student.sex+"\t"+student.num);

    //方法的使用

    //对象可以在static方法中直接调用非static方法(如果直接调用就只能调用static方法,对象的强大性来了!)

    student.study("zhangsan");

    //不同的对象可以有不同的属性

    student1.name = "lisi";

    student1.age = 19;

    student1.sex = '男';

    student1.num = 1002;

    System.out.println(student1.name+"\t"+student1.age+"\t"+student1.sex+"\t"+student1.num);

    //不同的对象调用方法

    student1.study("lisi");

    }

    }

    代码运行结果:

    5099c642cad7e4e7c2825164fe774e76.png

    本人水平有限,若有错误望指出~感激不尽!

    展开全文
  • 基础数据类型不是计算机运算更快吗?为啥还要有包装?...因为在对象描述就可以定义更多的属性和行为对该基本数据类型进行操作。基本数据类型的包装是为了解决基本数据类型有些操作不方便带来的问题。

    一、为啥要有包装类?

       基础数据类型不是在计算机中运算更快吗?为啥还要有包装类?
       因为想要对基本类型数据进行更多的操作,最方便的方式就是将其封装成对象。为啥呢?因为在对象描述中就可以定义更多的属性和行为对该基本数据类型进行操作。基本数据类型的包装类是为了解决基本数据类型有些操作不方便带来的问题。

    二、基本类型和包装类的对应表

    包装类对应表

    基本数据类型 包装类
    byte Byte
    boolean Boolean
    short Short
    char Character
    int Integer
    long Long
    float Float
    double Double

    三、自动装箱拆箱

       JDK1.5之前还需要自己做转换,但是JDK1.5之后,Java为了方便开发提供了自动装箱与自动拆箱的机制,并且可以直接利用包装类的对象进行数学计算。

    public class TestCode {
        public static void main(String[] args) {
            Integer a = 10;  // 自动装箱
            int b = a;  // 自动拆箱
            System.out.println(a * b); // 结果100
        }
    }
    

    四、拓展知识(易错点)

    1、不同的包装类对象之间值的比较,不能比较!(这是首要条件,切记!能比较的是基础数据类型!)

    public class TestCode {
        public static void main(String[] args) {
            Integer a = 10;
            Long b = 10L;
            System.out.println(a == b);  // 编译直接报错
            System.out.println(a.equals(b)); // false
        }
    }
    

    2、所有整型包装类对象之间值的比较,全部使用 equals 方法比较。(阿里巴巴开发手册)

    原因1:

    public class TestCode {
        public static void main(String[] args) {
            Integer a = 10;  // 直接赋值
            Integer b = new Integer(10);  // 构造方法
            System.out.println(a == b); // false, 直接new出来的是对象,所以不相等
            System.out.println(a.equals(b)); // true
        }
    }
    

    原因2:

    public class TestCode {
        public static void main(String[] args) {
            Integer a = 10;
            Integer b = 10;
            Integer c = 128;
            Integer d = 128;
            System.out.println(a == b); // true
            System.out.println(c == d); // false,Integer直接等于数字如果在-128到127之间会保存到常量池,当这个值大于等于-128并且小于等于127时使用了常量池,所以前两个地址是相等的,但是后两个超过了127,故不使用常量池。
            System.out.println(c.equals(d)); // true
        }
    }
    

    源码如下:

    public static Integer valueOf(int i) {
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
    }
    

    3、浮点数之间的等值判断,基本数据类型不能用==来比较,包装数据类型不能用 equals来判断。(阿里巴巴开发手册)
      因为,浮点数采用“尾数+阶码”的编码方式,类似于科学计数法的“有效数字+指数”的表示方式。二进制无法精确表示大部分的十进制小数,

    4、关于基本数据类型与包装数据类型的使用标准如下。(阿里巴巴开发手册)
    1) 【强制】所有的 POJO 类属性必须使用包装数据类型。
    2) 【强制】RPC 方法的返回值和参数必须使用包装数据类型。
    3) 【推荐】所有的局部变量使用基本数据类型。

      POJO 类属性没有初值是提醒使用者在需要使用时,必须自己显式地进行赋值,任何 NPE 问题,或者入库检查,都由使用者来保证。如:数据库的查询结果可能是 null,因为自动拆箱,用基本数据类型接收有 NPE 风险。

    5、字符串与基本数据类型的互相转换。

    • 字符串变为基本数据类型,依靠包装类的parseXxx()方法。
    • 基本数据类型变为字符串,依靠String.valueOf(数据类型 变量)方法。
    展开全文
  • 封装就是隐藏对象的属性和实现细节,仅对外公开接口,控制程序属性的读和修改的访问级别,将抽象得到的数据和行为(或功能)相结合,形成一个有机的整体,也就是将数据与操作数据的源代码进行有机的结合,形成...
  • JAVA面向对象的三大特性每一对象是其状态和行为封装是按一定体系和层次安排的,使得子类可以从超类继承行为。这个层次体系有一个根,它是具有一般行为的。Java程序是用来组织的。下面是小编整理的...
  • JavaString类型常量可以修改吗?

    千次阅读 2019-01-26 13:22:22
    我们知道,java是面向对象语言,但不是完全的面向对象的,...*为了方便操作基本数据类型值,将其封装成了对象,对象定义了属性和行为丰富了该数据的操作 *用于描述该对象的类就称为基本数据类型包装。 *byte ...
  • Java面向对象编程

    2018-04-27 13:24:18
    顾名思义,就是面向对象的编程,将事务的属性和行为封装起来,使其作为程序的基本单位。面向对象编程的好处?提出了对象的概念,使编程思想更贴近人类,与面向过程编程相比,面向过程更注重的是怎样去实现某个方法,...
  • 封装就是隐藏对象的属性和实现细节,仅对外公开接口,控制程序属性的读和修改的访问级别,将抽象得到的数据和行为(或功能)相结合,形成一个有机的整体,也就是将数据与操作数据的源代码进行有机的结合,形成...
  • 面向对象特征

    2020-11-09 16:16:58
    封装就是隐藏对象的属性和实现细节,仅对外公开接口,控制程序属性的读和修改的访问级别,将抽象得到的数据和行为(或功能)相结合,形成一个有机的整体,也就是将数据与操作数据的源代码进行有机的结合,形成...
  • 面向对象

    2021-03-19 14:19:30
    继承:从一个已知的类中派生出一个新类,新类可以拥有已知类的行为和属性,并且可以通过重写来增强已知类能力。 多态:多态是指不同对象对同一事物多种表现形式,主要通过三种方式来实现: a.通过子类对...
  • 本书论述运用UML(统一建模语言)模式进行对象建模的方法技巧,重点讨论了如何使用面向对象的分析设计技术来建造一个健壮的易于维护的系统。 全书叙述清晰、图文并茂、实例丰富,是一部来自于大量经验的...
  • JAVA面向对象详细资料

    2019-03-19 00:14:10
    20.10 父类私有属性和私有方法可以继承吗? 24 20.11 代码开发时先开发父类还是先开发子类? 24 20.12 父类是怎么来? 25 20.13 父类所有子类共性。子类可以有自己特性。 26 20.14 方法重写(核心@...
  • 封装,即隐藏对象的属性和实现细节,仅对外公开接口,控制程序属 性的读和修改的访问级别;将抽象得到的数据和行为(或功能)相结合,形成一个有机的整体,也就是将数据与操作数据的源代码进行有机的结合,...
  • 数据库性能资源管理方面最佳经验封装在一起。您可以很方便地在自己 .NET 应用程序中将其作为构造块使用,从页减少了需要创建、测试维护自定义代码数量。 尤其是,Data Access Application Block 可以...
  • 普通窗口,直接创建一个CXPButton类对象,然后OnCreate()调用CXPButtonCreate方法; 以下章节将综合地使用以上方法,请读者朋友留心观察。 3.2 使用MFC类的既有函数 界面美化专题,MFC也...
  • 知道其行为的其它类可以在类中实现这些方法。  接口(interface)是抽象类变体。在接口中,所有方法都是抽象。多继承性可通过实现这样接口而获得。接口中所有方法都是抽象,没有一个有程序体。接口只可以...
  • java联想(中文)

    2008-12-29 21:07:11
    10.2 增添属性和有用接口 10.2.1 通过FilterInputStream从InputStream里读入数据 10.2.2 通过FilterOutputStream向OutputStream里写入数据 10.3 本身缺陷:RandomAccessFile 10.4 File 10.4.1 目录列表器 ...
  • 10.2 增添属性和有用接口 10.2.1 通过FilterInputStream从InputStream里读入数据 10.2.2 通过FilterOutputStream向OutputStream里写入数据 10.3 本身缺陷: 10.4 File 10.4.1 目录列表器 10.4.2 检查与创建...
  • 10.2 增添属性和有用接口 10.2.1 通过FilterInputStream从InputStream里读入数据 10.2.2 通过FilterOutputStream向OutputStream里写入数据 10.3 本身缺陷:RandomAccessFile 10.4 File 10.4.1 目录列表器 ...
  • 对象的一个新类可以从现有的类中派生,这个过程称为类继承。新类继承了原始类的特性,新类称为原始类的派生类(子类),而原始类称为新类的基类(父类)。派生类可以从它的基类那里继承方法实例变量,并且类可以...
  • 软件工程教程

    热门讨论 2012-07-06 23:10:29
    顺序图、协作图:单用例几个对象的行为 顺序图突出顺序,协作图着重对象间链接关系 项目三 项目市场调研 任务1. 系统的研发背景 任务2. 软件开发计划 油画创作背景 波洛克 《1948年第五号》 1.4亿$,最昂贵画作...
  • java 面试题 总结

    2009-09-16 08:45:34
    知道其行为的其它类可以在类中实现这些方法。 接口(interface)是抽象类变体。在接口中,所有方法都是抽象。多继承性可通过实现这样接口而获得。接口中所有方法都是抽象,没有一个有程序体。接口只可以...
  • JAVA面试题最全集

    2010-03-13 13:09:10
    掌握类和对象的概念,掌握面向对象编程的本质 49.静态变量静态方法的意义,如何引用一个的静态变量或者静态方法? 50.JAVA语言如何进行异常处理,关键字:thorws,throw,try,catch,finally 51.Object(或者其...
  • 二十三种设计模式【PDF版】

    热门讨论 2011-05-30 14:13:49
    使用再生两个方式:组合(new)继承(extends),这个已经 thinking in java提到过. 设计模式之 Proxy(代理) 以 Jive 为例,剖析代理模式用户级别授权机制上应用 设计模式之 Facade(门面?) 可扩展使用...

空空如也

空空如也

1 2 3
收藏数 58
精华内容 23
关键字:

对象的属性和行为封装在类中吗