第一行代码Java课后习题学习

川长思鸟来 2021-11-23 23:58 661阅读 0赞

### 文章目录 ###

*  第1章：Java简介
 *   *  一、填空题
     *  二、选择题
     *  三、判断题
     *  四、简答题
 *  第2章：简单Java程序
 *   *  一、填空题
     *  二、选择题
     *  三、简答题
     *  四、编程题
 *  第3章：面向对象
 *   *  一、填空题
     *  二、选择题
     *  三、判断题
     *  四、简答题
     *  五、编程题
 *  第4章：面向对象\[高级\]
 *   *  一、基础题
     *  二、编程题
 *  第5章: 包以及访问控制权限
 *   *  一、编程题
 *  第6章：异常
 *   *  一、基础题
     *  二、编程题

# 第1章：Java简介 #

## 一、填空题 ##

1、Java源程序文件的后缀是 \*.java，java字节码文件的后缀名称是 \*.class  
2、Java抽象实现可移植性，依靠的是JVM。  
备注：Java实现可移植性考的是JVM，JVM就是一台虚拟的计算机，只要在不同的操作系统上植入不同版本的JVM，那么Java程序就可以在各个平台上移植。  
3、Java语言的三个分支是：JavaSE，JavaME，JavaEE。

*  JavaSE包括构成Java核心的类，比如数据库连接，接口定义，数据结构，输入/输出，网络编程。【核心】
 *  JavaEE就是企业版，包括用于开发企业级应用的类，比如EJB，Servlet，JSP，XML，事务控制。
 *  JavaME用于嵌入式开发。

4、Java语言有类组成，如果Java使用public class声明类，则文件名称必须与类名称一致。  
5、Java执行是从main()方法开始执行的，此方法的完整定义是public static void main(String args\[\])  
6、从命名标准来讲，Java类名的每个单词的首字母通常要求大写。  
7、当使用Java命令解释一个程序时，一定需要classpath环境属性来定位类资源路径。

## 二、选择题 ##

1、Java.exe时用来解释java程序的。Javac.exe是用来编译java程序的。

备注：Java中程序执行步骤：

*  javac将一个\*.java文件编译成\*.class文件
 *  Java执行\*.class文件。

2、calsspath是java解释时需要的。

备注：每次使用java命名执行一个\*.class文件时，都会启动JVM，JVM通过classpath给出的路径加载所需要的类文件，可以通过set classpath设置类的加载文件。

## 三、判断题 ##

1、Java是解释型的开发语言： 通过在不同平台上运行Java解释器，对Java代码进行解释，来实现一次编译，到处运行。

2、JavaApplication程序的入口是main()方法。

## 四、简答题 ##

1、简述Java实现可移植性的基本原理  
答：Java属于编译型和解释型的编程语言，所有的\*.java程序必须编译为\*.class文件之后才能在电脑上执行，而执行\*.class文件的电脑并不是一台真实的电脑，而是利用软件和硬件模拟出来的一台虚拟电脑，称为Java虚拟机，而针对不同的操作系统平台，有不同版本的java虚拟机，即：由Java虚拟机去适应不同的操作系统，即：只要Java虚拟机的支持没有改变，同一个\*.class可以在不同的平台上运行。

2、简述Java语言的三个程序分支  
答：  
JavaSE：提供基础的Java类库以及平台支持  
JavaME：提供嵌入式开发支持  
JavaEE：提供企业平台支持

3、简述Java中path以及classpath的作用  
答：Path是操作系统的环境属性，值得是可以执行命令的程序路径；  
ClassPath：是由\*.class文件的执行路径，Java命令执行的时候将利用此路径加载所需要的\*.class文件

4、简述Java语言的特点：  
答：

*  Java语言是一门面向对象语言，而且语法足够简单
 *  Java避免了C/C++中复杂的指针关系，而且使用了更为简单的引用方式来进行内存传递
 *  Java是为数不多的支持多并发开发的编程语言
 *  Java提供了自动的垃圾收集机制，可以定期释放出无用的垃圾恐吓关键
 *  Java语言的安全性较高
 *  Java具备可移植性，同一个程序在不同的操作系统上都可以运行。

