面向对象（七）

最新推荐文章于 2021-11-13 20:37:58 发布
最新推荐文章于 2021-11-13 20:37:58 发布
阅读量328 收藏
点赞数
分类专栏： JavaSE 文章标签： 面向对象
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chouchougege0905/article/details/54411954
版权

一、类名作为形式参数
形式参数:
基本类型（太简单）
引用类型
类（匿名对象的时候其实我们已经讲过了）需要的是该类的对象
抽象类:需要的是该抽象的类子类对象
接口：跟接口很相似，需要的是该接口的实现类对象。

abstract class Person{
    public abstract void study();
}

class PersonDemo{
    public void method(Person p){
        p.study();
    }
}

class Student extends Person{
    public void study(){
        System.out.println("Good Good Study,Day Day Up");
    }
}

class PersonTest{
    public static void main(String[] args){
        /*
            目前是没有办法使用的
            因为抽象类没有对应的具体类
            那么，我们就应该先定义一个具体类
            需求：我要使用persondemo类中的method方法
        */
        PersonDemo pd = new PersonDemo();
        Person p = new Student();//多态
        pd.method(p);
    }
}
//  定义一个爱好的接口
interface Love{
    public abstract void love();

}

class LoveDemo{
    public void method(Love l){
        l.love();
    }
}

//定义具体类实现接口
class Teacher implements Love{
    System.out.println("老师爱学生，爱java，爱周秀蓉");
}

class TeacherTest{
    public static void main(String[] args){
        LoveDemo ld = new LoveDemo();
        Love l = new Teacher();
        ld.method(l);
    }
}

二、类名作为返回值类型
返回值类型
基本类型：太简单
引用类型：
类：返回的是该类的对象。
抽象类：返回的是该抽象类的子类对象
接口：返回的是该接口的实现类的对象

class Student{
    public void study(){
        System.out.println("Good Good Study,Day Day Up");
    }
}

class StudentDemo{
    public Student method(){
        return new Student();
    }
}

class ClassDemo{
    public static void main(String[] args){
        //需求：调用Student中的study方法
        //但是不直接创建对象调用，而是通过StudentDemo调用
        StudentDemo sd  = new StudentDemo();
        Student s = sd.method();
        s.study();
    }
}
abstract class Person{
    public abstract void study();
}

class PersonDemo{
    public Person method(){
        //Person p = new Student();
        //return p;
        return new Student();
    }
}

class Student extends Person{
    public void study(){
        System.out.println("Good Good Study,Day Day Up");
    }
}



class PersonTest{
    public static void main(String[] args){

        PersonDemo pd = new PersonDemo();
        Person p = pd.method();
        p.study();
    }
}
//  定义一个爱好的接口
interface Love{
    public abstract void love();

}

class LoveDemo{
    public Love method(){
        //Love l = new Teacher();
        //return l;
        return new Teacher();
    }
}

//定义具体类实现接口
class Teacher implements Love{
    public void love(){
        System.out.println("老师爱学生，爱java，爱周秀蓉");
    }
}

class TeacherTest{
    public static void main(String[] args){

        LoveDemo ld = new LoveDemo();
        Love l = ld.method();
        l.love();
    }
}

三、链式编程

/*
    链式编程：
        每次调用完毕方法后，返回的是一个对象。
*/

class Student{
    public void study(){
        System.out.println("Good Good Study,Day Day Up");
    }
}

class StudentDemo{
    public Student method(){
        return new Student();
    }
}

class StudentTest{
    public static void main(String[] args){
        StudentDemo sd = new StudentDemo();
        //Student s = sd.method();
        //s.study();

        //注意了
        //现象：对象调方法，再调方法，再调方法
        sd.method().study();

    }
}

四、package关键字
1.概述

/*
    包：
        A:其实就是文件夹
        B:作用
            a:把相同的类名放到不同的包中
            b:对类进行分类管理
    举例：
        学生：增加，删除，修改，查询
        老师：增加，删除，修改，查询
    ...

    分包的方案：
        方案1：按照功能分
            cn.jkx.add
                AddStudent
                AddTeacher
            cn.jkx.delete
                DeleteStudent
                AddTeacher
            cn.jkx.update
                UpdateStudent
                AddTeacher
            cn.jkx.find
                FindStudent
                FindTeacher

        方案2：按照模块分
            cn.jkx.teacher
                AddTeacher
                AddTeacher
                AddTeacher
                FindTeacher
            cn.jkx.student
                AddStudent
                DeleteStudent
                UpdateStudent
                FindStudent
*/

