精华内容
下载资源
问答
  • 因为idea强大语法检查功能初学者十分友好,idea提供各种错误提示,以及各个需要注意地方,这让初学者可以轻松找到出错代码块。好了,下面来看题目吧! 1.根据以下这段话的描述,用面向对象思想实现 狗...

    这几天逐渐被idea所折服,越来越喜欢这个优雅又强大的代码编辑器,有很多人说idea对很多初学者不友好,但是在我看来,只要你足够自律,并且英语不会太差,语法上关键的几个单词没什么大问题,idea对初学者是有很大帮助的。因为idea强大的语法检查功能对初学者十分友好,idea提供各种错误提示,以及各个需要注意的地方,这让初学者可以轻松找到出错的代码块。好了,下面来看题目吧!

    1.根据以下这段话的描述,用面向对象的思想实现

    狗生活在陆地上(是一种陆生动物),既是哺乳类的也是肉食性的。
    狗通常的时候和人打招呼会通过“摇摇尾巴”,在被抚摸情绪很好的时候,
    会“旺旺叫”,而在受到惊吓情绪烦躁时,会发出“呜呜”声;

    猫也生活在陆地上(是一种陆生动物),既是哺乳类的也是肉食性的。
    猫通常的时候和人打招呼会发出“喵~”的声音,在被抚摸情绪很好时,
    会发出“咕噜咕噜”声,而在受到惊吓时,会发出“嘶嘶”声;

    青蛙是一种两栖动物(既是水生动物也是陆生动物),既不是哺乳类的也不是肉食性的,
    属于卵生。青蛙通常的时候和人打招呼会通过“呱呱叫”,当青蛙情绪好的时候,
    会在岸边“呱呱呱”的唱歌,而在受到惊吓时,会“扑通一声跳入水中”

    //下面只实现了狗的模块,猫和青蛙模块同理,不再赘述
    //因为水生和陆生不能抽象处出来共性,因此将其定义为接口

    package com.company;
    abstract class Animal
    {
        static final int HAPPY = 1;
        static final int UNHAPPY = 0;
        protected boolean carnivorous;  //肉食
        protected boolean mammal;  //哺乳
        public abstract void sayHello();
        public abstract void sayHello(int mood);
    
        public boolean isCarnivorous()
        {
            return carnivorous;
        }
    
        public boolean isMammal()
        {
            return mammal;
        }
    
    }
    //水生动物
    interface Water
    {
        boolean hasGillFlag();  //是否有腮
    }
    //陆生动物
    interface Land
    {
        int getLegNumber(); //有多少条腿
    }
    
    class Dog extends Animal implements Land
    {
        private int dogLegNumber = 4;
    
        //访问父类的属性
        //父类使用权限protected
        Dog()
        {
            this.carnivorous = true;
            this.mammal = true;
        }
        public void sayHello()
        {
            System.out.println("摇摇尾巴");
        }
        public void sayHello(int mood)
        {
            switch (mood)
            {
                case HAPPY:
                    System.out.println("汪汪叫");
                    break;
                case UNHAPPY:
                    System.out.println("呜呜叫");
                    break;
                default:
                    System.out.println("摇摇尾巴");
            }
        }
        public int getLegNumber()
        {
            return dogLegNumber;
        }
    }
    
    public class TaskDay09_4 {
        public static void main(String[] args)
        {
            Dog dog = new Dog();
            if(dog.mammal)
                System.out.println("狗是哺乳动物");
            else
                System.out.println("狗不是哺乳动物");
    
            if(dog.carnivorous)
                System.out.println("狗是肉食动物");
            else
                System.out.println("狗不是肉食性动物");
    
            System.out.print("狗通常的打招呼方式是:" );
            dog.sayHello();
            System.out.print("狗开心的时候的打招呼方式是:" );
            dog.sayHello(Animal.HAPPY);
            System.out.print("狗不开心的时候的打招呼方式是:" );
            dog.sayHello(Animal.UNHAPPY);
            System.out.println("狗是肉食动物,狗有" + dog.getLegNumber() + "条腿");
        }
    }
    

    总结:这道题因为水生和陆生不能抽象处出来共性,因此需要将其定义为接口

    2.已知电脑有三个USB接口,分别去实例化一个鼠标,一个键盘,一个U盘来连接到电脑上。输出每一个USB接口连接的设备信息

    package com.company;
    interface Usb
    {
        String getDeviceInfo();
    }
    
    class Mouse implements Usb
    {
        public String getDeviceInfo()
        {
            return "鼠标";
        }
    }
    
    class KeyBoard implements Usb
    {
        public String getDeviceInfo()
        {
            return "键盘";
        }
    }
    
    class Upan implements Usb
    {
        public String getDeviceInfo()
        {
            return "U盘";
        }
    }
    
    class Computer
    {
        private Usb usb1;
        private Usb usb2;
        private Usb usb3;
        public Computer(){}
        public Computer(Usb usb1, Usb usb2, Usb usb3)
        {
            this.usb1 = usb1;
            this.usb2 = usb2;
            this.usb3 = usb3;
        }
        public void showInfo()
        {
            System.out.println(usb1.getDeviceInfo());
            System.out.println(usb2.getDeviceInfo());
            System.out.println(usb3.getDeviceInfo());
        }
    }
    
    public class TaskDay09_1 {
        public static void main(String[] args)
        {
            Usb usb1 = new Mouse();
            Usb usb2 = new KeyBoard();
            Usb usb3 = new Upan();
    
            Computer com = new Computer(usb1, usb2, usb3);
            com.showInfo();
        }
    }
    
    
    

    总结:在做这道题的时候面向对象的思想不明确,导致题意不懂。
    只需要将USB定义为接口,接口的作用是用来展示键盘、鼠标、U盘各个设备的信息。键盘、鼠标、U盘只需要分别定义为一个类实现接口即可。将电脑定义为一个类,其中包含了三个USB对象,并通过方法试实现展示功能。
    注意:接口是抽象的,不能用来实例化对象,只能通过实现接口的各个类和实例化对象。因此在main函数中利用多态来实现函数功能。

    3.设计一个交通工具抽象类,提供抽象方法–驾驶

    汽车作为交通工具的一种,实现了驾驶的方法(在马路上驾驶)
    火车作为交通工具的一种,实现了驾驶的方法(在铁路上驾驶)
    飞机作为交通工具的一种,实现了驾驶的方法(在天上驾驶)
    需求:做一个测试类,在测试类的main函数中,分别实例化一个汽车的对象,火车的对象和飞机的对象,并分别描述驾驶行为

    package com.company;
    
    abstract class Transportation
    {
        abstract void Drive();
    }
    
    class Car extends Transportation
    {
        public void Drive()
        {
            System.out.println("马路上行驶");
        }
    }
    
    class Train extends Transportation
    {
        public void Drive()
        {
            System.out.println("铁路上行驶");
        }
    }
    
    class Plane extends Transportation
    {
        public void Drive()
        {
            System.out.println("天上行驶");
        }
    }
    
    public class TaskDay09_2
    {
        public static void main(String[] args)
        {
            Car car = new Car();
            Train train = new Train();
            Plane plane = new Plane();
    
            func(car);
            func(train);
            func(plane);
        }
    
        //多态:父类的引用指向了子类
        public static void func(Transportation tool)
        {
            tool.Drive();
        }
    }
    

    总结:同样的,这题也是通过多态实现,但是这题是抽象类,但是第2题是接口。
    多态的过程细节:多态与继承、方法重写密切相关,我们在方法中接收父类类型作为参数,在方法实现中调用父类类型的各种方法。当把子类作为参数传递给这个方法时,java虚拟机会根据实际创建的对象类型,调用子类中相应的方法(存在方法重写时)。
    因此可以继续总结多态实现的三个条件,一定要记下来!
    1.需要有继承关系(普通子父类的继承和抽象类的继承)或者实现(接口)的存在。
    2.需要有方法的重写。
    3.需要有父类的引用指向子类对象。

    4.设计一个家政服务规范(接口): 洗衣服, 扫地, 买菜, 做饭

    设计一个保姆类, 保姆需要遵循这些规范
    需求:在测试类中,实例化一个保姆的对象,然后让保姆买菜,做饭,扫地

    package com.company;
    
    interface Service
    {
        void wishClothes();
        void sweepFloor();
        void cookRice();
    }
    
    class Nurse implements Service
    {
        private String name;
        Nurse(){}
        Nurse(String name)
        {
            this.name = name;
        }
    
        public String getName()
        {
            return name;
        }
        public void wishClothes()
        {
            System.out.println("wishClothes");
        }
        public void sweepFloor()
        {
            System.out.println("sweepFloor");
        }
        public void cookRice()
        {
            System.out.println("cookRice");
        }
    }
    
    
    public class TaskDay09_3
    {
        public static void main(String[] args)
        {
            Nurse nurse = new Nurse("Tom");
            System.out.println(nurse.getName());
            show(nurse);
        }
        public static void show(Service ser)
        {
            ser.wishClothes();
            ser.sweepFloor();
            ser.cookRice();
        }
    }
    

    这一题同样是用到了多态,和上面两道题不一样的是,这一题里面的子类包含了自己特有的属性,因此先先定义了一个子类对象nurse,利用子类对象nurse对其属性先赋初始值。之后利用多态,创建ser(接口)对象,再将ser对象指向子类对象nurse,实例化的同样只是子类,而不是接口。
    经过这三道题目的踪总结,对于多态应当有了更深入的理解。

    5.设计一个动物类,属性: 姓名,性别

    设计一个猫类,设计一个狗类, 猫和狗都继承自动物类
    需求:在测试类中设计一个方法,这个方法需要一个参数,参数的类型可以是猫类,也可以是狗类 -->多态(动物类 )

    package com.company;
    
    abstract class Animals
    {
        private String name;
        private String sex;
    
        Animals(){}
    
        Animals(String name, String sex)
        {
            this.name = name;
            this.sex = sex;
        }
    
        public void setName(String name)
        {
            this.name = name;
        }
    
        public void setSex(String sex)
        {
            this.sex = sex;
        }
    
        public String getName()
        {
            return name;
        }
        public String getSex()
        {
            return sex;
        }
    }
    
    class Cat extends Animals
    {
        Cat(){}
        Cat(String name, String sex)
        {
            super(name, sex);
        }
    }
    
    class Dog1 extends Animals
    {
        Dog1(){}
        Dog1(String name, String sex)
        {
            super(name, sex);
        }
    }
    
    
    class TaskDay09_4
    {
        public static void main(String[] args)
        {
            Cat cat = new Cat("Tom","M");
            Dog1 dog1= new Dog1("Amy", "W");
            testAnimals(cat);
            testAnimals(dog1);
        }
    
        public static void testAnimals(Animals ani)
        {
            if (ani instanceof Cat)
            {
                //下面这段可以进行封装,但是懒。。。
                String name = ani.getName();
                String sex = ani.getSex();
                System.out.println(name);
                System.out.println(sex);
            }
            if (ani instanceof Dog1)
            {
                String name = ani.getName();
                String sex = ani.getSex();
                System.out.println(name);
                System.out.println(sex);
            }
        }
    }
    

    总结:认真做到这一道题目的时候已经对面向对象、抽象类、多态有比较深入的理解了!
    1.抽象类也是一个类,也应当包含构造方法。
    2.子类在继承抽象类时,构造方法应当重写,并继承父类的构造器。
    3.为了更加细致地体现面向对象的思想,在main方法中定义的对象应当有明确的指向,例如Cat cat = new Cat(“Tom”,“M”); 此处定义的对象cat应当指向Cat类,而不是指向的Animals类,同时利用构造器对该对象赋初始值更加方便快捷
    4.细节上来说,每次重写构造器时都应当写上该类的默认构造器,若不写上,则利用该类作为父类定义子类时,子类找不到父类的默认构造方法出现意想不到的错误。坚持一个良好习惯就成功了一半!

    6.设计一个数据传输接口:Type-C标准

    设计一个防水的接口:防水
    设计一个手机类,实现这个数据传输接口,采用Type-C;同时实现了防水的接口

    package com.company;
    
    interface TypeC
    {
    
    }
    interface waterProof
    {
    
    }
    class Phone implements TypeC,waterProof
    {
    
    }
    public class TaskDay09_5
    {
        public static void main(String[] args)
        {
            Phone phone = new Phone();
        }
    }
    

    总结:实现多个接口

    7.模拟 Arrays.sort 方法,实现如下方法,实现对一个Person数组的排序,给第二个参数传递对象时使用匿名内部类。

      MyArrays.sort(Person[] array, MyComparator comparator);
      Person是一个类,MyComparator是一个比较器,包含了compare抽象函数,需要使用匿名内部类重写
    
    package com.company;
    
    interface MyComparator
    {
        int compare(Person ren1, Person ren2);
    
    }
    
    class Person
    {
        private String name;
        private int age;
        public Person(){}
        public Person(String name, int age) {
            this.name = name;
            this.age = age;
        }
    
        public int getAge() {
            return age;
        }
    
        //重写toString方法
        public String toString()
        {
            return name+"," +age;
        }
    }
    
    public class TaskDay09_6 {
        public static void main(String[] args)
        {
            Person[] arr = {new Person("lisi", 20), new Person("zhosi", 35),
            new Person("wangzi", 18), new Person("gangzi", 40), };
            sort(arr, new MyComparator(){
               public int compare(Person ren1, Person ren2)
               {
                   return ren1.getAge() - ren2.getAge();
               }
            });
    
            for (Person person:arr)
            {
                System.out.println(person.toString());
            }
        }
    	
    	//选择排序,排序器用来比较大小的,只有这么一个功能
        public static void sort(Person[] array, MyComparator comparator)
        {
            for (int i=0; i<array.length-1; i++)
            {
                for(int j=i+1; j<array.length; j++)
                {
                    if(comparator.compare(array[j], array[i])>0)
                    {
                        Person temp = array[j];
                        array[j] = array[i];
                        array[i] = temp;
                    }
                }
            }
        }
    }
    

    按照题目要求做即可,这里对Person排序指的是对Person里的age排序。
    比较震撼的是lambda表达式,idea直接可以将匿名内部类换成lambda表达式,期待后面的学习

    展开全文
  • 随着项目的深入,Sample可能还会"生出很多儿子出来", 那么我们要这些儿子一个个实例化,更糟糕的是,可能还要以前的代码进行修改:加入后来生出儿子的实例.这在传统程序中是无法避免的. 但如果你一开始就有意识使用...
  • 面向对象部分测试题下面描述函数重写错误的是 CA. 要有子类继承或实现B. 子类方法的权限必须大于等于父类的权限C. 父类中被private权限修饰的方法可以被子类重写D. 子类重写接口中的抽象方法,子类的方法权限必须是...

    共40道选择题,每题2.5分。多选题有错则全错,全对才满分.

    面向对象部分测试题

    下面描述函数重写错误的是 C

    A.  要有子类继承或实现

    B.  子类方法的权限必须大于等于父类的权限

    C.  父类中被private权限修饰的方法可以被子类重写

    D.  子类重写接口中的抽象方法,子类的方法权限必须是public的

    关于封装下面介绍错误的是()。D

    A.  封装将变化隔离

    B.  封装提高重用性。

    C.  封装安全性

    D.  只有被private修饰才叫做封装

    试图编译运行下面的代码会发生什么情况 d

    public class MyClass{

    static int i;

    public static void main(String[] args){

    System.out.println(i);

    }

    }

    A.  错误,变量i没有被初始化

    B.  输出null

    C.  输出1

    D.  输出0

    在Java中,下面对于构造函数的描述正确的是( )。D

    A.  类必须显式定义构造函数

    B.  构造函数的返回类型是void

    C.  构造函数和类有相同的名称,并且不能带任何参数

    D.  一个类可以定义多个构造函数

    下面Java代码的运行结果是(  )。C

    class Penguin {

    private String name=null; // 名字

    private int health=0; // 健康值

    private String sex=null; // 性别

    public void Penguin() {

    health = 10;

    sex = "雄";

    System.out.println("执行构造方法。");

    }

    public void print() {

    System.out.println("企鹅的名字是" + name +

    ",健康值是" + health + ",性别是" + sex+ "。");

    }

    public static void main(String[] args) {

    Penguin pgn = new Penguin();

    pgn.print();

    }

    }

    A.  企鹅的名字是null,健康值是10,性别是雄。

    B.  执行构造方法。

    企鹅的名字是null,健康值是0,性别是null。

    C.  企鹅的名字是null,健康值是0,性别是null。

    D.  执行构造方法。

    企鹅的名字是null,健康值是10,性别是雄。

    class A {

    public int i = 10;

    }

    class B extends A{

    public int i = 20;

    }

    public class Test{

    public static void main(String args[]){

    B b = new B();

    A a = b;

    System.out.println(b.i);

    System.out.println(a.i);

    }

    }输出为多少 ()

    C

    A.10 10

    B.10 20

    C.20 10

    D.20 20

    下面说法正确的是( )。D

    A.  匿名内部类编译后不会生成.class文件

    B.  接口编译后不会生成.class文件

    C.  抽象类中没有构造方法

    D.  局部内部类只能访问被final修饰的局部变量。

    下面对this的作用描述错误的是   D

    A.  当成员变量和局部变量重名的时候可以用this区分

    B.  this()语句必须放在构造函数的第一行,根据this后面括号中的参数调用本类其他的构造函数.ss

    C.  this可以调用本类的一般函数

    D.  this不可以调用父类的一般函数

    在Java中,以下程序编译运行后的输出结果为( )。 D

    public class Test {

    int x, y;

    Test(int x, int y) {

    this.x = x;

    this.y = y;

    }

    public static void

    main(String[] args) {

    Test pt1, pt2;

    pt1 = new Test(3, 3);

    pt2 = new Test(4, 4);

    System.out.print(pt1.x +

    pt2.x);

    }

    }

    A.  6

    B.  3 4

    C.  8

    D.  7

    在Java语言中,下列关于类的继承的描述,正确的是( )。B

    A.  一个类可以继承多个父类

    B.  一个类可以具有多个子类

    C.  子类可以使用父类的所有方法

    D.  子类一定比父类有更多的成员方法

    Java中,如果类C是类B的子类,类B是类A的子类,那么下面描述正确的是( )。

    A.  C可以继承B中的公有成员,同样也可以继承A中的公有成员

    B.  C只继承了B中的成员

    C.  C只继承了A中的成员

    D.  C不能继承A或B中的成员

    给定一个Java程序Test.java的代码如下所示,编译时,会出现以下( )情况。C

    class Parent {

    public int count() {               // 第1行

    return 0;

    }

    }

    public  class Test  extends Parent {

    public float count() {               // 第2行

    return 9;                // 第3行

    }

    }

    A.  编译通过

    B.  在第1行引发编译错误

    C.  在第2行引发编译错误

    D.  在第3行引发编译错误

    给定如下一个Java源文件Child.java,编译并运行Child.java,以下结果正确的是( )。

    class Parent1 {

    Parent1(String s){

    System.out.println(s);

    }

    }

    class Parent2  extends Parent1{

    Parent2(){

    System.out.println("parent2");

    }

    }

    public class Child extends Parent2 {

    public static void

    main(String[] args) {

    Child child = new Child();

    }

    }B

    A.  编译错误:没有找到构造器Child()

    B.  编译错误:没有找到构造器Parent1()

    C.  正确运行,没有输出值

    D.  正确运行,输出结果为:parent2

    给定Java程序Child.java的代码如下所示,则编译运行该类的结果是( )。

    class Parent {

    Parent() {

    System.out.println("parent");

    }

    }

    public class Child extends Parent {

    Child(String s) {

    System.out.println(s);

    }

    public static void

    main(String[] args) {

    Child child = new

    Child("child");

    }

    }C

    A.  child

    B.  child

    parent

    C.  parent

    child

    D.  编译错误

    下列选项中关于Java中super关键字的说法错误的是( )。B

    A.  当子父类中成员变量重名的时候,在子类方法中想输出父类成员变量的值,可以用super区分子父类成员变量

    B.  super语句可以放在构造函数的任意一行

    C.  子类可以通过super关键字调用父类的方法

    D.  子类可以通过super关键字调用父类的属性

    分析如下所示的Java代码,则选项中的说法正确的是( )。C

    class Parent{

    public String name;

    public Parent(String pName){

    this.name = pName;

    }

    }

    public class Test  extends Parent

    {  //1

    public Test(String Name){               //2

    name="hello";          //3

    super("kitty");          //4

    }

    }

    A.  第2行错误,Test类的构造函数中参数名称应与其父类构造函数中的参数名相同

    B.  第3行错误,应使用super关键字调用父类的name属性,改为super.name="hello";

    C.  第4行错误,调用父类构造方法的语句必须放在子类构造方法中的第一行

    D.  程序编译通过,无错误

    以下关于Object类说法错误的是( )。B

    A.  一切类都直接或间接继承自Object类

    B.  接口也继承Object类

    C.  Object类中定义了toString()方法

    D.  Object类在java.lang包中

    在Java中,多态的实现不仅能减少编码的工作量,还能大大提高程序的可维护性及可扩展性,下面哪一个选项不属于多态的条件( )。B

    A.  子类重写父类的方法

    B.  子类重载同一个方法

    C.  要有继承或实现

    D.  父类引用指向子类对象

    给定Java代码如下所示,则编译运行后,输出结果是( )。C

    class Parent {

    public void count() {

    System.out.println(10%3);

    }

    }

    public class Child  extends

    Parent{

    public void count() {

    System.out.println(10/3);

    }

    public static void main(String

    args[]) {

    Parent p = new Child();

    p.count();

    }

    }

    A.  1

    B.  1.0

    C.  3

    D.  3.3333333333333335

    编译运行如下Java代码,输出结果是(   )。D

    class Base {

    public void method(){

    System.out.print

    ("Base method");

    }

    }

    class Child extends Base{

    public void methodB(){

    System.out.print

    ("Child methodB");

    }

    }

    class Sample {

    public static void

    main(String[] args) {

    Base base= new Child();

    base.methodB();

    }

    }

    A.  Base method

    B.  Child methodB

    C.  Base method Child MethodB

    D.  编译错误

    在Java接口中,下列选项中属于有效的方法声明是( )。A

    A.  public void aMethod();

    B.  final void aMethod();

    C.  void aMethod(){}

    D.  private void aMethod();

    给定如下Java程序代码,在_____横线处加入( )语句,可以使这段代码编译通过。

    interface Parent{

    public int count(int i);

    }

    public class Test implements Parent {

    public int count(int i){

    return i % 9;

    }

    public static void main(String[] args){

    ________________

    int i = p.count(20);

    }

    }  A

    A.  Test p = new Test();

    B.  Parent p;

    C.  Parent p = new Parent();

    D.  Test p = new Parent();

    下面说法中错误的是  D

    静态代码块类一加载只执行一次,以后再创建对象的时候不执行

    局部代码块的作用是为了限制变量的生命周期

    C.  构造代码块在每创建一次对象就执行一次

    D.  以上都不对

    在Java中,如果父类中的某些方法不包含任何逻辑,并且需要有子类重写,应该使用(     )关键字来声明父类的这些方法。  C

    A.  final

    B.  static

    C.  abstract

    D.  void

    给定两个java程序,如下:

    public interface Face{

    int counter = 40;

    }

    public class Test implements Face{

    private static int counter;

    public static void main(String[]args){

    System.out.println(++counter);

    }

    }   Test.java 的编译运行结果是( )。   d

    A.  40

    B.  41

    C.  0

    D.  1

    给定java代码,如下:

    public class Test{

    static int i;

    public int aMethod( ){

    i++;

    return i;

    }

    public static void main(String [] args){

    Test test = new Test( );

    test.aMethod( );

    System.out.println(test.aMethod( ));

    }

    }编译运行后,输出结果是( )。  C

    A.  0

    B.  1

    C.  2

    D.  3

    给定java程序,如下:

    public class Test{

    private static final int counter=10;

    public static void main(String [] args){

    System.out.println(++counter);

    }

    }

    编译运行Test.java,结果是 ( )   D

    A.  10

    B.  11

    C.  编译错误

    D.  运行时出现异常

    给定一个Java程序代码,如下:

    public class Test{

    int count = 9;

    public void count1(){

    int count =10;

    System.out.println("count1="+count);

    }

    public void count2(){

    System.out.println("count2="+count);

    }

    public static void main(String args[]){

    Test t=new Test();

    t.count1();

    t.count2();

    }

    }

    编译运行后,输出结果是 B

    A.  count1=9 count2=9

    B.  count1=10 count2=9

    C.  count1=10 count2=10

    D.  count1=9 count2=10

    给定java代码,如下:编译运行,结果是 A

    public static void main (String [] args){

    String s;

    System.out.println(“s=”+s);

    }

    A.  编译错误

    B.  编译通过,但出现运行时错误

    C.  正常运行,输出s=null

    D.  正常运行,输出s=

    在java中,以下程序的输出结果是()。  C

    class Point  {

    int x;

    boolean y;

    void output()     {

    System.out.println(x);

    System.out.println(y);

    }

    public static void main(String[] args)     {

    Point pt =new Point();

    pt.output();

    }

    }

    A.  运行错误

    B.  0 ture

    C.  0 false

    D.  0 0

    多选择题:

    给定如下 java 代码, 以下(    )访问控制修饰符可以填入下划线处。  AD

    class Parent{

    protected void eat(){

    }

    }

    class Child extends Parent {

    _______ void eat(){

    }

    }

    A.  protected

    B.  private

    C.  什么也不填

    D.  public

    给定如下Java代码 , 以下(  )方法可以加入Child类中。  AB

    public class Parent{

    int change(){

    }

    }

    Class Child extends Parent{

    (此处可以放入下面哪个选项)

    }

    A.  public int change(){}

    B.  int show(int i){}

    C.  private int change(){}

    D.  abstract int change(){}

    下面对static的描述正确的是 ACD

    A.  静态修饰的成员变量和成员方法随着类的加载而加载

    B.  静态修饰的成员方法可以访问非静态成员变量

    C.  静态修饰的成员可以被整个类对象所共享

    D.  静态修饰的成员变量和成员方法随着类的消失而消失

    给定java代码,如下:

    abstract class Shape     {

    abstract void draw( );

    }

    要创建Shape类的子类Circle,以下代码正确的是()。 BD

    A.  class Circle extends Shape{    int draw( ){}      }

    B.  abstract class Circle extends Shape{      }

    C.  class Circle extends Shape{    void draw( );

    D.  class Circle extends Shape{    void draw( ){} }

    在Java中,下面关于抽象类的描述正确的是()。   ABD

    A.  抽象类可以被实例化

    B.  如果一个类中有一个方法被声明为抽象的,那么这个类必须是抽象类

    C.  抽象类中的方法必须都是抽象的

    D.  声明抽象类必须带有关键字abstract

    在java中,已定义了两个接口B和C以下语句正确的是 ( )  AC

    A.  interface A extends B,C

    B.  interface A implements B,C

    C.  class A implements B,C

    D.  class A implements B,implements C

    关于abstract不能和哪些关键字共用正确的是() ABC

    A.  abstract不可以和private共用

    B.  abstract不可以和static共用

    C.  abstract不可以和final共用

    D.  abstract不可以和public共用

    下面关于Java接口的说法正确的是( )。ABD

    A.  Java接口中定义的是扩展功能

    B.  Java接口中可以被多个子类实现,一个类也可以同时实现多个接口

    C.  Java接口中可以声明私有成员

    D.  Java接口不能被实例化

    分析如下Java代码,如果想在控制台上输出“B类的test()方法”,则在主函数应填入( )。AD

    class A {

    public void test() {

    System.out.println("A类的test()方法");

    }

    }

    class B extends A {

    public void test() {

    System.out.println("B类的test()方法");

    }

    public static void main(String

    args[]) {

    }

    }

    A.  A a = new B();

    a.test();

    B.  A a = new A();

    a.test();

    C.  B b = new A();

    b.test();

    D.  new B().test();

    在Java接口中定义常量,下面语法正确的是( )。ABC

    A.  static int MALE = 1;

    B.  final int MALE = 1;

    C.  int MALE = 1;

    D.  private int MALE = 1;

    展开全文
  • 在XML文档中,上述几种语句的语法都是错误的。因为: 1.所有的标记都必须要有一个相应的结束标记; 2.所有的XML标记都必须合理嵌套; 3.所有XML标记都区分大小写; 4.所有标记的属性必须用""括起来; 所以上列...
  • 实际上,封装在程序和数据之间设置了一道栅栏,它可以阻止一部分设计错误,不至 于涉足应用程序其他部分数据。 2.2.3 消息 一个单独对象一般不十分有用,而作为一员出现在包含有许多其他对象大...
  • .NET 数据提供程序代码访问安全:描述随 .NET 框架提供 .NET 数据提供程序可用附加代码访问安全权限,并说明如何确定特定权限是否可用于所运行代码。   创建和使用 DataSet 创建 DataSet:描述创建 ...
  •  GC是垃圾收集的意思(Gabage Collection),内存处理是编程人员容易出现问题的地方,忘记或者错误的内存回收会导致程序或系统的不稳定甚至崩溃,Java提供的GC功能可以自动监测对象是否超过作用域从而达到自动回收...
  • 你必须知道495个C语言问题

    千次下载 热门讨论 2015-05-08 11:09:25
    1.27 我编译器总在报函数原型不匹配的错误,可我觉得没什么问题。这是为什么? 1.28 文件中第一个声明就报出奇怪语法错误,可我看没什么问题。这是为什么? 1.29 为什么我编译器不允许我定义大数组,如...
  • 异常是问题的描述,根据java面向对象思想将问题进行对象的封装 2,异常体系 异常大哥是Throwable,下面有两个小弟分别是Error和Exception。对于Error是一种严重的错误,一般不编写针对性的

    ------- java培训,android培训、期待与您交流! ----------

    学习内容:异常体系;一个经典的异常处理例子;包

    一、异常体系
    1,异常概念
    异常是对问题的描述,根据java的面向对象思想将问题进行对象的封装
    2,异常体系
    异常的大哥是Throwable,下面有两个小弟分别是Error和Exception。对于Error是一种严重的错误,一般不编写针对性的代码对其进行处理。另外一种是Exception,非严重性的错误,一般要编写针对性的处理代码。在Exception的小大哥下,还有一个小弟弟RuntimeExceptin(运行时异常),这个小异常体系中的异常,可以不抛出,不声明,不处理,程序照样编译通过,照样正常执行,很特殊吧,哈哈。
    3,异常体系的特点
    异常体系中的所有类以及建立的对象都具备可抛性,也就是说可以被throw和throws关键字所操作,只有异常体系具备这个特点。
    4,throw和throws关键字的用法和区别
    throw定义在函数内部,用于抛出异常对象。
    throws定义在函数上,用于抛出异常类,可以抛出多个,中间使用逗号隔开。
    当函数内有throw抛出的异常对象,并未进行处理,那么必须要在函数上声明,否则编译失败,但是RuntimeException这个特殊异常例外,也就是说,函数内部抛出了RuntimeException异常,函数上可以不声明。如果函数上声明了异常,调用者必须由相应的处理方式,要么抛给上一层调用者,或者自己在内部自己处理。
    5,异常的处理语句
    try
    {
    需要被检测异常的代码;
    }
    catch()
    {
    处理异常的代码
    }
    finally
    {
    一定会执行的代码
    }
    6,异常语句的几种结合格式
    try try try
    { } { } { }
    catch finally catch()
    { } { } { }
    finally
    { }
    7,自定义异常
    定义异常类继承Exception或者RuntimeException
    1),为了让该类具备可抛性
    2),让该类具备操作异常的共性方法
    8,异常的处理原则
    1),异常有两种处理方式,一种是自己处理try 或者 抛出去 throws让调用者处理
    2),调用到抛出异常的功能时,抛出几个,就处理几个,一个try可以对应多个catch
    3),多个catch,父类的catch放在最下面
    4),catch内,需要定义针对性的处理方法,不要简单的定义输出语句,也不要不处理而把问题隐藏。
    9,一个很重要的异常处理思想
    当捕获到异常,本功能处理不了,可以继续在catch中抛出。
    如果捕获的异常处理不了,但并不属于该功能的异常,可以将异常转换后,再抛出和该功能相关的异常。或者异常可以处理,当需要将异常产生和本功能相关的问题提供出去,让调用者知道并处理,也可以将捕获到的异常处理后,转换新的异常。
    10,在子父类覆盖时,异常的处理原则
    1),子类抛出的异常,必须是父类的异常的子类或者子集。
    2),如果父类或者接口没有异常抛出,自理覆盖出现异常,只能自己处理,也就是try处理,绝对不能抛出
    11,一个注意事项
    throw以及return下面的语句不会被执行,并且这种情况下会编译失败。
    二、一个经典的异常处理例子
    需求:以老师讲课使用电脑,而电脑可能出现各种各样的故障,例如,蓝屏,或者硬件损坏等等,蓝屏的话,老师可以自己处理,重启电脑就行了,如果是硬件损坏,则老师无法处理,但是这个异常与老师调用讲课的方法无关,但是他可以转换为自己的异常然后抛出,让高层解决。
    class BlueScreenException extends Exception
    {
    BlueScreenException(String msg)
    {
    super(msg);
    }
    }
    class SmokingException extends Exception
    {
    SmokingException(String msg)
    {
    super(msg);
    }
    }
    class NoPlanException extends Exception
    {
    NoPlanException(String msg)
    {
    super(msg);
    }
    }
    class Computer
    {
    private int state=3;
    public void run()throws BlueScreenException,SmokingException
    {
    if (state==2)
    {
    throw new BlueScreenException("blue screen");
    }
    if (state==3)
    {
    throw new SmokingException("computer is smoking");
    }
    System.out.println("computer is running");
    }
    public void reset()
    {
    state=1;
    System.out.println("电脑已经重启完毕");
    }
    }
    class Teacher
    {
    public void teach() throws NoPlanException
    {
    Computer cmpt=new Computer();
    try
    {
    cmpt.run();
    System.out.println("讲课");
    }
    catch (BlueScreenException e)
    {
    cmpt.reset();
    System.out.println("讲课");
    //cmpt.run();
    }
    catch (SmokingException e)
    {
    test();
    throw new NoPlanException("由于电脑坏了,课时无法继续");
    }
    }
    public void test()
    {
    System.out.println("练习");
    }
    }
    class TestException
    {
    public static void main(String[] args)
    {
    Teacher t=new Teacher();
    try
    {
    t.teach();
    }
    catch (NoPlanException e)
    {
    System.out.println(e.toString());
    System.out.println("放假活着联系");
    }
    }
    }
    三、包
    1,包的概述
    1)对类文件进行分类管理
    2)给类提供多层的命名空间
    3)写在程序文件的第一行
    4)类名的全称就变成了 包名.类名
    5)包也是一种封装形式。
    2,包的出现访问特点
    1)包与包之间进行访问,被访问的包中的类以及类中的成员需要public修饰
    2)不同包中的类可以直接访问父类中被protected权限修饰的成员
    3)包与包之间可以使用的权限只有两种:public 和protected
    3,import关键字
    当包出现后,包与包之间的类的访问需要使用类的全称,也就是包名.类名,这时候为了简化书写,就引入了import关键字。import导入程序中是该包中的类,而没有包中的子包。在import导入时,不要使用*通配符,需要用到包中的那个类,就导入那个类,因为使用通配符,太占用内存。如果两个保重有重名的类,那样在使用类时类名前加包名。
    4,jar包
    jar包是java的一种压缩包
    方便项目的携带
    方便于使用,只要在classpath下设置jar路径即可
    数据库驱动 SSH框架都是以jar包体现的
    展开全文
  • 《你必须知道495个C语言问题》

    热门讨论 2010-03-20 16:41:18
    1.27 我编译器总在报函数原型不匹配的错误,可我觉得没什么问题。这是为什么? 15 1.28 文件中第一个声明就报出奇怪语法错误,可我看没什么问题。这是为什么? 15 1.29 为什么我编译器不允许我定义大数...
  • Egret 童话 与 现实

    2021-01-03 14:33:25
    但是它的好处大多数也仅仅体现在『有助于减少在编码期因失误造成的拼写错误等低级错误的发生』。也许有人会说,这个好处已经足够了,配合强大的IDE可以更好的开发复杂的企业级项目,尤其那种大型...
  • C#微软培训资料

    2014-01-22 14:10:17
    <<page 1>> page begin==================== 目 目目 目 录 录录 ... 2000 年 6 月 22 日 不论 Microsoft 还是整个 IT 业界都将成为值得纪念一天 这一天 微软公司正式推出了其下一代...
  • C) 目标系统层次结构进行描述 D) 作为分析和设计工具 8. 数据字典是数据流图中所有元素定义集合,一般由以下四类条目组成(C)。 A) 数据说明条目、控制流条目、加工条目、数据存储条目 B) 数据流条目...
  • 1.27 我编译器总在报函数原型不匹配的错误,可我觉得没什么问题。这是为什么? 15 1.28 文件中第一个声明就报出奇怪语法错误,可我看没什么问题。这是为什么? 15 1.29 为什么我编译器不允许我定义大数...
  • C#微软培训教材(高清PDF)

    千次下载 热门讨论 2009-07-30 08:51:17
    C#--微软.NET第一语言 本书着重介绍语言本身,比较少涉及应用,不错入门书,从头讲起,不怕不明白。 <<page 1>> page begin==================== 目 目目 目 录 录录 录 第一部分 C#语言概述.4 ...
  • (25) 下面对对象概念描述错误的是(A) 注:P55 A. 任何对象都必须有继承 B. 对象是属性和方法的封装体 C. 对象间的通讯靠消息传递 D. 操作是对象的动态属性 (26) 下面不属于软件工程的3个要素的是(D) 注:P62 A. ...
  • (25) 下面对对象概念描述错误的是______。(A) A. 任何对象都必须有继承 B. 对象是属性和方法的封装体 C. 对象间的通讯*消息传递 D. *作是对象的动态属性 (26) 下面不属于软件工程的3个要素的是______。(D) A. ...
  • 上面讲过来,使用类是为了让它实例出对象来给我们用,这就要知道你想要的是什么样的 象了,像上面我们讲的一个装机配置单上写什么,你装出来的机子就有什么。比如说,一个人就是 一个对象,你怎么把一个你看好的人...
  • ASP.NET网页代码模型及生命周期

    热门讨论 2009-07-28 14:22:11
    在ASP.NET中,能够使用面向对象思想和软件开发中一些思想,例如封装、派生、继承以及高级设计模式等。本章首先介绍ASP.NET中最重要概念---网页代码模型。 4.1 ASP.NET网页代码模型 在ASP.NET应用程序开发...
  • 对象声明描述的是存 储在对象中的信息以及可对象执行的操作(类方法)。对象的某些组成部分对于外界来说是可见的(公有部 分),而某些部分却是隐藏的(私有部分)。特殊的类方法(构造函数和析构函数)在对象创建和释放...
  • 4. 用况图关于角色的说法中错误的是( D )。 A. 参与者是与目标系统交互的人或物 B. 参与者可以是实际的人,也可以是外部设备、外部系统等 C. 参与者之间可以存在一定的关系 D. 参与者是用例图的重要组成部分...
  • 对象声明描述的是存 储在对象中的信息以及可对象执行的操作(类方法)。对象的某些组成部分对于外界来说是可见的(公有部 分),而某些部分却是隐藏的(私有部分)。特殊的类方法(构造函数和析构函数)在对象创建和释放...
  • 对象声明描述的是存 储在对象中的信息以及可对象执行的操作(类方法)。对象的某些组成部分对于外界来说是可见的(公有部 分),而某些部分却是隐藏的(私有部分)。特殊的类方法(构造函数和析构函数)在对象创建和释放...
  • 对象声明描述的是存 储在对象中的信息以及可对象执行的操作(类方法)。对象的某些组成部分对于外界来说是可见的(公有部 分),而某些部分却是隐藏的(私有部分)。特殊的类方法(构造函数和析构函数)在对象创建和释放...

空空如也

空空如也

1 2 3 4 5
收藏数 100
精华内容 40
关键字:

下面对封装性描述错误的是