5、简述Java中public class或者class声明一个类的区别以及注意事项  
答：

*  public class声明的类，要求文件名称和类名称保持一致，在一个\*.java文件之中只能存在一个public class
 *  使用class定义的类，文件名称和类名称不一致，在一个\*.java文件之中可以同时存在多个class定义，编译之后会产生多个\*.class文件。

# 第2章：简单Java程序 #

## 一、填空题 ##

1、Java中的标识符组成原则：由字母，数字，下划线，$组成，不以数字开头，不使用关键字  
2、assert关键字在JDK1.4时加入，enum关键字在JDK1.5时加入  
3、java注释分为：单行注释，多行注释，文档注释  
4、在一个Java源文件中定义了3个类和15个方法，编译该Java源文件时会产生3个字节码文件，其扩展名时.class  
5、布尔型数据类型的关键字：boolean  
6、整数型可以采用：byte，short，int，long四种类型展示。  
7、根据占用内存长度的不同，浮点数分为：float和double两种。  
8、在方法中可以使用return来结束方法的执行  
9、void表示不返回任何值

## 二、选择题 ##

1、const，goto是Java的保留关键字  
2、一个java源文件编译之后可能产生多个class文件

## 三、简答题 ##

1、常量和变量的区别：  
答：常量：一个固定的值，用final修饰，只能初始化一次，之后值就不能改变了

final int  a ;
            a = 1;
            
            final  int b =3;

变量：利用声明的方式，将内存中的某个内存保存下来共程序使用，它的值可以改变

2、方法重载？  
答：方法重载就是多个方法的方法名称相同，但是方法中的参数类型以及个数不同

package com.oceanstar.test;
    
    public class chongzai_test {
        
        public static void main(String[] args) {
        
    
        }
    
        static int add(int a, int b){
        
            return  a + b;
        }
    
        static int add(int a, int b, int c){
        
            return  a + b + c;
        }
    
        static double add(double a, double b){
        
            return  a + b;
        }
    }

## 四、编程题 ##

1、打印100-1000的所有“水仙花数”。水仙花数就是一个三位数，其各个数字立方和等于该数本身。如153就是一个水仙花数，因为153 = 1^3 + 5 ^3 + 3 ^3

public class Shuixian_Test {
        
        public static void main(String[] args) {
        
     
            for (int i = 100; i < 1000; i++){
        
                int dd = (int)(Math.pow(i/100, 3) + Math.pow(i%100/10, 3) + Math.pow(i%10, 3));
                if (dd == i){
        
                    System.out.println(i);
                }
            }
        }
    }

结果：

153
    370
    371
    407

2、判断某数能否被3，5，7整除

package com.oceanstar.test;
    
    import java.util.Scanner;
    
    public class Zhengchu_Test {
        
        public static void main(String[] args) {
        
            Scanner in = new Scanner(System.in);
    
            while (true){
        
                System.out.printf("请输入一个整数:");
                int i = in.nextInt();
    
                if ((i%3==0) && (i%5==0) && (i%7==0)){
        
                    System.out.println(i + "能被3,5,7整除");
                }else{
        
                    System.out.println(i + "不能被3,5,7整除");
                }
            }
        }
    }

# 第3章：面向对象 #

## 一、填空题 ##

1、new运算符的作用是根据对象的类型分配内存空间。当对象拥有内存空间时，会自动调用类中的构造方法为对象实例化  
2、构造方法与类名称相同  
3、this关键字可以调用本类中的属性，方法，构造方法，调用构造方法时必须放在构造方法的首行。

## 二、选择题 ##

1、如果类中没有定义构造方法，系统会提供一个默认的构造方法。默认的构造方法既无参数也无任何操作。

## 三、判断题 ##

1、使用static定义的内部类就成为外部类

## 四、简答题 ##

1、string类的操特点  
答：String类的对象有两种实例化方式：

