栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

JAVA期末

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

JAVA期末

JAVA 复习资料 Java语言的特点(选择题、判断题)
  • 简单、面向对象、与平台无关、多线程、动态
标识符命名规则。(选择题、判断题)
  • 由字母、下划线、美元符号、数字组成
  • 第一个字符不能是数字
  • 标识符不能是关键字;不能是truefalsenull
开发与运行Java程序的三步骤(简答题)
  • 编写源文件:使用文本编辑器编写源文件。将编写好的源文件保存,源文件的扩展名必须是.java
  • 编译源文件:使用Java编辑器(javac.exe)编译源文件,得到字节码文件(扩展名是.class)
  • 运行程序:使用Java SE平台中的Java解释器(java.exe)来解释,执行字节码文件
java程序文件名命名规则(java源程序文件名与应用程序类名),及文件扩展名(选择题)、main方法(选择题、判断题)、主类
  • 源文件中可以有多个类,但最多一个类是public类
  • 如果源文件中有public,源文件名必须要和public类的名字完全相同;如果源文件中没有public类,源文件名只需要和某个类的名字相同
  • 源文件的扩展名是.java;字节码文件扩展名是 .class
  • 一个Java应用程序中必须有且仅有一个类含有main方法(public static void main(Sting args[]),称这个类为主类
整型(十进制、八进制、十六进制)合法常量的表示方法、字符型常量(单个字符、字符串常量)的表示方法、实型合法常量的表示方法。字符采用的编码(选择题、判断题)。
  • 整型常量:
    • 十进制:无前缀
    • 八进制:0做前缀
    • 十六进制:0x或0X做前缀
  • 字符型常量:
    • 单个字符:用单引号’ ’括起来
    • 字符串常量:用双引号" "括起来
  • 实型合法常量:
    • float:必须要有后缀f或F,存储时保留8位有效数字
    • double:可以有后缀d或D,存储时保留16位有效数字
  • 字符采用ASCII编码
混合数据类型运算的表达式求值:(选择题、判断题、阅读程序) 掌握教材提到的常用运算符的运算规则,以及运算对象(如 %、/ 、逻辑运算符&&和||等)的特殊要求,包括复合赋值运算符(+=,-=,*= 等)
 逻辑运算符:
 +、-、*、/;
 a+=b;//a=a+b;
 a-=b;//a=a-b;
 自增:a++(执行完代码后,再自增,即先用后加) a=a+1
     ++a(执代码前,先自增,即先加后用)
 自减同理a--、--a
 幂运算:需要用工具函数来执行;

 位运算符:
     &&(与)、||(或)、!(非)
    - a&&b 与运算 有假为假
    - a||b 或运算 有真为真
    - !a、!b 非运算 假为真,真为假
    - !(a&&b)异或运算 同号为假,异号为真

 短路运算:当*与运算*时,若靠左的逻辑运算若为假,则不继续走右边逻辑运算,直接结束运算。
 A=0011 1100
 B=0000 1101
 -----------------------------
 A&B 0000 1100(都为1则为1,有一个非1为0);
 A|B 0011 1101(都为0则为0,存在一个1直接为1);
 A^B 0011 0001(相同为0,不同为1);
 ~B 1111 0010(取反)
 2<<3 2左移3位 0000 0010->0001 0000 则结果为16
 >>右移除二
 <<左移乘二
 三元运算符
 //? :
 //x?y:z   (如果x==true,则结果为y,否则为z)
数据类型转换:自动转换条件、以及何种情况下需要强制转换与语法格式
  • 自动转换条件:低精度转高精度

  • 强制转换:高精度转低精度

  • 强制转换语法格式:(类型名)要转换的值 例如:int x=(int)34.98

  • 不能把一个高精度的变量直接赋值给低精度变量,因为编译器只会检查变量的类型而不是变量的值 例如有int x=1;byte y;不能y=x,必须y=(byte)x

  • 注意点::

    • 不能对布尔值(boolean,只能为其变量赋值true和false)进行转换
    • 不能把对象类型转换为不相干的类型
    • 高容量转换为低容量的时候强制转换可能内存溢出或者精度问题。
    //强制转换:
    int i=128;
    byte b=(byte)i;

    //自动转换:
    int i=128;
    double b=i;
条件运算符的使用
  • 加减运算符、乘除求余运算符、自加自减运算符、关系运算符、逻辑运算符、赋值运算符、位运算符、intanceof运算符(二目运算符,左边是一个对象,右边是类,当左边的对象是右边的类或者子类创建的对象的时候,返回true,否则false)
掌握分支结构与循环结构程序设计(选择题、程序阅读题、编程题)

(1)if语句、if~else语句 
(2)switch语句

  • switch后面的表达式的值不能是long型
  • 表达式的值和case常量值匹配,匹配成功则执行当中的语句,直到遇到break语句;如果没遇到break,则进行下一个匹配
  • 如果表达式的值不与任何一个case常量值相等,则执行default语句,default语句也可以没有,default语句可以在任意位置

(3)循环语句的结构(for、while、do-while)

  • while与do-while的区别:do-while至少执行一次

(4)break和continue语句return语句使用的用法。

  • break被执行,整个循环结束,不再执行循环语句
  • continue被执行,本次循环结束,进入下一次循环
  • return返回某个值
    (5)以及它们的组合使用。
一维数组的定义与使用;二维数组的定义与使用;数组元素的访问
  • 一维数组声明:
    • 1.类型 数组名[](int a[])
    • 2.类型 [] 数组名(int [] a)
 int[]nums;//首选声明类型
 int nums2[];//C语言风格 
 nums=new int[10];//创建一个数组
 int [] num=new int [10];//创建与声明相结合
 int [] numbers={10,20,30,40,50};//定义数组:
  • 二维数组声明:
    • 1.类型 数组名[][](int a[][])
    • 2.类型 [][] 数组名(int [][] a)
  • 一次声明多个数组:
    • 类型 [] 数组名1,数组名2(声明两个数组a,b:int [] a,b)
  • 一维数组分配元素:数组名=new 类型[个数](a=new int[3])
  • 二维数组分配元素:数组名=new 类型[一维个数][二维个数](a=new int[2][3])
  • 创建数组(声明并分配元素):如:int a[][]=new int[3][2]
  • 数组初始化:如float a[]={21.f,34.23f,56,78f,90,12f}
  • 数组属于引用型变量
Java面向对象编程 掌握类的定义(成员变量、成员方法和构造方法)和使用,对象创建
  • 成员变量:成员变量有默认值:
    • 成员变量=属性=field(字段)
    • 属性是类的一个组成部分,一般是基本数据类型,也可以是引用类型(对象、数组)
    • 属性的定义语法同变量: 访问修饰符 属性类型 属性名;
    • 对于boolean变量,默认值是false;
    • 对于 byte short、int 和long 变量,默认值是0;
    • 对于char 变量,默认值是’’(空宇符);
    • 对于float和double 变量,默认值是0.0;对于“引用型”变量,默认值是null
  • 成员方法:
    1.成员方法(实例方法)内声明的变量是局部变量;
    2.方法内声明的局部变量如果与成员变量的名字相同,那么成员变量被隐藏
  • 构造方法:
    1.构造方法没有返回值
    2.构造方法的名字与类名一样
    3.构造方法名可以一样,但必须参数类型或者参数个数不同(重载)
    4.如果类中没有编写构造方法,那么系统会给一个默认的构造方法
  • 对象:
    1.创建:类名 对象名=new 类名()
    2.对象属于引用型变量,存放的是引用值;创建对象分为声明和分配内存
    3.对象可以调用类中的方法、自己的变量
实例变量与局部变量的区别(简答题)
属性局部变量
有默认值,可以不赋值直接使用无默认值,必须赋值在使用
可以被本类使用,或其它类使用(通过对象调用)只能在本类中对应的方法中使用
可以加修饰符不可以加修饰符
可以重名,访问时准寻就近原则在同一个作用域中比如在同一个成员方法中,两个局部变量不能重名
生命周期较长,伴随着对象的创建而创建,伴随着对象的销毁而销毁生命周期较短,伴随着他的代码块的执行而创建,伴随着代码块的结束而销毁
  • 实例变量(成员变量)在类体内方法外声明,与对象共存亡,在类中有效,有默认值,通过(对象名+.)访问
  • 局部变量在方法内声明,与方法共存亡,在方法内有效(且与在方法内的位置有关),没有默认值,可以直接访问
类与对象的关系(简答题)
  • 用类声明的变量被称为对象。在用类声明对象后还必须创建对象,即为对象分配所拥有的变量。类是创建对象的模板,没有类就没有对象
package与import的用法(选择题、判断题)
  • package语句:package 包名(包名可以是一个合法的标识符,也可以是若干个标识符加上”.”分隔而成;有包名的类的存储目录必须包含包名)
  • import语句:表示引入一个包中的所有类,但可能会增加编译的时间
方法的调用与参数传递,参数传递的方法(值传递与引用传递)(选择、程序阅读题)
  • 参数传递
  1. 值传递:向该参数传递的值的级别不可以高于该参数的级别,比如不可以向一个int型参数传递一个float值

  2. 引用传递:传递的是变量中的引用

    • 基本数据类型赋值(值拷贝)
    int n1=10;
    int n2=n1;
    n2=80;
    //输出n1为10;n2为80;
    //n2的变化不会影响n1的值
    
    • 数组引用传递(地址拷贝)
    int[] arr1={1,2,3};
    int[] arr2=arr1;
    //赋的是一个地址,arr2的变化会影响到arr1
    arr2[0]=10;
    //输出的arr1为 10 2 3
    
this与super的各自作用(简答题,阅读程序题)
  • this
    1.构造方法中使用,代表使用该构造方法所创建的对象
    2.实例方法中使用,代表正在调用该方法的当前对象
  • super
    1.用super操作子类隐藏的继承的成员变量和方法
    2.用super调用父类的构造方法
  • super注意点:
    • super调用父类的构造方法,必须在构造方法的第一个/第一行
    • super必须只能出现在子类的方法或者构造方法中。
    • super和this不能同时调用构造方法,因为this()也只能放在构造器的第一行
  • super和this的区别:
    • 代表的对象不同
      • this:本身调用者这个对象
      • super:代表父类对象的应用
    • 前提
      • this:没有继承也可以使用
      • super:只能在继承条件才能使用
    • 构造方法:
      • this():本类的构造
      • super():父类的构造
类的访问修饰符有哪些(选择题、判断题)
  1. 公开级别 public 对外公开
  2. 受保护级别 protected 对子类和同一个包中的类公开
  3. 默认级别 没有修饰符号 向同一个包的类公开
  4. 私有级别 private 只有类本身可以访问,不对外公开
    访问修饰符的访问范围:

注意事项

  • 修饰符可以用来修饰类中的属性,成员方法以及类
  • 只有默认和public才能修饰类,并且遵循上述访问权限的特点
  • 成员方法的访问规则和属性完全一样
类的私有成员和公共成员
  • 类的私有成员只供本类调用(当声明了一个私有成员变量时,但可以通过public方法来修改它的属性)
  • 类的公共成员,可以被任何类调用
成员的访问修饰符:private、protect、public、缺省修饰符,它们的访问权限各是什么(选择题、判断题)
  • private:本类
  • protected:本类、同包类、不同包的子类
  • public:所有类
  • 缺省修饰符:本类、同包类
方法的重载的格式 (选择题、判断题)
  • 参数个数不同或者参数个数相同但是参数类型不同
构造方法的作用与定义,构造方法的重载与调用(选择题、判断题,程序阅读题)
  • 是类的一种特殊方法,作用是完成对新对象的初始化,并不是创建对象。

基本语法:

[修饰符]方法名(形参列表){ 
    方法体;
    }
  • 参数列表和成员方法一样的规则

  • 构造器的修饰符可以默认,也可以是public、protected、private

  • 构造器必须和类的名字相同

  • 必须没有返回类型,也不能写void

  • 构造器的调用,由系统完成

  • 一旦定义了自己的构造器,默认的构造器就覆盖了,就不能再使用默认的无参构造器,除非故意的定义声明一下,即: Person(){}

  • 如果没有定义构造器,系统会自动给类生产一个默认无参构造器
    对象的创建和使用:

  • 必须使用new 关键字创造对象,设构造器 person mosun

    • 对象的属性 mosun.name
    • 对象的方法 mosun.run()
//构造器实例化初始值
//使用new关键字,必须要有构造器,本质是在调用构造器
//用来初始化值
//对象属性:字段field 成员变量
//默认初始化:
// 数字:0 0.0
// char:u0000
// boolean:false
// 引用类型:null
public Student(){
    this.name="mosun"//没实例化之前类的对象为null

}
//有参构造(alt+insert默认生成有参):
public Person(String name){
    this.name=name;
}
//================================================
public class pet {
    public String name;
    public int age;
    public void shout(){
        System.out.println("汪了一声");
    }
}
public class 使用类 {
        public static void main(String[] args) {
            pet dog = new pet();

            dog.name="messi";
            dog.age=3;
            dog.shout();
            System.out.println(dog.name);
            System.out.println(dog.age);
        }
        //输出汪了一声
        //messi
        //3

    }

构造器重载:eg: 两个Person构造器,一个指定人名和年龄,一个只指定人名

class Person{
    String name;
    int age;
    public Person(String pName,int pAge){//指定人名和年龄
        name=pName;
        age=pAge;
    }
    public Person(String pName){//只指定人名
        name=pName;
    }
}
静态成员变量和静态成员方法的使用 (选择题、判断题,程序阅读题)
  • 声明成员变量时,用static修饰的称为静态成员变量(类变量)
    1.所有对象共享类变量,也就是说改变一个对象的类变量其他对象的这个类变量也会改变,而每个对象的实例变量不同
    2.也可以通过类名直接访问类变量
  • 加static修饰的方法是类方法
    1.类方法不可以操作实例变量
    2.类方法要通过类名调用,不能通过对象调用

类方法发也叫静态方法

  • 形式:访问修饰符 static 数据返回类型 方法名(){}

  • 调用(满足访问修饰符的访问权限和范围):类名.类方法名或者对象名.类方法名

  • 类方法和普通方法都是随着类的加载而加载,将结构信息存储在方法区:类方法中无this的参数(this代表当前对象,而static表示对象的共享,因此不能存在this在静态方法中)

    • 普通方法中隐含着this参数
    • 类方法中不允许使用和对象有关的该句子(this、super等)普通方法可以
  • 普通方法和对象有关,需要通过对象名调用,不能通过类名调用

  • 静态方法(类方法)只能访问静态变量或者静态方法

  • 普通成员方法既可以访问非静态成员也可以访问静态成员

继承与多态的概念(简答题)
  • 继承:一种已有的类创建新类的机制
  • 多态:父类的某个方法被其子类重写时可以各自产生自己的功能行为
子类的创建(注意,在子类构造方法中自动调用父类构造方法),上转型对象(程序阅读题)
  • 先调用父类的某个构造方法,再调用组合类的构造方法,最后调用子类自己的构造方法
  • 上转型对象
    1. 不能调用子类新增的成员变量和方法
    2. 不能调用子类重写的static方法
    3. 不能调用隐藏的方法
方法的重载与重写(也称为覆盖)的区别(简答题)
  • 重载:只看参数(参数类型或者个数不同)(返回类型和参数名字不参与比较)
  • 重写:只有方法体不同(返回类型,方法名,参数都相同)
抽象类的定义
  • 关键字abstract修饰
  • 抽象类中可以有抽象方法也可以没有
  • 抽象方法只允许声明,不允许实现,也就是没有方法体
  • 抽象类不能用new标识符创建对象
  • 如果一个非抽象类是抽象类的子类,那它必须重写父类的抽象方法;如果一个抽象类是抽象类的子类,那可以重写或者继承父类的抽象方法
接口与接口的实现,利用接口实现多重继承

接口(特殊的抽象)就是给出一些没有实现的方法,封装到一起,到某个类到使用的时候,再根据具体情况把这些方法发写出来

  • 语法:

    interface 接口名{
      //属性
      //方法(1. 抽象方法 2.默认实现方法 3.静态方法)
    }
    class 类名 implements 接口{
      自己属性;
      自己方法;
      必须实现的接口的抽象方法
    }
    
  • 如果一个类implements(实现)接口,需要将该接口的所有抽象方法都实现

  • 接口不能被实例化,不能被使用

  • 接口中所有的方法都是public方法,接口中抽象方法,可以不用abstract修饰

  • 一个普通类实现接口,就必须将该接口的所有方法都实现

  • 抽象类实现接口时,可以不用实现接口的方法

  • 一个类可以同时实现多个接口

  • 接口中的属性,只能是final,而且是public static final修饰符

    • 比如 int a=1;实际上是 public static final int a=1;
  • 接口中属性的访问形式:接口名.属性名

  • 一个接口不能继承其他的类,但是可以继承多个别的接口

  • 接口的修饰符只能是public和默认(和类的修饰符一样)

  • 接口与继承

    • 继承满足is-a关系,接口只需满足like-a关系
    • 当子类继承了父类,就自动的拥有父类的功能
    • 如果子类需要拓展功能,可以通过实现接口的方式拓展
    • 可以理解实现接口是对java单继承机制的一种补充
  • 接口在一定程度上实现代码解耦(即接口规范性+动态绑定)

接口与抽象类的区别(简答题)
  • 接口中只有常量而没有变量,抽象类中都可以有
  • 抽象类强调的是继承关系和代码复用,而接口是针对一个行为的实现
程序对错误与异常的处理方式,异常处理的基本结构try-catch-finally使用,throw和throws的使用及各自的作用(选择题、判断题, 程序阅读题)

异常:将程序执行中发生的不正常情况称为异常(语法错误和逻辑错误不是异常)

  • 执行过程中发生的异常事件可分为两类

    • Error(错误):JAVA虚拟机无法解决的致命严重问题
    • Exception(异常):其他因编程错误或偶然的外在因素导致的一般性问题,可以使用针对性的代码进行处理
      • 运行时异常:程序运行时发生的异常(编译器检测不出来)
      • 编译时异常:编写程序时,由编译器检测出的异常
  • 为保证程序的健壮性,如果程序员认为一段代码出现异常/问题,可以使用try-catch异常处理机制来解决

    • 如果程序出现了异常,程序仍然可以继续执行
          int num1=10,num2=0;
          int res= 0;
    //    res = num1/num2;//分母为0,会报错导致执行失败(运行时异常)
          try {
              res = num1/num2;//选定指定代码后快捷键Ctrl+alt+t,选择try/catch
          } catch (Exception e) {
              e.printStackTrace();
              System.out.println(e.getMessage());//输出异常信息:/ by zero
          }
    
    • 常见的运行时异常:
      • NullPointerException空指针异常:当应用程序试图在需要对象的地方使用null时,抛出该异常
      • ArithmeticException数学运算异常:当出现异常的运算条件时,抛出该异常(例如一个数除以0)
      • ArrayIndexOutOBoundsException数组下标越界异常:用非法索引(索引为负或大于等于数组大小) 访问数组时抛出的异常
      • ClassCastException类型转换异常:当试图将对象强制转换为不是实例的子类时,抛出该异常
      • NumberFormatException数字格式不正确异常:当应用程序试图将字符串转换成一种数值类型,但该字符串不能转换为适当格式时(比如将mosun字符串转成整数时,Inerger.parseInt(“mosun”)),抛出该异常
  • try catch处理机制:程序员在代码中捕获发生的异常,自行处理

    try{
      代码(可能有异常)
    }catch(Exception e){
      //捕获到异常
      //当异常发生时,系统将异常封装成Exception对象e,传递到catch
      //得到异常对象后,程序员自己处理异常
    }finally{//可以没有
      //不管try代码块是否有异常发生,始终要执行finally
      //所以通常将释放资源的代码放在finally上面
    }
    
    • 如果异常发生了,则异常发生后面的代码不会被执行,直接进入到catch块

    • 如果异常没有发生,则顺序执行try的代码块,不会进入到catch

    • 如果希望不管是否发生异常,都执行某段代码(比如关闭连接、释放资源等)则可使用finally

    • 可以进行try-finally 配合使用,这种用法相当于没有捕获异常,因此程序会直接崩掉。

      • eg:执行一段代码,不管是否发生异常,都必须执行某个业务逻辑
      try{
        //代码
      }finally{
        //总是执行
      }
      
    • 可以有多个catch语句,捕获不同的异常(进行不同的业务处理),要求父类异常在后,子类异常在前,比如(Exception在后,NullPointerException在前),如果发生异常,只会匹配一个catch

    //try catch举例:
        public static void main(String[] args) {
          //如果输入的不是整数,提示反复输入,直到输入整数
          Scanner scanner=new Scanner(System.in);
          int num=0;
          while (true){
              System.out.println("请输入一个整数");
              try {
                  Integer.parseInt((scanner.next()));//可能抛出异常
                  break;//如果没有抛出异常则break该循环,因为若抛出异常了,则异常发生后面的代码不会被执行,直接进入到catch块
              } catch (NumberFormatException e) {
                  System.out.println("输入的不是整数,请重新输入");
              }
          }
      }
    
  • throws处理机制:将发生的异常抛出,交给调用者(方法)来处理,最顶级的处理者是JVM

    • 如果一个方法(中的语句执行时)可能生成某种异常,但是并不能确定如何处理这种异常,则此方法应显示地声明抛出异常,表明该方法将不对这些异常进行处理,而由该方法地调用者负责处理
    • 在方法声明中用throws语句可以声明抛出异常地列表,throws后面地异常类型可以是方法中产生的异常类型,也可以是它的父类
    • 子类重写父类方法时,对抛出异常的规定:子类重写的方法,所抛出的异常类型要么和父类抛出的异常一致,要么为父类抛出的异常的类型的子类型
    • 在throws过程中,如果有方法try-catch,就相当于处理异常,就可以不必throws
    public void method() throws Exception1,Exception2,...,ExceptionN{
      //可能产生异常的代码
    }
    
程序阅读题的考查模式:

1、教材P57 的程序阅读题1、2
1.

public class trytry {
 public static void main(String args[]) {
     char c='';
     for(int i=1;i<=4;i++){
         switch (i){
             case 1:c='j';
                 System.out.print(c);
                 case 2:c='e';
                 System.out.print(c);
                 case 3:c='p';
                 System.out.print(c);
             default:
                 System.out.print("好");
         }
     }
 }//输出 jep好ep好e好好
}
  1.     public static void main(String args[]) {
         char a='你';
         if(a>'A')
             System.out.println(1);
         else
             System.out.println(2);
     }//输出1
    

2、教材P120 的程序阅读题1、2、3、4

  • 例一

    public class trytry {
        static class Fish{
            int weight=1;
        }
        static class Lake{
            Fish fish;
            void setFish(Fish s){
                fish=s;
            }
            void foodFish(int m){
                fish.weight= fish.weight+m;
            }
        }
        public static void main(String args[]) {
            Fish redFish=new Fish();
            System.out.println(redFish.weight);//1
            Lake lake=new Lake();
            lake.setFish(redFish);
            lake.foodFish(120);
            System.out.println(redFish.weight);//120+1 121
            System.out.println(lake.fish.weight);//121
    
        }
    }
    
  • 例二

    public static void main(String[] args) {
        B b=new B();
        b.setX(-100);
        b.setY(-200);
        System.out.println(b.getXYSum());//sum=100-200=-100
    }
    }
    class B{
        int x=100,y=200;
    
        public void setX(int x) {
            x = x;//此处无this,所以b.setX(-100)的值没有传进去,x仍然为100,sum=100-200=-100
        }
    
        public void setY(int y) {
            this.y = y;
        }
        public int getXYSum(){
            return  x+y;
        }
    }
    
  • 例三

    class A{
    public static void main(String[] args) {
            B b1=new B();
            B b2=new B();
            b1.setN(3);
            b2.setN(5);
            int s1=b1.getSum();
            int s2=b2.getSum();
        System.out.println(s2);
    }
    }
    class B{
        int n=0;
        static int sum=0;
        void setN(int n){
            this.n=n;
        }
        int getSum(){
            for(int i=1;i<=n;i++){
                sum=sum+i;//s1之后sum为6,因此s2开始调用时sum以6开始,而不是0开始
            }
            return sum;
        }
    }
    
  • 例4

    public class A {
    public static void main(String[] args) {
        B b=new B();
        System.out.println(b.f(10,10));//传递到int f(int x,int y),x*y=100
        System.out.println(b.f(10,10.0));//传递到double f(int x,double y),x+y=20.0
    }
    }
    class B{//方法的重载
        double f(int x,double y){
            return x+y;
        }
        int f(int x,int y){
            return x*y;
        }
    }
    

