JAVA基础班前10天homework作业及答案

欢迎基础班的伙伴来交流

Day01

1：若有定义：int a; a=a+10;则执行上述语句后，a的值是（D）。

A.   10                     

B.   11

C.   0                       

D.   编译产生错误

3：标示符的命名规则补齐

        类或者接口：类名：以大写字母开头，且每个单词首字母大写 ，要能够见名知意

                           例如：StudentInfo；

                  接口名：以大写字母"I"开头，单词首字母大写，要能够见名知意

                             例如：IStudentInfo

        变量或者方法：以26个英文大小写字母，0-9个数字，_和$符号组成，且不能以数字开头；

                        第一个单词首字母小写，之后的单词首字母大写

4：Java中的数据类型分类?

      基本数据类型

                4类8种，大小范围：

                整型：                       

                     byte 1个字节 -128-127

                     short 2个字节

                     int   4个字节（整数默认为int类型）

                     long  8个字节

                浮点型：float 4（float类型需要后加f后缀）

                        double 8（小数默认为double类型）

                字符型: char  2

                布尔型:boolean 不确定，暂认1个               

        引用数据类型：类class，接口interface，数组[]；

5：Java中数据的类型转换问题是什么?并举例

        隐式转换：short s = 1;

                        s+=1;        //该式子隐含类型转换

        从小到大：

                （byte,short,char） -- int -- long -- float -- double；

        强制转换：(数据类型)数据; 如(int)3.14;

6：面试题(拓展题)

        short s = 1;

        s = s + 1;//s是        short类型，加1后结果为int类型，这时不能再赋值给        short类型的s

        和

        short s = 1;

        s+=1;        //该式子隐含强制类型转换，故而可以通过运行               

谢谢分享

我是来看评论的 怎么不一起发呢

整个一个版里吧，

感谢分享。。。赞一个

大哥,能把你第.三.阶.段的考.试.题给我看看吗? 重题不可能,但能了解考什么类型就好

多谢楼主！只有前面10的吗？

好人一生平安

不错不错，楼主辛苦了

写的挺不错的哈，赞一个

后面的有么

嗯，不错。

学习一下

最好代码用代码编辑器。这样代码就容易看了。就是高级模式里的添加代码。

谢谢分享

JAVA双元基础班的小伙伴们第1-10天的homework作业及详细解答全部在这了，

Day10

第十天的压缩附件，{:3_67:}

Day09

1. 容器类，可以添加元素
class MyContainer
{
private Object[] arr = new Object[10];
/**计数器*/
private int index = 0;
public void add(Object obj){
  if(arr.length == index){
   Object[] temp = new Object[arr.length * 2];
   
   //把原来容器里面的数据赋值给新的容器temp
   for(int i=0; i<arr.length; i++){
    temp=arr;
   }
   
   arr=temp;
   
  }
  arr[index++] = obj;
}
public int size(){
  return index;
}
/**
  获取指定索引位置的元素
{2,0,0,0,0}
*/
public Object get(int index){
  if(index >= this.index){
   return null;
  }
  return arr[index];
  
}

public static void main(String[] args){
  MyContainer c = new MyContainer();
  
  for(long i=0; i<100; i++){
   c.add("hello,"+i);
  }
  for(int i=0; i<c.size(); i++){
   System.out.println(c.get(i));
  }
  System.out.println(c.size());
  
}
}

Day08

基本概念回顾：
1:类是什么?类的组成是哪些?
类是属性和行为的集合,是抽象的概念
由成员变量，构造方法，成员方法组成。
2:对象是什么?什么时候需要使用对象?
对象是类的具体的存在，体现；
当需要调用类，初始化对象时使用
3:封装是什么?自己概述
封装就是隐藏对象的属性和行为，仅对外提供访问方式
提高的代码的复用和安全。