*  直接赋值：开辟一块内存空间，并且对象入池
 *  构造方法：开辟两块内存空间，有一块为垃圾，不会自动入池，除非使用intern方法手动入池

String对象的比较方法

*  == ： 比较两个字符串对象的内存地址数值
 *  equals()：字符串内容比较

2、简述垃圾对象的产生：  
答：垃圾值得是一块无用的引用内存，当将变量设置为null或者长时间不使用时，就将成为垃圾。

3、static方法如何调用？非static方法如何调用  
答：static方法可以使用类名称或者实例化对象调用，而非static方法只能依靠实例化对象才可以调用

4、类和对象的关系是什么？如何创建以及使用对象  
答：类规定了对象所具有的属性和行为，类只有通过产生对象才可以通过分配属性或者调用方法，对象的创建依靠关键字new创建

5、子类对象的实例化过程  
答：当通过关键字new实例化子类对象时，会默认调用父类的无参构造方法，为父类对象实例化，而后才会调用子类的构造方法，为子类对象实例化

6、this和super关键字的区别  
答：this和super都可以调用类中的属性，方法和构造方法，但是this调用的是本类操作，而super是由子类调用父类操作。

## 五、编程题 ##

1、统计n在“anbuisgyucd ”中出现的次数

package com.oceanstar.test;
    
    public class AlfCount {
        
        public static void main(String[] args) {
        
            String str = "want you to know noe thing";
    //        System.out.println(str.indexOf("n"));  //第一次出现的下标
    //        System.out.println(str.substring(2)); // 从第2个字符开始替换
            System.out.println(count(str, "w"));
            System.out.println(count(str, "g"));
    
            System.out.println(count_2(str, 'w'));
        }
    
        static int count_2(String str, char a){
        
            int sum = 0;
            while (str.indexOf(a)  != -1){
        
                sum ++;
                str = str.substring(str.indexOf(a) + 1);
            }
            return sum;
        }
        static int count(String str, String a){
        
            int length1 = str.length();
            return str.length() -  str.replaceAll(a, "").length();
        }
    }

# 第4章：面向对象\[高级\] #

## 一、基础题 ##

1、方法重载与覆写的区别  
方法重载：发生在一个类里面；方法覆写发生在继承关系中  
方法重载：方法名称相同，参数的类型以及个数不同；  
方法覆写：方法名称相同，参数的类型以及个数相同，返回值相同。  
方法重仔：没有权限的限制；方法覆写：被覆写的方法不能拥有比父类更为严格的访问控制权限。

2、Object类是所有类的父类，该类中判断两个对象是否相等的方法是：public boolean equal(Object oth)，取得对象完整信息的方法是: public Striing toString()

3、接口中所有方法都是抽象的；一定是public类型。

4、this和super都可以调用类中的属性、方法、构造方法，但是this调用的是本类操作，而super是子类调用父类操作。

5、子类使用extends继承父类或者使用implements实现多个接口，子类可以继承父类中的全部内容，但是对于私有操作属于隐式继承，而非私有操作属于显式继承。

6、什么是多态？  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70]

7、接口右全局常量和抽象方法组成，一个类可以同时实现多个接口，在Java中使用interface定义接口，子类使用implement实现接口

8、接口和抽象类有哪些区别  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70 1]

10、在JDK1.5之后，基本数据类型可以采用直接赋值的方法为包装类进行对象的实例化操作，而包装类的对象可以通过直接赋值的方式变回基本数据类型

## 二、编程题 ##

1、定义一个ClassName接口，接口中只有一个抽象方法getClassName()。设计一个类Company，该类实现接口ClassName中的方法getClassName()。功能是获取该类的类名称，编写应用程序使用Company类。

package com.oceanstar.test_2;
    
    public class Data_test11 {
        
        public static void main(String[] args) {
        
            Company com = new Company();
            System.out.println(com.getClassName());
        }
    }
    
    interface ClassName{
        
        public String getClassName();
    }
    
    class Company implements ClassName{
        
        @Override
        public String getClassName() {
        
            return "Company";
        }
    }

