• java第二次实验作业


    (一)学习总结

    1.什么是构造方法?什么是构造方法的重载?下面的程序是否可以通过编译?为什么?

    public class Test {
    public static void main(String args[]) {
    Foo obj = new Foo();
    }
    }
    class Foo{
    int value;
    public Foo(int intValue){
    value = intValue;
    }
    }

    1.构造方法的名字必须与定义他的类名完全相同,没有返回类型,甚至连void也没有。
    2.构造方法的调用是在创建一个对象时使用new操作进行的。构造方法的作用是初始化对象。
    3.不能被static、final、synchronized、abstract和native修饰。构造方法不能被子类继承。
    
    两个或两个以上的方法具有相同的返回值类型和相同的方法名,只是参数的个数或类型不同,这样的方法就叫重载 。
    重载是类名相同,参数或返回值不同的方法。所以,重载的构造函数就是只能参数不一样,当没有构造方法的时候,
    系统会自己加上没有参数的构造函数,当用到了有参数的构造函数,那么系统就不会给你添加。
    
    不可以通过编译,原因是“构造函数Foo()”未定义。
    
    2.运行下列程序,结果是什么?分析原因,应如何修改。
    
    public class Test {
    public static void main(String[] args) {
    MyClass[] arr=new MyClass[3];
    arr[1].value=100;
    }
    }
    class MyClass{
    public int value=1;
    }
    
    运行结果是空指针异常,定义value后没有赋值或者判断就直接调用或者输出
    修改方法即对其进行实例化,修改如下:
    public class Test {
    public static void main(String[] args) {
    MyClass[] arr=new MyClass[3];
    arr[1] = new MyClass();
    arr[1].value=100;
    }
    }
    class MyClass{
    public int value=1;
    }
    
    3.运行下列程序,结果是什么?说明原因。
    
    public class Test {
    public static void main(String[] args) {
    Foo obj1 = new Foo();
    Foo obj2 = new Foo();
    System.out.println(obj1 == obj2);
    }
    }
    class Foo{
    int value = 100;
    }
    
    结果是false,原因是两者虽然赋值相同,但是开辟的数据存储地址不一样。
    
    4.什么是面向对象的封装性,Java中是如何实现封装性的?试举例说明。
    ~~~面相对象的封装性:
    
    封装性是面向对象的方法所应遵循的一个重要原则,它有两个含义:一是值把对象的属性和行为看成一个密不可分的整体,将这两者“封装”在一个不可分割的独立单位(即对象)中,另一层含义值“信息隐蔽”,把不需要让外界知道的信息隐藏起来,有些对象的属性及行为允许外界用户知道或使用,但不允许更改,而另一些属性或行为。则不允许外界知道,或只允许适用对象的功能,而尽可能隐蔽对象的功能实现细节 (课本93页)
    
    如何实现封装:
    属性封装:private 属性类型 属性名称;
    方法封装:private 方法返回值 方法名称{}
    只要是被封装的属性,必须通过setter和getter方法设置和取得。
    用private声明的属性或方式只能在其类的内部被调用,而不能在外部调用。~~~
    5.阅读下面程序,分析是否能编译通过?如果不能,说明原因。
    (1)
    
    class A{
    private int secret = 5;
    }
    public class Test{
    public static void main(String args[]){
    A a = new A();
    System.out.println(a.secret++);
    }
    }
    
    不能通过编译,错误原因是“字段 A.secret 不可视”,即secret是类A中的私有属性,不能在外部被调用。
    
    (2)
    
    public class Test{
    int x = 50;
    static int y = 200;
    public static void method(){
    System.out.println(x+y);
    }
    public static void main(String args[]){
    Test.method();
    }
    }
    
    不能通过编译,错误原因是“不能对非静态字段 x 进行静态引用”,即x没有被定义成static属性。
    
    6.使用类的静态变量和构造方法,可以跟踪某个类创建的对象个数。声明一个图书类,数据成员为编号,书名,书价,并拥有静态数据成员册数记录图书的总数。图书编号从1000开始,每产生一个对象,则编号自动递增(利用静态变量和构造方法实现)。下面给出测试类代码和Book类的部分代码,将代码补充完整。
    
    class Book{
    int bookId;
    String bookName;
    double price;
    ~~~// 声明静态变量
    
        //定义静态代码块对静态变量初始化
    
        //构造方法
        static int count=1000;
        public Book(String bookName, double price) {
            this.bookName = bookName;
             this.price = price;
        }
        public int getbookId(){
            return bookId;
        }
        public void setbookId(int bookId){
            this.bookId=bookId;
        }
        
         public String getBookName() {
            return bookName;
        }
        public void setBookName(String bookName) {
            this.bookName = bookName;
        }
        public double getPrice() {
            return price;
        }
        public void setPrice(double price) {
            this.price = price;
        }  
         
        //定义方法求图书总册数
        
        public   Book() {
            count++;
        }
    
        //重写toString方法
        public  String toString(){
            return "图书编号:"+this.bookId+"书名:"+this.bookName+"书价:"+this.price+"产生对象个数:"+count;
        }     
    }~~~
    public class Test{
    public static void main(String args[]){
    Book[] books = {new Book("c语言程序设计",29.3),
    new Book("数据库原理",30),
    new Book("Java学习笔记",68)};
    System.out.println("图书总数为:"+"count");
    for(Book book:books){
    System.out.println(book.toString());
    }
    }
    }
    ~~~7.什么是单例设计模式?它具有什么特点?用单例设计模式设计一个太阳类Sun。
    
       单例设计模式:保证一个类在使用过程中,只有一个实例。优势就是他的作用,这个类永远只有一个实例。
    
        特点:
            1、单例类只能有一个实例。~~~
    2、单例类必须自己自己创建自己的唯一实例。
       3、单例类必须给所有其他对象提供这一实例。
    ~~~太阳类:
            class Sun{
                    private static Sun s =  new Sun();
                    private Sun(){ 
    
                    }
                   public static Sun getInstance(){
                               return s;
                           }
                   }
    
       8.理解Java参数传递机制,阅读下面的程序,运行结果是什么?说明理由。
    
                public class Test {
                    String str = new String("你好  ");
                    char[] ch = { 'w','o','l','l','d' };
                   public static void main(String args[]) {
                   Test test = new Test();
                   test.change(test.str, test.ch);
                   System.out.print(test.str);
                       System.out.print(test.ch);
                    }
                    public void change(String str, char ch[]) {
                    str = "hello";
                    ch[0] = 'W';
                        }
                    }
    
                运行结果是“你好 Wolld”
                
                理由:Test类中调用test输出“你好”后,空间即被释放掉,而ch数组输出第一个字符“W”后会返回到主函数,持续输出直到输出完毕。~~~
    (二)实验总结
    ~~~1.用面向对象思想完成评分系统
    程序设计思路:按照老师的模板一步步完成的。
    问题1:第一次写出现了很多问题。
    原因:不明白怎么调用。
    解决方案:老师帮助修改。
    2.Email验证
    程序设计思路:用了三层嵌套,觉得程序比较麻烦,但没想到还有什么更好的方法。
    3.查找子串
    程序设计思路:查找出现的字符串的下标,下一次从该下标处继续查找,直到查完整个字符串,没查找到一次,计数加一。
    4.评分类中不会对选手分数进行数组输入,就是评委类中不会调用数组
    5.统计文件时不会对文件的首字母进行大写,只会调用函数将全部内容大写
    6.验证Email文件的时候不会对后边的字符串进行判断,也无法进行输出了。
    

    (三)代码托管(务必链接到你的项目)

  • 相关阅读:
    mysql缓存
    复杂映射
    SQL 映射的 XML 文件
    xml配置文件
    从xml中构建sqlSessionFactory
    eclipse使用时jar不在libraries
    去掉不用的工作空间
    javac找不到或无法加载主类 com.sun.tools.javac.Main,
    文本,布局,样式
    (常用)re模块
  • 原文地址:https://www.cnblogs.com/weizhenchuan/p/8688285.html
Copyright © 2020-2023  润新知