4:继承是什么?自己概述
继承就是儿子继承父亲，是类与类之间的一种关系；
将多个类中的相同属性和行为抽取到同一个类中，其他类就不必在定义，提高extends使类之间产生关系；
继承提高的复用，是多态的前提；
类之间支持单继承和多层继承；不支持多继承；
子类可直接访问非私有的属性和行为；
子类可以通过父类公共方法访问父类私有成员。

5:多态是什么?自己概述
多态就是对象在不同的时刻表现出不同的状态；
前提：
      1.有继承关系或实现关系；
      2.有方法的重写；
      3.有父类引用或父接口关系指向子类对象
成员特点：
  成员变量：编译运行都依据左边；
  成员方法：编译看左边，运行看右边
弊端：父类引用不能够使用子类所特有的功能。
好处：提高了代码的复用性和可维护性。

6:抽象类是什么?自己概述
类中有抽象方法的类就是抽象类，被Abstract修饰
当一个方法不确定要做什么时，就可以把它定义为抽象方法，该类便是抽象类
特点：
      1.由abstract修饰；
      2.有抽象方法的类一定是抽象类，但出现类不一定有抽象方法；
      3.抽象类不能被实例化；
      4.通过子类对象实例化；
      5.子类要么本身为抽象类，要么全部重写父类抽象方法。
作用：强制子类必须完成某些功能
成员特点：
  1.成员变量，成员常量都可以有
  2.构造方法，有，可以在子类访问父类数据之前对父类数据初始化
  3.成员方法：抽象方法和非抽象方法都可以有，
       抽象方法是为了要求子类做某些事情
       非抽象方法是为了被子类继承，提高代码复用性
7:接口是什么?自己概述
把接口看成是一种特殊的抽象类。比抽象类更抽象。
因为它的方法都是抽象的。但是接口不是类，只是把他看成类
定义格式：
  interface 接口名
         {
             静态常量
      抽象方法
         }
特点：
1、接口不能被实例化。
2、接口中的方法：要么被子类重写，要么子类也是抽象类。
成员特点：
  1.接口中只有常量；
  2.无构造方法，接口中的成员变量都被final修饰，定义时须做初始化；
  3.接口中的方法都是抽象的，默认修饰符：public abstract

8:抽象类和接口的区别?
  抽象类：
                   成员变量：可以是变量，也可以是常量。
                   构造方法：有构造方法。
                   成员方法：可以是抽象方法，也可以是非抽象方法。
         接口：
                   成员变量：只能是常量。默认修饰符：public static final
                   成员方法：只能是抽象方法。默认修饰符：public abstract
9:匿名对象是什么?怎么用?
1.在创建对象时，不使用间接变量表示对象，而是直接使用new出来的对象
2.当对方法只进行一次调用时可以使用匿名调用,做测试时使用，
10:成员变量和局部变量的区别?
1.定义位置：成：类中，方法外
      局：方法中或方法形参
2.初始化：成：有默认初始化值
    局：无，使用前需要先赋值
3.存储位置：成：堆中，随对象存在和消失
      局：栈中，随方法的调用而存在和消失
11:构造方法的特点?构造方法的注意事项?
特点：
  1.函数名必须与类名相同；
  2.无返回值类型；
  3.无返回值
注意：
  1.最好自己给出无参构造方法；
  2.jvm默认给出无参构造方法，如果已经定义了则不再给出无参构造

12:方法重写是什么?注意事项是什么?
子类中出现与父类中一样的方法声明
注意事项：
  1.父类中私有方法不可重写；
  2.子类方法的访问权限须大于等于父类权限
  3.子类需要法律方法，而且又有自己特有方法是可以采用重写