3、教材P153 的程序阅读题1、2、3、4

  • 例一

    public class trytry {
      public static void main(String[] args) {
          B b=new B();
          System.out.println(b.f(3,5));//3*5 15
          System.out.println(b.f(3.0,5.0));//3.0+5.0 8.0
      }
    }
    
    class A{
        double f(double x,double y ){
            return x+y;
        }
    }
    class B extends A{//B继承了A的方法,所以创造B对象时,也可以调用A的方法double f(double x,double y)
        int f(int x,int y){
            return x*y;
        }
    }
    
  • 例二

    class A{
      public int getNumber(int a){
            return a+1;
        }
    }
    class B extends A{
        public int getNumber(int a){
            return a+100;
        }
    
        public static void main(String[] args) {
            A a=new A();
            System.out.println(a.getNumber(10));//11 此时调用的是A中方法
            a = new B();
            System.out.println(a.getNumber(10));//110 此时调用的是B中方法
        }
    }
    
    
  • 例三

     class A{
      double f(double x,double y){
          return x+y;
      }
      static int g(int n){
          return n*n;
      }
    }
    class B extends A {
        double f(double x, double y) {
            double m = super.f(x, y);//访问父类方法
            return m + x * y;
        }
    
        static int g(int n) {
            int m = A.g(n);//静态方法,无this和super,通过A.g()调用父类方法
            return m + n;
        }
    
    }
    public class trytry {
        public static void main(String[] args) {
            B b=new B();
            System.out.println(b.f(10.0,8.0));//98.0 先super访问了父类的f()方法得到m为18.0,再加上x*y 为98.0
            System.out.println(b.g(3));//12 先A.g()调用父类g()方法得到m为9,再加上n 3 结果为12
            A a=new B();
            //当创建子类对象时,不管使用子类的哪个构造器,默认情况下总会去调用父类的无参构造器,如果父类没有提供无参构造器,则必须在子类的构造器中用super去指定使用父类的哪个构造器完成对父类的初始化工作
            System.out.println(a.f(10.0,8.0));//98.0 同上
            System.out.println(a.g(3));//9 直接访问父类的g方法
        }
    }
    
  • 例四

     class A{
      int m;
      int getM(){
          return m;
      }
      int seeM(){
          return m;
      }
    }
    class B extends A {
        int m;
        int getM(){
            return m+100;
        }
    }
    public class trytry {
        public static void main(String[] args) {
            B b=new B();
            b.m=20;
            System.out.println(b.getM());//120
            A a=b;
            a.m=-100;
            System.out.println(a.getM());//120
            //上转型对象调用的一定是子类重写的getM()
            System.out.println(b.seeM());//-100
            //子类继承色seeM()方法操作的m是被子类隐藏的m
        }
    }
    