2.包的定义

/*
    包的定义：
        package 包名；
            多级包用.分开即可
            package cn.jkx.student

    包的注意事项：
        A:package语句必须是程序的第一条可执行的代码
        B:package语句在一个java文件中只能有一个
        C:如果没有package，默认表示无包名
*/

五、import关键字

/*
    导包：
        格式：import 包名;
            这种方式导入时到类的名称；
        注意：我们用哪个类就导入哪个类，
                不要导入*

        面试题：
            package，import，class有没有顺序关系

            package > import > class

            package:只能有一个
            import:可以有多个
            class:可以有多个，以后建议是一个

*/
import com.yangb.Demo;

六、四种权限修饰符
权限修饰符:
本类中 同一个包下（包含子类和无关类） 不同包下（子类） 不同包下（无关类）
private Y N N N
默认 Y Y N N
protected Y Y Y N
public Y Y Y Y

七、内部类的概述和访问特点
1.内部类概述：
把类定义在其他类的内部，这个类就被称为内部类。
举例：在类A中定义一个类B，类B就是内部类。
内部类的访问特点：
A:内部类可以直接访问外部类的成员，包括私有。
B：外部类要访问内部类的成员，必须创建对象

class Outer{

    private int num = 10;

    class Inear{
        public void show(){
            System.out.println(num);
        }
    }

    public void method(){
        //找不到符号
        //show();
        Inear i = new Inear();
        i.show();
    }
}


class InearClassDemo{
    public static void main(String[] args){

    }
}

2.内部类分类及成员内部类的直接使用
内部类的位置
成员位置：在成员位置定义的类，被称为成员内部类。
局部位置：在局部位置定义的类，被称为局部内部类。

class Outer{
    private int num = 10;

    //成员位置
    class Inner{

    }
    /*
    public void method(){
        class Inner{

        }
    }
    */
}
class InnerClassDemo{
    public static void main(String[] args){

    }
}

成员内部类：
如何直接访问内部类的成员。
外部类名.内部类名 对象名 = 外部类对象.内部类对象

class Outer{
    private int num = 10;

    class Inner{
        public void show(){
            System.out.println(num);
        }
    }
}

class InnerClassDemo2{
    public static void main(String[] args){
        Outer.Inner oi = new Outer().new Inner();
        oi.show();
    }
}

成员内部类的修饰符：
private：为了保证数据的安全性
static：为了方便访问数据
注意：静态内部类访问的外部类的数据只能是static修饰的。

案例：我有一个人，人有身体，身体内有心脏。

    class Body{
        private class Heart{
            public void operator(){
                System.out.println("心脏搭桥");
            }
        }

        public void method(){
            if(如果你是外科医生){
                Heart h = new Heart();
                h.operator();
            }
        }
    }

    按照我们刚才的讲解，来使用一下
    Body.Heart bh = new Body().new Heart();
    bh.operator();
    //加了private后，就不能被直接访问了。
    Body b = new Body();
    b.method();

class Outer{
    private int num = 10;
    private static int num2 = 100;

    //内部类用静态修饰是因为内部类可以看成是外部类的成员。
    public static class Inner{
        public void show(){
        //错误: 无法从静态上下文中引用非静态 变量 num
            //System.out.println(num);
            System.out.println(num2);
            //静态内部类中访问的外部类的数据只能是静态修饰的。
        }

        public static void show2(){
            //System.out.println(num);
            System.out.println(num2);
        }
    }
}


class InnerClassDemo3{
    public static void main(String[] args){
        //使用内部类
        //Outer.Inner oi = new Outer().new Inner();
        //oi.show();
        //oi.show2();

        //成员内部类被静态修饰后的访问方式是：
        //格式：外部类名.内部类名  对象名 = new 外部内名.内部类名（）；
        Outer.Inner oi = new Outer.Inner();
        oi.show();
        oi.show2();

        //show2的另一种调用方式
        Outer.Inner.show2();
    }
}

