学习总结

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

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

构造方法：再创建对象时初始化，叫做构造方法构造方法没有返回值其方法名和类名相同 ,一个类中没有声明一个构造方法，那系统会自动声明一个构造方法，有需要可以自己在类中写构造方法，如果重写最好在写一个无参构造方法
构造方法的重载：方法名和类型与构造方法相同，但是方法的参数不同，再调用方法时根据传入的参数来判断应使用哪个方法
不能通过，因为类Foo中的构造方法的参数为一个int型的变量，而且没有无参的构造方法，但是实例化时并没有参数

.运行下列程序，结果是什么？分析原因，应如何修改
```
public class Test {
public static void main(String[] args) {
    MyClass[] arr=new MyClass[3];
    arr[1].value=100;
}
}
class MyClass{
public int value=1;
}
```
运行结果Exception in thread "main" java.lang.NullPointerException
原因：只是声明了数组并没有对数组进行实例化
应对数组进行实例化

运行下列程序，结果是什么？说明原因
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
原因：==进行的比较只是对两个比较对象所在的物理地址进行比较，obj1和obj2的引用是不同的，所以结果为false

什么是面向对象的封装性，Java中是如何实现封装性的？试举例说明
封装性：封装性即不能让其余的类随意对此类的成员变量进行修改，在定义成员时，使用private关键字对成员变量进行封装，使这些变量只能被这个类中的其他成员方法调用，而不能被其余类所调用

例子

class S{
    private String name;//对姓名进行封装，在公共类中如果需访问，需要用set,get方法访问
    private int age;
    public S(String name,int age){
        String name;
        int age;
        this.name=name;
        this.age=age;
    }
    public void setName(String name){      
        this.name=name;
    }
    public String getName(String name){
        return this.name;
    }
    public void setAge(int age){
        this.age=age;
    }
    public int getAge(int age){
        return this.age;
    }

}
public class S{
    public static void main(String[]  args){
        S p1=new S(张三,18);
        S p2=new S(李四,20);
        if(p1.getName.equals(p2.getName)&&p1.getAge==p2.getAge){
            System.out.println("两个对象相等");
        }
        else{
            System.out.println("两个对象不不相等");
        }
    }
}

阅读下面程序，分析是否能编译通过？如果不能，说明原因

一

class A{
private int secret = 5;
}
public class Test{
public static void main(String args[]){
    A a = new A();
    System.out.println(a.secret++);
}
}

不能。secret属性是类A的私有属性，不能在类外直接访问。

二

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();
}
}

不能。method只能用被static修饰的变量，但是x没有被static修饰

使用类的静态变量和构造方法，可以跟踪某个类创建的对象个数。声明一个图书类，数据成员为编号，书名，书价，并拥有静态数据成员册数记录图书的总数。图书编号从1000开始，每产生一个对象，则编号自动递增（利用静态变量和构造方法实现）。下面给出测试类代码和Book类的部分代码，将代码补充完整。

```
class Book{
int bookId;
String bookName;
double price;
// 声明静态变量

//定义静态代码块对静态变量初始化

//构造方法

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;
}
//定义方法求图书总册数

//重写toString方法

}
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("图书总数为："+ Book.totalBook());
for(Book book:books){
System.out.println(book.toString());
}
}
}

**更改代码如下**

class Book{
int bookId;
String bookName;
double price;
// 声明静态变量
public static n;
//定义静态代码块对静态变量初始化
static {
n=0;
}
//构造方法
public Book(String bookName,double price ){
this.bookName=bookName;
this.price =price ;
n++;
this.bookId=1000+n;
}
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 int totalBook(){
return n;
}
//重写toString方法
public string toString(){
return "编号"+bookld+“书名”+bookName+"价格"+"price "+"图书总数目为"+n;
}
}
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("图书总数为："+ Book.totalBook());
for(Book book:books){
System.out.println(book.toString());
}
}
}

###什么是单例设计模式？它具有什么特点？用单例设计模式设计一个太阳类Sun
+ 单例模式：一个类只能有一个对象

class Sun{
private Sun instance = new Sun();
private Sun(){

  }
  public static Sun getInstance(){
      return instance;
  }

}

###理解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
+ 原因：字符串str属于引用类型，在调用change方法传入的是str的副本，并为对str本身进行改变,，但是数组ch传入的是地址，直接改变了ch数组中的内容
#实验总结
###用面向对象思想完成评分系统
+ 了解什么是面向对象
+ 在选手类中声明选手的信息，成绩信息是后来打分后才有的，所以在构造方法中并不需要成绩这个参数，在裁判类中声明裁判的信息，用来存储成绩，在测试类测试
###Email验证
+ 没有什么注意事项 
###查找子串
+ 如果查找的字符串存在，计数机加一，截取剩下的字符串继续查找，重复以上直到不存在查找的字符串
###统计文件
将所有的字符串根据逗号分隔，将每一个文件变成字符数组，通过判断数组首元素与大写字母的关系来判断是否大小写，如果小写则减去32，然后再变回字符串，文件统计： 用lastIndexOf方法找到最后出现点的位置，然后截取后面的子串，设置两层循环，外层判断字符数组，内层从第一个字符串开始判断文件类型然后记录，在将数组元素变为空，向下寻找相同的文件类型，记录，变空，知道数组为空最后输出
###类的设计
+ 日期类   除了定义年月日外还定义个生日，参加工作时间变量，另外定义了一个员工类的对象，这样在员工类中不需要再定义两个日期类分别进行存储生日和参加工作时阿，只需用set和get方法调用即可
+ 员工类   除了员工的基本信息之外还应定义一个部门类的对象来存储员工属于哪个部门，同时也应定义一个日期类存储生日和参加工作的时间
+ 部门类   除了部门的基本信息之外还应定义一个员工类的对象来存储 部门的经理信息，同时也应定义一个员工类的对象数组来存储一个部门的所有员工
+ 测试类   测试
+``` /*当一个类中声明了其余类的对象时，在调用时逻辑上要分清一个方法在调用后所代表的是什么，例如emp2.getDept().getEmp()[i].getName()，    emp2.getDept（）这个方法调用后代表的是部门dept（返回值为部门对象的引用）；dept.getEmp()[i]这个方法执行后代表的是部门所包含的所有成员中第i个成员（emp[i]）的引用；emp[i].getName()这个方法执行后表示的是员工数组中第i个员工的姓名；因此，综上分析，emp2.getDept().getEmp()[i].getName()这个语句执行的含义是emp2员工所在的部门中第i个员工的姓名。*/

码云

《Java技术》第二次作业

秒客网

《Java技术》第二次作业

学习总结

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

.运行下列程序，结果是什么？分析原因，应如何修改

运行下列程序，结果是什么？说明原因

什么是面向对象的封装性，Java中是如何实现封装性的？试举例说明

阅读下面程序，分析是否能编译通过？如果不能，说明原因

一

二

码云

相关文章