4、教材P173 的程序阅读题1、2、3

  • 例一

    interface A{
      double f(double x,double y);
    }
    class B implements A{
        @Override
        public double f(double x, double y) {
            return x*y;
        }
        int g(int a,int b){
            return a+b;
        }
    }
    public class trytry {
    
        public static void main(String[] args) {
            A a=new B();
            System.out.println(a.f(3,5));//15
            B b=(B)a;
            System.out.println(b.g(3,5));//8.0
        }
    }
    
  • 例二

    interface Com{
      int add(int a,int b);
    }
    abstract class A{
        abstract int add(int a,int b);
    }
    class B extends A implements Com{
        @Override
        public int add(int a, int b) {
            return a+b;
        }
    }
    public class trytry {
    
        public static void main(String[] args) {
            B b=new B();
            Com com=b;
            System.out.println(com.add(12,6));//18
            A a=b;
            System.out.println(a.add(10,5));//15
        }
    }
    
  • 例三

    interface Com{
      int add(int a,int b);
      public static int get(int n){
          return n;
      }
      public default int see(int n){
          return n;
      }
      public default int look(int n){
          return n;
      }
    }
    class A implements Com{
    
        @Override
        public int add(int a, int b) {
            return a+b;
        }
    
        @Override
        public int see(int n) {
            return n+1;
        }
    }
    
    public class trytry {
    
        public static void main(String[] args) {
            A a = new A();
            int m=a.add(12,6);//18
            int n=Com.get(12);//12
            int t=a.see(6);//7
            int q=a.look(6);//6
            System.out.println(m+" "+n+" "+t+" "+" "+q);
        }
    }
    