2、定义一个人类Person()和学生类Student：

*  Person中包含四个保护型的数据成员name（string）、address（string）、sex（char）、age（int）。一个四参构造方法，一个无参构造方法，以及一个输出方法用于显示四种属性。
 *  Student继承Person，并增加输出成员math，english用于存放数学英文成绩。一个六参构造方法，一个两参构造烦烦烦，一个无参构造方法。重写输出方法用于显示全部六种属性。

package com.oceanstar.test_2;
    
    public class Data_test12 {
        
        public static void main(String[] args) {
        
            Student stu = new Student("oceanstar", "北京", 'w', 18, 150, 150);
    
            System.out.println(stu.toString());
            System.out.println(stu.getSex());
        }
    }
    
    class Person{
        
        private  String name;
        private String address;
        private char  sex;
        private int age;
    
        public Person(){
        
    
        }
    
        public Person(String name, String address, char  sex, int age) {
        
            this.name = name;
            this.address = address;
            this.sex = sex;
            this.age = age;
        }
    
        @Override
        public String toString() {
        
            return "Person{" +
                    "name='" + name + '\'' +
                    ", address='" + address + '\'' +
                    ", sex='" + sex + '\'' +
                    ", age=" + age +
                    '}';
        }
    
        public String getName() {
        
            return name;
        }
    
        public void setName(String name) {
        
            this.name = name;
        }
    
        public String getAddress() {
        
            return address;
        }
    
        public void setAddress(String address) {
        
            this.address = address;
        }
    
        public char  getSex() {
        
            return sex;
        }
    
        public void setSex(char  sex) {
        
            this.sex = sex;
        }
    
        public int getAge() {
        
            return age;
        }
    
        public void setAge(int age) {
        
            this.age = age;
        }
    }
    
    class Student extends  Person{
        
        private double math;
        private double english;
    
        public Student() {
        
        }
    
        public Student(double math, double english) {
        
            this.math = math;
            this.english = english;
        }
    
        public Student(String name, String address, char  sex, int age, double math, double english) {
        
            super(name, address, sex, age);
            this.math = math;
            this.english = english;
        }
    
        @Override
        public String toString() {
        
            return "Student{" +
                    "math='" + math + '\'' +
                    ", english='" + english + '\'' +
                    "} " + super.toString();
        }
    
        public double getMath() {
        
            return math;
        }
    
        public void setMath(double math) {
        
            this.math = math;
        }
    
        public double getEnglish() {
        
            return english;
        }
    
        public void setEnglish(double english) {
        
            this.english = english;
        }
    }

3、定义员工类，具有姓名，年龄，性别属性，并具有构造方法，显示数据方法；定义管理层类，继承员工类；并有自己的属性：职务，年薪。定义职员类，继承员工类，并由自己的属性：所属部门，月薪。