关键字回顾：请说说下面东西分别是什么，有什么用?
private ：私有化，不需要对外提供的内容都可以私有化，只能被本类中对象使用，
this：代表当前对象，
super：代表父类内存空间的标识
static：静态化，被其修饰的变量可被类中所以对象共享
final：最终化，修饰类时不可继承，修饰成员时不可再赋值和重写
abstract：抽象化，声明抽象类，抽象方法
interface：接口，接口是方法的集合
extends： 继承，
implements :实现
编程题：
1:标准学生类定义及使用。
/**
标准学生类定义及使用
*/
class Student
{
private String name;
private int age;

//无参构造
public Student(){}
//有参构造,姓名，年龄
public Student(String name, int age){
  this.name = name;
  this.age = age;
}
public void setName(String name){
  this.name = name;
}
public String getName(){
  return name;
}
public void setAge(int age){
  this.age = age;
}
public int getAge(){
  return age;
}
public void show(){
  System.out.println("学生"+name+"的年龄为："+age);
}
}
public class StudentTest
{
public static void main(String[] args)
{
  Student s = new Student();
  s.setName("姚明");
  s.getName();
  s.setAge(40);
  s.getAge();
  s.show();
}
}

2:请用抽象类体现如下代码：
/**
需求：
   公司中程序员有姓名，工号，薪水，工作内容。
   项目经理除了有姓名，工号，薪水，还有奖金，工作内容。
思路：
   员工（程序员、项目经理）
   姓名 工号 薪水
   工作
  程序员 简单的继承
  项目经理 简单继承+奖金
*/
//员工抽象类Emlpoyer
abstract class Emlpoyer
{
/**属性: 姓名 工号 薪水*/父类中有文档注释时子类中可以不写
public String name;
public String id;
public double salary;
public Emlpoyer(){}
public Emlpoyer(String name, String id,double salary){
  this.name = name;
  this.id = id;
  this.salary = salary;
}
public void setName(String name){
  this.name = name;
}
public String getName(){
  return name;
}
public void setId(String id){
  this.id = id;
}
public String getId(){
  return id;
}
public void setSalary(double salary){
  this.salary = salary;
}
public double getSalary(){
  return salary;
}
//方法：工作
public abstract void work();
}
//程序员类Programmer
class Programmer extends Emlpoyer
{
  public Programmer(){}
  public void work()
  {
   this.name = name;
   this.id = id;
   this.salary = salary;
   System.out.println("姓名:"+name+" 工号:"+id+" 薪资:"+salary+" 她在调bug");
  }
}
//项目经理类Manager
class Manager extends Emlpoyer
{
  public double bonus=50000D;
  public Manager(){}
  public void work()
  {
   this.name = name;
   this.id = id;
   this.salary = salary;
   System.out.println("姓名:"+name+" 工号:"+id+" 薪资:"+salary+" 奖金:"+bonus+" 我在数奖金");
  }
}
//测试类EmlpoyerTest
public class  EmlpoyerTest
{
public static void main(String[] args)
{
  Emlpoyer e = new Programmer();
  e.setName("小美");
  e.getName();
  e.setId("20150729");
  e.getId();
  e.setSalary(8000);
  e.getSalary();
  e.work();
  e = new Manager();
  e.setName("郑经理");
  e.getName();
  e.setId("20150728");
  e.getId();
  e.setSalary(18000);
  e.getSalary();
  e.work();
}
}

Day7

1：继承是什么?继承的好处是什么?
1. 将多个类中相同的属性和行为抽取到单个类中，这样各个类无需再定义，只需要继承即可
2. 提高代码的复用性；
           让类与类产生关系，是多态的前提。
2：Java中的继承特点是什么?

1、类支持单继承，不支持多继承,因为多继承会出现调用不明确的问题;
        2、JAVA支持多层继承 (继承体系).

3：看程序写结论。最好自己分析,先不要运行看结果。
class Fu
{
public int num = 10;
public Fu()
{
  System.out.println("fu");//fu
}
}
class Zi extends Fu
{
public int num = 20;
public Zi()
{
  System.out.println("zi");//zi
}
public void show()
{
  int num = 30;
  System.out.println(num); //30
  System.out.println(this.num); //20
  System.out.println(super.num); //10
}
}
class Test
{
public static void main(String[] args)
{
  Zi z = new Zi();//先执行父类构造方法，再执行子类构造方法fu,zi
  z.show();//30,20,10
}
}
4：this和super分别是什么，他们各自的应用场景是什么?
1. super代表父类内存空间标识
           this代表所在方法的所属对象的引用，谁调用this就代表谁