5、教材P189 的程序阅读题1、2、3

  • 例一

    class Cry{
      public void cry(){
          System.out.println("hi");
      }
    }
    public class trytry {
        public static void main(String[] args) {
            Cry hello=new Cry(){
                public void cry(){
                    System.out.println("hello");
                }
            };
            hello.cry();//hello 内部类已经把cry方法重写了
        }
    }
    
  • 例二

    interface  Com{
      public void speak();
    }
    public class trytry {
        public static void main(String[] args) {
            Com p=()->{
                System.out.println("p是接口变量");
            };
            p.speak();//p是接口变量
        }
    }
    
  • 例三

    import java.io.IOException;
    
    public class trytry {
        public static void main(String[] args) {
            try {
                methodA();
            }catch (IOException e){
                System.out.println("hi");
                return;
            }finally {
                System.out.println("fine");
            }
        }
        public static void methodA() throws IOException{
            throw new IOException();
        }
    }
    //hi
    //fine
    
编程题涉及相关内容:

1、求数列之和(累积和) ,如:教材P51页 例子5,教材P51页 例子6
2、教材P58 的编程题1、3、5、6

  • 1
        public static void main(String[] args) {
          //求1到10的阶乘和    
          int sum=0;
          int m=1;
          for(int i=1;i<=10;i++){
              m=i*m;
              sum+=m;
          }
          System.out.println(sum);//4037913
      }
    
  • 3
        public static void main(String[] args) {
        //求1+1/2!...前20项之和
        double sum=0;
        double m=1;
        for(int i=1;i<=20;){
            sum+=m;
            i++;
            m=m*(1.0/i);
    
        }
        System.out.println(sum);//1.7182818284590455
        int i = 0;
        while(i<=20){
            sum+=m;
            i++;
            m=m*(1.0/i);
        }
        System.out.println(sum);//1.7182818284590455
    }
    
  • 5
        public static void main(String[] args) {
        //求8+88+888...前十项之和
        int num=8;
        double sum=0;
        for(int i=0;i<10;i++){
            sum+=num;
            num=num*10+8;
    
        }
        System.out.println(sum);//1.286608608E9
    }
    
  • 6
        public static void main(String[] args) {
        //1+2+3...+n<8888,求n的最大正整数
        int sum=0;
        int max=8888;
        int n;
        for ( n = 0; sum < max; n++) {
            sum+=n;
            if(sum>max){
                n-=2;
            }
        }
        System.out.println(n);//132
    }
    