package com.oceanstar.test_2;
    
    public class Data_test13 {
        
        public static void main(String[] args) {
        
            Manager man = new Manager("manage", 20, 'w', "CEO", 2000000.0);
            Staff sta = new Staff("staff", 18, 'w', "研发",  180000);
    
            System.out.println(man);
            System.out.println(sta);
        }
    }
    
    class Employee{
        
        private String name;
        private int age;
        private char sex;
    
        public Employee(){
        
    
        }
    
        public Employee(String name, int age, char sex) {
        
            this.name = name;
            this.age = age;
            this.sex = sex;
        }
    
        public String getName() {
        
            return name;
        }
    
        public void setName(String name) {
        
            this.name = name;
        }
    
        public int getAge() {
        
            return age;
        }
    
        public void setAge(int age) {
        
            this.age = age;
        }
    
        public char getSex() {
        
            return sex;
        }
    
        public void setSex(char sex) {
        
            this.sex = sex;
        }
    
        @Override
        public String toString() {
        
            return "Employee{" +
                    "name='" + name + '\'' +
                    ", age='" + age + '\'' +
                    ", sex='" + sex + '\'' +
                    '}';
        }
    }
    
    
    class Manager extends Employee{
        
        private String job;
        private double incom;
    
        public Manager() {
        
    
        }
    
    
        public Manager(String name, int age, char sex, String job, double incom) {
        
            super(name, age, sex);
            this.job = job;
            this.incom = incom;
        }
    
        public String getJob() {
        
            return job;
        }
    
        public void setJob(String job) {
        
            this.job = job;
        }
    
        public double getIncom() {
        
            return incom;
        }
    
        public void setIncom(double incom) {
        
            this.incom = incom;
        }
    
        @Override
        public String toString() {
        
            return "Manager{" +
                    "job='" + job + '\'' +
                    ", incom=" + incom +
                    "} " + super.toString();
        }
    }
    
    class Staff extends Employee{
        
        private String dept;
        private double salary;
    
        public Staff() {
        
        }
    
        public Staff(String name, int age, char sex, String dept, double salary) {
        
            super(name, age, sex);
            this.dept = dept;
            this.salary = salary;
        }
    
        @Override
        public String toString() {
        
            return "Staff{" +
                    "dept='" + dept + '\'' +
                    ", salary=" + salary +
                    "} " + super.toString();
        }
    
        public String getDept() {
        
            return dept;
        }
    
        public void setDept(String dept) {
        
            this.dept = dept;
        }
    
        public double getSalary() {
        
            return salary;
        }
    
        public void setSalary(double salary) {
        
            this.salary = salary;
        }
    }

4、定义类Shape表示一般二维图形。Shape具有抽象方法area和perimeter，分别计算形状的面积和周长。试定义一些二维形类\[如矩形，三角形，圆形等\]，这些类均为Shape类的子类

package com.oceanstar.test_2;
    
    public class Data_test14 {
        
        public static void main(String[] args) {
        
            Shape rec = new Rectangle(10.5, 20.6);
            System.out.println("矩形：" + rec.area() +  "  ----- " +  rec.permeter());
    
    
            Shape tri = new Triangle(3, 4, 5);
            System.out.println("三角形：" + tri.area()  +  "  ----- " +  tri.permeter());
    
            Shape round = new circular(30.3);
            System.out.println(round.area() + "---------- " + round.permeter());
        }
    }
    
    
    abstract class Shape{
        
        abstract public double area();
        abstract public double permeter();
    }
    
    class Rectangle extends Shape{
        
        private double length;
        private double width;
    
        public Rectangle(){
        
    
        }
    
        public Rectangle(double length, double width) {
        
            this.length = length;
            this.width = width;
        }
    
        @Override
        public double area() {
        
            return this.length * this.width;
        }
    
        @Override
        public double permeter() {
        
            return (this.length + this.width) * 2;
        }
    }
    
    class Triangle extends Shape{
        
        private double egea;
        private double egeb;
        private double egec;
    
        public Triangle() {
        
    
        }
    
    
        public Triangle(double egea, double egeb, double egec) {
        
            this.egea = egea;
            this.egeb = egeb;
            this.egec = egec;
        }
    
        @Override
        public double area() {
        
            double p = this.permeter() / 2 ;
            double temp = p * (p - egea) * (p - egeb) * (p - egec);
    
            if (temp <  0){
        
                System.out.println("不能构成三角形");
                return -1.0;
            }
            return Math.sqrt(p * (p - egea) * (p - egeb) * (p - egec));
        }
    
        @Override
        public double permeter() {
        
            return this.egea + this.egeb + this.egec;
        }
    }
    
    class circular extends Shape{
        
        private double radius;
        private final double PI = 3.14;
    
    
        public circular(double radius) {
        
            this.radius = radius;
        }
    
        @Override
        public double area() {
        
            return PI * radius * radius;
        }
    
        @Override
        public double permeter() {
        
            return 2 * PI * radius;
        }
    }

# 第5章: 包以及访问控制权限 #

## 一、编程题 ##

1、单例设计模式的特点：构造方法被私有化，只能通过getInstance方法取得Singleton类的实例化对象，这样不管外部如何操作，最终只有一个实例化对象，在单例设计模式中，一定会存在一个static方法，用于取得本例的实例化对象