3.成员内部类的面试题
要求分别输出30,20,10，请填空

注意：
    1.内部类和外部类没有继承关系
    2.通过外部类名限定this对象
        Outer.this

class Outer{
    public int num = 10;
    class Inner{
        public int num = 20;
        public void show(){
            int num = 30;
            System.out.println(num);
            System.out.println(this.num);
            //System.out.println(new Outer.num);
            System.out.println(Outer.this.num);
        }
    }
}

class InnerClassTest{
    public static void main(String[] args){
        Outer.Inner oi = new Outer().new Inner();
        oi.show();
    }
}

4.局部内部类访问局部变量的问题
局部内部类
A:可以直接访问外部类成员
B:在局部位置，可以创建内部类对象，通过对象调用内部类方法，来使用局部内部类功能。
面试题：
局部内部类访问局部变量的注意事项：
A；局部内部类访问局部变量必须用final修饰
为什么呢？
局部变量是随着方法的调用而调用，随着调用完毕而消失。
而堆内存的内容并不会立即消失，所以，我们加final修饰。
加入final修饰后，这个变量就成了常量。既然是常量，你消失了
我再内存中存储的是数据20，所以，我还是有数据在使用。

class Outer{
    private int num = 10;

    public void method(){
        final int num2 = 20;
        class Inner{
            public void show(){
                System.out.println(num);
                //错误: 从内部类中访问本地变量num2; 需要被声明为最终类型
                System.out.println(num2);//20

            }
        }

        Inner i = new Inner();
        i.show();
    }
}


class InnerClassDemo{
    public static void main(String[] args){
        Outer o = new Outer();
        o.method();
    }
}

5.匿名内部类的格式和理解
匿名内部类
就是内部类的简化写法
前提：存在一个类或者接口
这里的类可以是具体类也可以是抽象类。

格式：
    new 类名或者接口名(){
        重写方法；
    };

本质是什么呢？
    是一个继承了该类或者实现了该接口的子类匿名对象。

interface Inter{
    public abstract void show();
    public abstract void show2();
}

class Outer{
    public void method(){
        //一个方法的时候
        /*
        new Inter(){
            public void show(){
                System.out.println("show");
            }
        }.show();*/

        //两个方法的时候
        /*
        new Inter(){
            public void show(){
                System.out.println("show");
            }
            public void show2(){
                System.out.println("show2");
            }
        }.show();

        new Inter(){
            public void show(){
                System.out.println("show");
            }
            public void show2(){
                System.out.println("show2");
            }
        }.show2();*/

        //如果我是很多个方法，就很麻烦了
        //那么，有没有改进的方案呢？
        Inter i = new Inter(){//多态
            public void show(){
                System.out.println("show");
            }
            public void show2(){
                System.out.println("show2");
            }
        };

        i.show();
        i.show2();
    }
}

class InnerClassDemo{
    public static void main(String[] args){
         Outer o = new Outer();
            o.method();

         }
}

6.匿名内部类在开发中的应用

interface Person{
    public abstract void study();
}

class PersonDemo{
    //接口名作为形式参数
    //其实这里需要的不是接口，而是接口的实现类
    public void method(Person p){
        p.study();
    }
}

//实现类
class Student implements Person{
    public void study(){
        System.out.println("好好学习，天天向上");
    }
}


class InnerClassDemoTest{
    public static void main(String[] args){
        PersonDemo pd = new PersonDemo();
        Person p = new Student();
        pd.method(p);
        System.out.println("--------------");

        //匿名内部类在开发中的使用
        //匿名内部类的本质是继承类或者实现了接口的子类匿名对象
        pd.method(new Person(){
            public void study(){
                System.out.println("好好学习，天天向上");
            }
        });
    }
}

7.匿名内部类面试题