3、设计一个圆形、矩形、三角形的类,计算面积、周长等(参考实验题及单元测试)

import java.lang.Math;
import java.util.Scanner;
abstract class Shape{
	public abstract double area();
	public abstract String getShapeName();
}
class Circle extends Shape{
	public double r;
	Circle(double r){
		this.r=r;
	}
	public String getShapeName(){
		String c="Circle";
		return c;
	}
	public double area(){
		return Math.PI*r*r;
	}
}
class Rectangle extends Shape{
	double height,width;
	public String getShapeName(){
		String r="Rectangle";
		return r;
	}
	Rectangle(double height,double width){
		this.height=height;
		this.width=width;
	}
	public double area(){
		return height*width;
	}
}
class Triangle extends Shape{
	double bottom,height;
	public String getShapeName(){
		String r="Triangle";
		return r;
	}
	Rectangle(double bottom,double height){
		this.bottom=bottom;
		this.height=height;
	}
	public double area(){
		return bottom*height/2;
	}
}

class Calculator{
    public void play (Shape shape) {
       System.out.printf("%s:%.2f",shape.getShapeName(),shape.area());   
	}
}
public class Main{
	public static void main(String[] args) {
		Calculator calculator =new Calculator();
		Scanner sc=new Scanner(System.in);
		int ch=sc.nextInt();
		switch(ch){
		case 1: 
			double r=sc.nextDouble();
			calculator.play(new Circle(r));break;
		case 2:
			double height=sc.nextDouble();
			double width=sc.nextDouble();
			calculator.play(new Rectangle(height,width));break;
case 3:
			double bottom=sc.nextDouble();
			double height=sc.nextDouble();
			calculator.play(new Triangle(bottom,height));break;

		default:
			System.out.println("No corresponding shape!");
		}
	}
}
    