package com.oceanstar.test_2;
    
    public class Singleton_test2 {
        
        public static void main(String[] args) {
        
            Singleton_2.instance.print();
            System.out.println(Singleton_2.getInstance());
            System.out.println(Singleton_2.getInstance());
        }
    }
    
    class Singleton_2{
        
        static final Singleton_2 instance = new Singleton_2(); // 因此智能在内部实例化本类对象；如果要想在外部调用，
        // final 只允许定义一次，要不然就不是单例对象设计。
        // static 定义的属性特点是由类名称直接调用，并且在没有实例化对象是就可以调用
    
        private Singleton_2(){
          // 构造方法私有化
    
        }
        public void print(){
        
            System.out.println("hello world");
        }
    
        public static Singleton_2 getInstance() {
        
            return instance;
        }
    
    }

2、多例设计模式：单例设计模式只流下一个类的实例化对象，而多例设计模式，只会定义出多个对象。例如：定义一个表示星期的操作类，这个类的对象只能有7个实例化对象(星期一~星期日)；定义一个表示性别的类，只能由两个表示实例化的对象(男，女)。这种情况下，这样的类就不应该由用户无限制的去常见实例化对象，应该只使用几个，这个就是多例设计。不管是单例设计还是多例设计，有一个核心不可动摇，即构造方法私有化。

package com.oceanstar.test_2;
    
    public class Sex_test {
        
        public static void main(String[] args) {
        
            Sex sex = Sex.getInstance("man");
            System.out.println(sex);
        }
    }
    
    class Sex{
        
        private String title;
        private static final Sex MALE = new Sex("男");
        private static final Sex FEMALE = new Sex("女");
    
        private Sex(String title){
        
            this.title = title;
        }
    
        public String getTitle() {
        
            return title;
        }
    
        @Override
        public String toString() {
        
            return "Sex{" +
                    "title='" + title + '\'' +
                    '}';
        }
    
        public static Sex getInstance(String ch){
        
            switch (ch){
        
                case "man":
                    return MALE;
                case "woman":
                    return FEMALE;
                default:
                    return null;
            }
        }
    }

# 第6章：异常 #

## 一、基础题 ##

1、异常时导致程序终端运行的一种指令流，当异常发生时，如果没有进行良好的处理，则程序将会中断执行

2、异常的最大父类是Throwable，其分为两个子类：Exception、Error。Exception表示程序处理的异常，而Error表示JVM错误，一般不是由程序开发人员处理的。

3、发生异常之后，JVM会自动产生一个异常类的实例化对象，并匹配相应的catch语句中的异常类型，也可以利用对象的向上转型关系，直接捕获exception

4、throws用在方法声明处，表示本方法不处理异常；throw表示在方法中手工抛出一个异常。

5、自定义异常类时，只需要继承Exception类或者RuntimeException类。

## 二、编程题 ##

1、编写应用程序，从命令行输入两个小数参数，求商

package com.oceanstar.test3;
    
    public class try_test2 {
        
        public static void main(String[] args) {
        
            if (args.length != 2){
        
                System.out.println("参数错误");
                System.exit(1);
            }
            try {
        
                System.out.println(MyMath_Test.div(args[0], args[1]));
            }catch (Exception e){
        
                e.printStackTrace();
            }
        }
    }
    
    
    class MyMath_Test{
        
        public static int div(String x, String y)throws Exception{
        
            System.out.println("计算开始：");
            int result;
            try {
        
                int numa = Integer.parseInt(x);
                int numb = Integer.parseInt(y);;
                result = numa / numb;
            }catch (Exception e){
        
                throw e;
            }finally {
        
                System.out.println("计算结束");
            }
            return result;
        }
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70]: /images/20211122/3e0aa99fe7e14733ba1532b11a0e7a90.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poaXpoZW5nZ3Vhbg_size_16_color_FFFFFF_t_70 1]: /images/20211122/b2babb57e3c04397a75cca048c4d794e.png