2. 当子父类中出现同名成员可以用super区分，子类调用父类的构造方法可以用super
    直接通过this调动本类的构造方法，成员变量，成员方法

5：什么是方法重写?需要注意哪些问题?

1.子父类关系中子类存在与父类方法声明完全一样的方法叫重写
2.父类中私有的方法不可以重写；
   子类修饰符权限要大于等于父类；
   静态方法只能被静态方法重写。
   重写时子类可以对父类方法扩展功能
6：方法重写和重载有什么区别?
  重载：同一类中或子父类关系中存在多个同名方法，且方法参数列表不同。
  重写：子父类关系中子类存在与父类方法声明完全一样的方法
7：子父类中构造方法的执行有什么特点?为什么要这样?

1.父类静态代码块-->子类静态代码块-->父类构造代码块
   -->父类构造方法-->子类构造代码块-->子类构造方法；
   子类默认构造方法都访问了父类的无参构造方法；
   子类构造方法中都有默认语句super()，并且默认只能是无参的super()语句。

        2. 因为子类会具备父类中非私有数据，初始化靠父类完成，
    所以先调用父类构造方法来初始化父类中的数据

8：静态代码块，构造代码块，构造方法的执行顺序是什么?
  静态代码块 -> 构造代码块 ->构造方法

9：final关键字是什么? 可以干什么? 分别是哪些特点?
  1.final关键字：最终的意思；
  2.可以修饰类，变量，成员方法；
  3.被final修饰的方法不能被重写；
           被final修饰的类不能被继承；
           被final修饰的变量即是常量(命名规则:字母大写，单词间_分割)

10：分析如下需求，写出你分析的类有哪些，以及功能。
    最后写一个测试类，针对每个类的功能进行测试。
    动物园里有很多种动物：
比如说，狗，猫等。
狗有姓名和年龄，猫也有姓名和年龄。
狗有跑步的方法，猫也有跑步的方法。而且都仅仅是跑步。
狗有吃饭的方法，猫也有吃饭的方法。只不过，狗吃骨头，猫吃鱼。
    请用所学知识，对这个问题进行解决。

/**
分析如下需求，写出你分析的类有哪些，以及功能。
    最后写一个测试类，针对每个类的功能进行测试。
  动物园里有很多种动物：
  比如说，狗，猫等。
  狗有姓名和年龄，猫也有姓名和年龄。
  狗有跑步的方法，猫也有跑步的方法。而且都仅仅是跑步。
  狗有吃饭的方法，猫也有吃饭的方法。只不过，狗吃骨头，猫吃鱼。
  请用所学知识，对这个问题进行解决。
分析：
1.类：
   祖类：动物类
    子类：狗类，猫类
2.属性：祖类：姓名，年龄
3.功能：
  祖类：跑步
  子类：狗吃骨头，猫吃鱼
*/
//标准化！！！
/**父类Animal的定义*/
class Animal
{
public String name;
public int age;

public Animal(){}
public Animal(String name,int age)
{
  this.name = name;
  this.age = age;
}
public void run()
{
  System.out.println("跑步");
}
}
/**子类Dog的定义*/
class Dog extends  Animal
{
public dog(){}
public void eat(String name,int age)
{
  this.name = name;
  this.age = age;
  System.out.println(name+"爱吃骨头,他 "+age+"个月大");
}
}
/**子类Cat的定义*/
class Cat extends  Animal
{
public void eat(String name,int age)
{
  this.name = name;
  this.age = age;
  System.out.println(name+"爱吃鱼,她 "+age+"个月大");
}
}
/**测试类AnimalTest的定义*/
public class  AnimalTest
{
public static void main(String[] args)
{
  new Dog().eat("叨叨狗", 5);
  new Cat().eat("加菲猫", 4);
}
}

未完待续......

敬请期待！！！