4、设计一个Point(二维图中的点)类,计算距离(参考实验题及单元测试)

    public static class Point{
        private double x;
        private double y;

        public Point(int x, int y) {
            this.x=x;
            this.y=y;
        }

        public double getX() {
            return x;
        }

        public void setX(double x) {
            this.x = x;
        }

        public double getY() {
            return y;
        }

        public void setY(double y) {
            this.y = y;
        }

        public int distance(Point p2) {
            return (int) Math.sqrt(Math.pow((p2.x - this.x), 2) + Math.pow(p2.y - this.y, 2));
        }
    }
    public static void main(String[] args) {
        Point p1, p2;
        int x1, y1, x2, y2;

        Scanner sc = new Scanner(System.in);

        x1 = sc.nextInt();
        y1 = sc.nextInt();
        x2 = sc.nextInt();
        y2 = sc.nextInt();

        p1 = new Point(x1, y1);
        p2 = new Point(x2, y2);

        System.out.println(p1.distance(p2));
    }

5、教材P76例子6(求和)、教材P81例子8(圆锥组合圆对象)

  • 例子6

      public class trytry {
          public static void main(String[] args) {
          Computer com=new Computer();
          int m=100;
          int n=200;
          int result=com.add(m,n);
              System.out.println(result);//300
              result=com.add(120+m,n*10+8);
              System.out.println(result);//2228
          }
      }
      class Computer{
          int add(int x,int y){
              return x+y;
          }
      }
    
  • 例子8

    public class Circle {
    double radius,area;
    void setRadius(double r){
        radius=r;
    }
    double getRadius(){
        return radius;
    }
    double getArea(){
        area=3.14*radius*radius;
        return area;
    }
    }
    public class Circular {
        Circle bottom;
        double height;
        void setBottom(Circle c){
            bottom = c;
        }
        void setHeight(double h){
            height =h;
        }
        double getVolume(){
            if(bottom==null) return -1;
            else return bottom.getArea()*height/3.0;
        }
        double getBottomRadius(){
            return bottom.getRadius();
        }
        public void setBottomRadius(double r){
            bottom.setRadius(r);
        }
    }
    public class Run1 {
        public static void main(String[] args) {
            Circle circle = new Circle();
            circle.setRadius(10);
            Circular circular = new Circular();
            System.out.println("circle的引用"+circle);//circle的引用comCircleAndCircular.Circle@96532d6
            System.out.println("圆锥的bottom的引用"+circular.bottom);//圆锥的bottom的引用null
            circular.setHeight(5);
            circular.setBottom(circle);
            System.out.println("circle的引用"+circle);//circle的引用comCircleAndCircular.Circle@96532d6
            System.out.println("圆锥的bottom引用"+circular.bottom);//圆锥的bottom引用comCircleAndCircular.Circle@96532d6
            System.out.println("圆锥的体积"+circular.getVolume());//圆锥的体积523.3333333333334
            System.out.println("修改circle的半径,bottom的半径同样变化");//修改circle的半径,bottom的半径同样变化
            circle.setRadius(20);
            System.out.println("bottom的半径"+circular.getBottomRadius());//bottom的半径20.0
            System.out.println("重新创建circle,circle的引用将发生变化");//重新创建circle,circle的引用将发生变化
            circle=new Circle();
            System.out.println("circle的引用"+circle);//circle的引用comCircleAndCircular.Circle@6108b2d7
            System.out.println("但是不影响circular的bottom的引用");//但是不影响circular的bottom的引用
            System.out.println("圆锥的bottom的引用:"+circular.bottom);//圆锥的bottom的引用:comCircleAndCircular.Circle@96532d6
        }
    }
    
转载请注明:文章转载自 www.mshxw.com
本文地址:https://www.mshxw.com/it/949072.html
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号