按照要求，补齐代码
            interface Inter{
                void show();
            }
            class Outer{//补齐代码}
            class OuterDemo{
                public static void main(String[] args){
                    Outer.method().show();
                }
            }

            //要求在控制台输出“hello world”
interface Inter{
    void show();
    //public abstract
}

class Outer{
    public static Inter method(){
        //子类对象 -- 子类匿名对象
        return new Inter(){
            public void show(){
                System.out.println("hello world");
            }
        };

    }
}

class OuterDemo{
    public static void main(String[] args){
        Outer.method().show();
        /*
            1.Outer.method():可以看出method是Outer中的一个静态方法
            2.Outer.method().show()：可以看出method（）方法的返回值是一个对象
            3.又由于Inter中有一个show（）方法，所以，我认为method（）的返回值类型是一个接口。
        */
    }
}

七、Myeclipse工具的使用
1:Eclipse的安装

2:用Eclipse写一个HelloWorld案例，最终在控制台输出你的名字

A:创建项目
B:在src目录下创建包。cn.itcast
C:在cn.itcast包下创建类。HelloWorld
D:在HelloWorld下有一个方法。public static void main(String[] args) {}
E:在main方法中有一个输出语句。System.out.println("你的名字");

3:Eclipse空间的基本配置
A:程序的编译和运行的环境配置(一般不改)
window – Preferences – Java
编译环境：Compiler 默认选中的就是最高版本。
运行环境：Installed JREs 默认会找你安装的那个JDK。建议配置了Java的环境变量。
问题：
低编译，高运行。可以。
高编译，低运行。不可以。
建议，编译和运行的版本一致。

B:如何去掉默认注释?
    window -- Preferences -- Java -- Code Style -- Code Templates
    选择你不想要的内容，通过右边Edit编辑。
    注意：请只删除注释部分，不是注释部分的不要删除。

C:行号的显示和隐藏
    显示：在代码区域的最左边的空白区域，右键 -- Show Line Numbers即可。
    隐藏：把上面的动作再做一次。

D:字体大小及颜色
    a:Java代码区域的字体大小和颜色：
        window -- Preferences -- General -- Appearance -- Colors And Fonts -- Java修改 -- Java Edit Text Font
    b:控制台
        window -- Preferences -- General -- Appearance -- Colors And Fonts -- Debug -- Console font
    c:其他文件
        window -- Preferences -- General -- Appearance -- Colors And Fonts -- Basic -- Text Font

E:窗体给弄乱了，怎么办?
    window -- Reset Perspective

F:控制台找不到了，怎么办?
    Window--Show View—Console

4:常用快捷键
A:格式化 ctrl+shift+f
B:导入包 ctrl+shift+o
如果该类仅仅在一个包中有，就自己显示了
如果该类在多个包中有，会弹出一个框框供你选择
C:注释
单行：注释 ctrl+/，取消注释再来一次。
多行：ctrl+shift+/,ctrl+shift+\
D:代码上下移动
选中代码alt+上/下箭头
E:查看源码
选中类名(F3或者Ctrl+鼠标点击)

5:如何提高开发效率
A:自动生成构造方法
a:无参构造方法 在代码区域右键–source–Generate Constructors from Superclass
b:带参构造方法 在代码区域右键–source–Generate Constructors using fields.. – finish
B:自动生成getXxx()/setXxx()方法
在代码区域右键–source–Generate Getters and Setters…

提供了对应的快捷键操作。
    alt+shift+s 
    按下带有下划线的那个字母即可。

C:如何继承抽象类和实现接口。
D:Override的作用
    表示该方法是重写父类的。如果方法声明和父类不匹配，就会报错。

6:通过讲解的快捷键和提高开发效率的一些内容完成如下内容
自定义学生类:Student
成员变量；
姓名
年龄
构造方法：
无参
带参
成员方法：
getXxx()/setXxx()
在给出一个show()方法，显示类的所有成员信息。

然后，写一个测试类，对学生的代码进行测试。
    StudentDemo

7:删除项目和导入项目
删除项目
选中项目 – 右键 – 删除
从项目区域中删除
从硬盘上删除

导入项目
    在项目区域右键找到import
    找到General，展开，并找到
    Existing Projects into Workspace
    点击next,然后选择你要导入的项目
    注意：这里选择的是项目名称

8:要注意的几个小问题
如何查看项目所在路径
选中 – 右键 – Properties – Resource – Location
导入项目要注意的问题
项目区域中不可能出现同名的项目(新建或者导入)
自己随意建立的文件夹是不能作为项目导入的
修改项目问题
不要随意修改项目名称
如果真要修改，不要忘记了配置文件.project中的
把这里改为你改后的名称

9:大家接收文件的注意事项
A:专门建立一个文件夹用于接收项目，不要随意放置。
B:同一个项目再次接收的时候，先去存放目录把原始项目删除，然后重新存储，最后刷新项目即可。
C:每天对照我写的项目，自己也创建一个练习项目
举例：我的项目名称 day11_eclipse
你就创建一个项目名称 day11_eclipse_test

10:Eclipse中代码的高级(Debug)调试
作用：
调试程序
查看程序执行流程

如何查看程序执行流程
    要想看程序流程，就必须设置断点。

    什么是断点：
        就是一个标记，从哪里开始。

    如何设置断点：
        你想看哪里的程序，你就在那个有效程序的左边双击即可。

    在哪里设置断点：
        哪里不会点哪里。
        目前：我们就在每个方法的第一条有效语句上都加。

    如何运行设置断点后的程序：
        右键 -- Debug as -- Java Application

    看哪些地方：
        Debug：断点测试的地方
            在这个地方，记住F6，或者点击也可以。一次看一行的执行过程。
        Variables：查看程序的变量变化
        ForDemo：被查看的源文件
        Console：控制台

    如何去断点：
        a:再次双击即可
        b:找到Debug视图，Variables界面，找到Breakpoints，并点击，然后看到所有的断点，最后点击那个双叉。

八、eclipse中如何生成jar包并导入到新的项目中
1.jar包是什么？
（1）.jar是什么？
jar其实就是多个class文件的压缩包
（2）.jar有什么用？
用别人写好的东西
（3）.打jar包
选中项目–右键–Export–java–jar–自己制定
一个路径和一个名称–Finish
（4）.使用jar包
复制到项目路径下并添加至构建路径

**jar包和说明书一般是配套使用
2.如何制作帮助文档
eclipse中如何制作帮助文档：
（1）.编写源程序（设计接口，抽象类，具体类案例）
（2）.针对源程序添加文档注释
（3）.选中项目–右键–Export–java–javadoc–Finish

3.如何删除和导入项目
1.选中项目–右键–删除
从项目区域中删除（在硬盘上还能找到）
从硬盘上删除

2.导入项目
在项目区域右键找到import
找到General，展开，并找到
Exising Projects into Workspace
点击next，然后选择你要导入的项目
注意，这里选择的是项目名称

导入项目需要注意的问题：
项目区域中不可能出现同名的项目（新建或导入）
自己随意建立的文件夹是不能作为项目导入的

修改项目问题
不要随意修改项目名称
如果真要修改，不要忘记了配置文件.project中的
把这里改为你改后的名称

3.Debug调试
Eclipse中代码的高级Debug调试
作用：
调试程序
查看程序执行流程

如何查看程序执行流程
什么是断点
就是一个标记，从哪里开始
如何设置断点
你想看哪里的程序，就在有效程序的左边双击
在哪里设置断点
哪里不会点哪里。
目前：就在每个方法的第一条有效语句上都加
如何运行设置断点后的程序
右键–Debug as–java application
看那些地方
Debug:断点测试的地方
在这个地方，记住F6，或者点击也可以
variables:查看程序的变量变化
fordemo:被查看的源文件
console:控制台
如何去除断点
1.再次双击
2.找到debug视图，Variables界面，找到BreakPoingts,并点击，
然后看到所有的断点，最后点击那个双叉。

4.eclipse查看java中参数传递问题

/*
    通过断点来看方法的参数传递以及进栈，出栈
*/

public class ArgsDemo{
    public static void main(String[] args){
        int a = 10;
        int b = 20;
        System.out.println("a:"+a+",b:"+b);
        change(a,b);
        System.out.println("a:"+a+",b:"+b);

        int[] arr = {1,2,3,4,5};
        change(arr);
        System.out.println(arr[1]);
    }

    public static void change(int a,int b){
        System.out.println("a:"+a+",b:"+b);
        a = b;
        b = a + b;
        System.out.println("a:"+a+",b:"+b);
    }

    public static void change(int[] arr){
        for(int x = 0; x < arr.length; x++){
            if(arr[x] % 2 ==0){
                arr[x] *= 2;
            }
        }
    }
}
Purple66Calm
关注
专栏目录
2023年11月15号期中测验选择题（Java）
这个博主不懒，但Ta什么也没写~（私信互关24小时必回）
11-19 1265
本篇续接《2023年11月15号期中测验判断题（Java）》->
【Java基础】· 面向对象编程（下）习题详解
麟-小白的博客
10-30 1934
Hello大家好， 我是【麟-小白】，一位软件工程专业的学生，喜好计算机知识。希望大家能够一起学习进步呀！本人是一名在读大学生，专业水平有限，如发现错误或不足之处，请多多指正！！！如果小哥哥小姐姐们对我的文章感兴趣，请不要吝啬你们的小手，多多呀！❤❤❤爱你们！！！目录【面向对象编程（下）知识详解】【Java基础】· 第6章 · 面向对象编程（下）③接口和内部类【Java基础】· 第6章 · 面向对象编程（下）②代码块、final和abstract。
Java静态内部类、匿名内部类、成员式内部类和局部内部类
Love my love
02-11 501
转载网址： Java静态内部类、匿名内部类、成员式内部类和局部内部类  内部类可以是静态(static)的，可以使用 public、protected 和 private 访问控制符，而外部类只能使用 public，或者默认。 成员式内部类 在外部类内部直接定义（不在方法内部或代码块内部）的类就是成员式内部类，它可以直接使用外部类的所有变量和方法，即使是 private
java面向对象基础
liutao43的博客
05-25 382
在java中,除了基本的数据类型,其他的基本都是类, 比如接口,异常等等… 构造函数 和c++类似,构造函数是用来初始化的实例中的字段的,实例就是对象,字段在这里代表的是类中的数据.没有返回值,而且和类名相同. 比如: class Person { private String name; private int age; public Person(String name, int age) { this.name = name; this.age = age; }
Java内部类
Apple-yeran 的博客
11-13 513
内部类1 内部类的含义2 成员内部类3 静态内部类4 局部内部类5 匿名内部类6 练习7 作业 1 内部类的含义 内部类： 把类定义在其他类的内部，这个类就被称为内部类。(类可以嵌套定义，方法不可以嵌套定义) 编译成字节码文件：Outer.class(外部类), Outer$Inner.class(内部类) 为什么需要内部类？ 外部类 内部类 PC -- CPU a. 保护CPU b. 方便PC和CPU的交互 人 心脏
面向对象七大基本设计原则.pdf
10-01
面向对象七大基本设计原则通常是指SOLID原则，它是一组面向对象设计的指导原则，旨在使软件更加可维护和可扩展。SOLID由以下五个原则组成： 1. 单一职责原则（Single Responsibility Principle, SRP）：一个类应该...
面向对象七大原则
10-22
面向对象七大原则 面向对象编程是一种编程范式，它强调模块化、抽象化、封装性、继承性和多态性等特点。面向对象编程的七大原则是指在面向对象设计中所遵循的七个基本原则，它们是：开闭原则、依赖倒转原则、单一...
面向对象七大原则——肖文斌.pdf
10-01
肖文斌在其文件“面向对象七大原则”中详细地探讨了这些原则。 1. 开闭原则（OCP - Open Closed Principle） 开闭原则是指软件实体应当对扩展开放，对修改关闭。这意味着，一旦软件实体被设计并开发完成，应当无需...
Java设计模式-面向对象七大设计原则
最新发布
02-06
例如：随着计算机的不断发展，程序学习这门技术也越来越重要，很多人都开启了...面向对象设计原则一共有七个：开闭原则、里氏替换原则、依赖倒转原则、单一职责原则、接口隔离原则、组合/聚合复用原则、迪米特法则。
面向对象七大设计原则，详细解释版
05-31
详细解释了开闭原则、里氏替换原则、依赖倒置原则、单一职责原则、接口隔离原则、迪米特法则以及合成服用原则，是不可多得的学习资料。
黑马程序员——面向对象——包-修饰符-内部类
hison_lian的博客
05-15 341
一.包 1.包就是文件夹 2.作用： A:用来将同名的文件区分开，方便我们使用 B:将类分别进行管理 a:根据功能进行分类 b:根据开发模块进行分类 3.包的定义 A：package 包名;      B:多级包用.隔开 4.注意事项： A:package语句必须是放在文件中的第一条有效语句 B:在一个java文件中，只能有一个package包 C:没有pack
Java面试题
qq_38274974的博客
03-01 1247
1.jdk与jre的区别？ jdk:java development kit的简称，是Java开发工具，提供了Java的开发环境和运行环境。 jre:java runtime environment的简称，提供了Java的运行环境 实际上，jdk包含了jre 2.一个".java"源文件中是否可以包含多个类(不是内部类)？ 可以有多个类，但必须只有一个public类，而且public类必须与文件名...
面向对象测试题，快来看看自己的掌握程度吧
zx_balabala的博客
07-17 4128
一、选择题（针对以下题目，请选择最符合题目要求的答案。针对每一道题目，所有答案都选对，则该题得分，所选答案错误或不能选出所有答案，则该题不得分。每题2分，共80分。）   1、在方法内定义的变量，描述正确的是（）？ A、一定在方法内所有位置可见 B、可能在方法的局部位置可见 C、在方法外可以使用 D、在方法外可见   2、关于方法的形参，描述正确的是（）？ A、可以没有 B、至...
经典面试题-Thread和Runnable有什么不同？
逍遥云恋
11-16 1106
首先,Java 中Thread 和 Runnable是实现并发线程的两种方式!!!, 通过两者中的任意一个都可以达到线程并发的目的!!! 区别 Thread 是一個 Class,Runnable 是一個 interface!!! 通过extends Thread，可获得start(), sleep(), 并覆盖run(), 使用时直接用start()，但有时不太方便通过继承(extends)而进...
2021-05-21--0515周考
weixin_57795964的博客
05-21 497
一 Java基础（40分，每题2分） 请选这以下代码的输出结果。 Public Base{ Base(){ System.out.println(“Base”); } } public class Checket extends Base{ Checket (){ System.out.println(“Checket”); super(); } public static void main(String args[]){ Checket c= Checket(); ...
Java面向对象练习题含解析（三）
热门推荐
pattyi的博客
04-08 2万+
1、 如果类的成员被（ ）访问控制符来修饰，则这个成员只能被该类的其它成员访问，其它类无法直接访问。1分A、privateB、defaultC、protectedD、public参考答案:A【答案解析】如果类的成员被private访问控制符来修饰，则这个成员只能被该类的其它成员访问，其它类无法直接访问。类的良好封装就是通过private关键字来实现的。2、以下代码执行后的结果是:（ ） public class Person { String name = “小芳”; publi
java 内部类的使用_Java内部类使用总结
weixin_42511990的博客
02-12 122
1．定义内部类是指在一个外部类的内部再定义一个类。内部类作为外部类的一个成员，并且依附于外部类而存在的。内部类可为static，可用public、protected、private修饰。(而外部类不可以：外部类只能使用publi和default)。2．分类在一个类(外部类)中直接定义的内部类(成员内部类)、局部内部类、静态内部类、匿名内部类。3．使用方法A. 在一个类中直接定义的内部类1)...
第一次java基础选择题总结
不爱码字的程序鸽 的博客
02-13 195
a.抽象类是不能与final和static共同使用。 b.最好不要有私有成员变量，因为子类在继承父类的过程中，根本继承不过来私有成员变量和方法。但是抽象类中可以有私有变量。 c 抽象类中可以有非抽象方法，但是抽象方法必须在抽象类中 关于委托事件模型：实现事件对应的事件监听器接口。同时也要想事件源3注册事件监听器对象。这样事件源和事件监听器之间就会建立某种联系。 java中四类8种基本数据类型...
java的语法基础知识_Java基础_基础语法知识10
weixin_42382703的博客
02-16 59
1.形式参数参数类型基本类型，如:int float double引用类型:类:这一个时候参数需要的是一个该类的对象。抽象类:需要的是该抽象的类的子类对象。接口：需要的是该接口的实现类对象。2.返回值类型基本类型:就是一般的基本类型(省略)引用类型:类:需要返回的是该类对象。抽象类:返回的是该抽象类的子类对象。接口:返回的是该接口的实现类的对象。3.链式编程所谓的链式编程实质就是对象调用方法，然后...
提升编程实力：面向对象七大原则与软件复用
面向对象编程是软件开发的核心理念，其成功应用的关键在于遵循一系列基本原则。...因此，掌握和实践面向对象七大原则对于任何开发者来说都是至关重要的，它们是构建高效、可维护和可扩展软件的基石。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值