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天呢。。就day01。。。。求发全，给我们这些自学的也自测看看。。

Wqi 发表于 2015-7-29 23:27
说好的前10天呢。。就day01。。。。求发全，给我们这些自学的也自测看看。。 ...

骚瑞！接着更新:loveliness:

多更新点啊

Day02

1：以下选项中变量均已正确定义，合法的赋值语句(假设变量都已经正确定义了)是（B）。
A.   a==1;                 
B.   i*=2;
C.   a=a+1                     
D.   4+=a;

2：在Java中，下列（D）语句不能通过编译。
A.   String s = "join"+ "was"+ "here";                       
B.   String s = "join"+3;
C.   int a = 3+5;
D.   float f = 5+5.5;

3：运算符的使用

Day03

第一题：
        求1-100之和。
                int sum = 0;
                for(int i = 1; i<=100; i++)
                {
                        sum += i;
                }
                System.out.println("sum = "+sum);
       
        求1-100之间偶数和。
                方法一：
                int sum = 0;
                int x = 1;
                while(x<=100)
                {
                        if(x%2 == 0)
                        {
                                sum += x;
                        }
                }
                方法二：
                int sum = 0;
                int x = 0;
                while(x<=100)
                {
                        sum += x;
                        x += 2;
                }

        求1-100之间奇数和。
                int sum = 0;
                int x = 1;
                do
                {
                        sum += x;
                        x += 2;
                }while(x<=100);


第二题：
        输出 n=6 的三角数字阵
        1        
        2  3  
        4  5  6
        7  8  9  10
        11 12 13 14 15
        16 17 18 19 20 21  

        思路：
                1. 定义一个计数器，每输出一次，计数器累加1。这个计数器的值就是我们要打印的值
                2. 行号跟这一行里面元素的个数一样，所以我们可以用行号来控制内层循环
                3. 在内层循环里面输出计数器
                   在外层循环里面输出换行

        代码：
                int count = 0;
                for(int i =1; i <= 6;i++)
                {
                        for(int j = 1; j <= i; j++)
                        {
                                System.out.print(++count+"\t");
                        }
                        System.out.println("");
                }


第三题：
        请输出满足这样条件的五位数。
                个位=万位
                十位=千位
                个位+十位+千位+万位=百位

                思路：
                        1.定义一个要操作的五位数变量num
                        2.求出每一位个系数
                                个：num%10
                                十：num/10%10
                                百：num/100%10
                                千：num/1000%10
                                万：num/10000%10
                        3.根据题意确定范围10000-99999，变化规律是+1
                        4.判断是否符合题意中的要求，符合的话输出num
                代码：
                       
                        for(int num = 10000; num <100000;num++)
                        {
                                int ge = num%10;
                                int shi = num/10%10;
                                int bai = num/100%10;
                                int qian = num/1000%10;
                                int wan = num/10000%10;

                                if(ge == wan && shi == qian && (shi+ge+qian+wan) == bai)
                                {
                                        System.out.println(num);
                                }
                        }

第四题：
        输出 n=5 的螺旋方阵
        1  2  3  4  5
        16 17 18 19 6
        15 24 25 20 7
        14 23 22 21 8
        13 12 11 10 9  
        代码：
                int SIZE = 5;
                int arr[][] = new int[SIZE][SIZE];
                int i, j, k = 0, n, m;
                n = SIZE;
                m = (n + 1) / 2;
                for (i = 0; i < n; i++) {
                        // 顶边，从左到右，行不变列变
                        for (j = i; j <= n - i - 1; j++)
                                arr[j] = ++k;// 输出1、2、3、4、13、14
                       
                        // 右边，从上到下，行变列不变
                        for (j = i + 1; j <= n - i - 1; j++)
                                arr[j][n - i - 1] = ++k; // 输出5、6、7、15
                       
                        // 底边，从右到左，行不变列变
                        for (j = n - i - 2; j >= i; j--)
                                arr[n - i - 1][j] = ++k; // 输出8、9、10、16
                       
                        // 左边，从下到上，行变列不变
                        for (j = n - i - 2; j >= i + 1; j--)
                                arr[j] = ++k; // 输出11、12
                }
                for (i = 0; i < n; i++) {
                        for (j = 0; j < n; j++)
                                System.out.print(arr[j] + "\t");
                        System.out.println("");
                }

umbriel 发表于 2015-7-30 23:54
多更新点啊

放心，好东西大家分享！:)

Day04

1. 把a数组里面的元素复制到b数组


int[] a = new int[]{1,2,3,4,5,8,5};
int[] b = new int[a.length];




/**
        把a数组里面的元素复制到b数组


*/




class CopyArray
{
        public static void main(String[] args)
        {
                int[] a = new int[]{1,2,3,4,5,8,5};
                int[] b = new int[a.length];


                for (int x=0,y=0; x<a.length; x++,y++)
                {
                        b[y]=a[x];
                        System.out.print(b[y]+" ");
                    }
        }
}




2. 获取某个字符在字符数组中第一次出现的位置


/**
        查找指定数据在数组中首次出现的位置，即输出其下标


*/




class  ArrayTest01
{
        public static void main(String[] args)
        {
                //定义一个数组,并静态初始化
                int[] arr = {12,14,58,54,69,65,69,87,96,100};
               
                //寻找69在数组中首次出现的位置
                int index = getIndex(arr,69);
                System.out.println("69在数组中首次出现的下标为: "+index);
        }




                //定义一个获取指定元素下标的方法getIndex,返回值类型为int
        public static int getIndex(int[] arr, int value)
        {
                //遍历数组，依次获取数组中的每个元素，并与指定元素比较
                for (int x=0; x<arr.length; x++)
                {
                        if (arr[x] == value)
                        {
                                //如果相等, 则输出其下标
                                return x;
                        }
                }
        //如果没有找到则输出-1,
        return -1;//注意其放置位置,
        }
       
}






3. 获取给定字符在字符数组中 从某个位置开始查找在数组中出现的位置




        int[] arr = new int[]{1,2,3,4,6,9}


        indexOf(arr,2,4); //返回 3
       
        public static int indexOf(char[] chs, int startIndex, char ch){
        }






/**
        3. 获取给定字符在字符数组中 从某个位置开始查找在数组中出现的位置


                int[] arr = new int[]{1,2,3,4,6,9}


                indexOf(arr,2,4); //返回 3
               
                public static int indexOf(char[] chs, int startIndex, char ch){
                }
*/




class  GetIndex
{
       
        public static void main(String[] args)
        {
       
                char[] chs = new char[]{'a','d','c','d','e','c'};
                System.out.println("从下标1开始字符c首次出现的位置为: "+indexOf(chs,1,'c'));
        }


        public static int indexOf(char[] chs, int startIndex, char ch)
        {
               
                for (int i=startIndex; i<chs.length; i++)
                {
                        if (chs==ch)
                        {
                                return i;
                        }
               
                }return -1;
               
        }
}

umbriel 发表于 2015-7-30 23:54
多更新点啊

希望可以帮到你:)

最后那个陀螺方阵还挺有意思的！

是啊。螺旋很有意思。

lz的螺旋代码不对哦。:)打印的是2维数组元素。需要2个角标的。

Day05

1. 请设计一个类Demo，这个类包含如下操作：
        A:求两个数的和。
        B:判断两个数是否相等。
        C:输出九九乘法表。
最后在测试类Test中进行测试。
/**
        请设计一个类Demo，这个类包含如下操作：
                A:求两个数的和。
                B:判断两个数是否相等。
                C:输出九九乘法表。
        最后在测试类Test中进行测试。
*/
class Demo
{     //求两个数的和。
        public  int sum(int a,int b)
        {
                return a+b;
        }
        //判断两个数是否相等。
        public  boolean equals(int a,int b)
        {
                if (a==b)
                {
                        System.out.println("两数相等");
                }return false;  //return a==b;
        }


        //输出九九乘法表。
        public static void jiu()
        {
                for (int x=1; x<=9;x++)
                        {
                                for (int y=1; y<=x; y++)
                                {
                                        System.out.print(y+"*"+x+"="+y*x+"\t");
                                }
                                System.out.println();
                        }
        }
}


//在测试类Test中进行测试。
class Test
{
        public static void main(String[] args)
        {
                Demo s = new Demo();


                System.out.println(s.sum(11,12));
                System.out.println("********");
                System.out.println(s.equals(11,12));
                System.out.println("********");
                s.jiu();
        }
}

2. 把今天视频中的装大象案例的伪代码，转换成可以运行的java代码，并以此了解面向对象的思想
/**
        把今天视频中的装大象案例的伪代码，
        转换成可以运行的java代码，并以此了解面向对象的思想
        1. 提取问题中的对象：大象，冰箱，测试
        2. 分析对象的属性和方法(功能)：
                大象：in();
                冰箱：open(),close()；
                测试：main();
        3. 分析对象之间的关系
*/
/**
        大象对象
*/
class  Elephant
{
        public void in()
        {
                System.out.println("装进大象");
        }
}


/**
        冰箱对象
*/
class IceBox
{
        public  void open()
        {
                System.out.println("打开冰箱");
        }
       
        public  void close()
        {
                System.out.println("关闭冰箱");
        }
}


/**
        测试对象
*/
class Test3
{
        public static void main(String[] args)
        {
                Elephant e = new Elephant();
                IceBox i = new IceBox();


                i.open();
                e.in();
                i.close();
        }
}

Day06

简答题目：
1：请解释面向对象是什么?并举例说明?
   定义：
        1.面向对象以对象为基础，将功能封装，强调具备了功能的对象 结果；
        2.面向对象是基于面向过程的；
        3.面向过程以函数为基础，实现各种功能操作，强调功能 行为。
  特点：
        1.将复杂问题简单化；
        2.将程序员从执行者变为指挥者；
        3.是一种更符合人类思考习惯的思想。
  举例：
        C语言是面向过程的；JAVA则是面向对象的；


        吃饭时在家里自己做饭菜是面向过程的，
        直接去饭馆点菜吃则是面向对象的


2：类与对象的关系?
        类是属性和行为的集合，是抽象的概念；
        对象是类具体的体现 存在；
              属性（外在特征）——>成员变量
        对象：———————————————:类
              行为（功能特性）——>成员方法

3：类有哪些内容组成?
        成员变量: 外在描述
        构造方法：对数据进行初始化
        成员方法：一些功能
4：局部变量和成员变量的区别?
   1.定义位置：成员变量：类中，方法外；
               局部变量：方法中，或作方法形参
   2.初始化：  成员变量：有默认初始化值
               局部变量：无，使用前需要先赋初值
   3.存储位置：成员变量：存在堆中，
               局部变量：存在栈中，     
   4.生存周期：成员变量：随对象的出现和消失而存在和消失
               局部变量：随方法的运行而出现，随方法的出栈而消失
5：构造方法的特点及注意事项?
        特点： 1.函数名与类名相同；
               2.无返回值类型
               3.无返回值
        注意事项：
               1.用来创建类的一个实例，并对实例的成员变量初始化
               2.类中无时，JAVA自动提供无参的构造方法，并按成员变量类型默认初始化
               3.类中可以有多个构造方法，即构造方法的重载
               4.最好自己给出无参的构造方法
6：this关键字是什么?在什么时候使用?
        1.this关键字代表其所在方法所属对象的引用；
          即：谁调用，this 就代表谁；
        2.用在解决局部变量隐藏成员变量值得问题
          通过this调用成员内容。
7：给成员变量赋值的方式有几种?分别怎么实现?
        1.定义时直接初始化；
        2.set()方法初始化，为推荐方法；
        3.构造方法里初始化
8：static关键字是什么?有什么特点?在什么时候使用?
        1.static关键字表静态，
        2.被它修饰的变量可被类中所以对象共享；
          它随着类的加载而加载；
          先于对象而存在；
          没有static修饰的其实是属于对象所特有的表述；
          可以被类名直接调用
        3.如果想在不创建对象的情况下就想调用某个方法，可以在方法前加static修饰
编程题目：
1：请写出一个标准的学生类(Student)
/**
        请写出一个标准的学生类(Student)
*/
class Student
{
        /**姓名，年龄/
        private String name;
        private int age;


        /**默认构造方法*/
        private Student(){}


        public Student(String name){
                this.name = name;
        }
        public Student(String name, int age){
                this.name = name;
                this.age = age;
        }


        /**定义show()方法，*/
        public void show(){
                System.out.println(this.name);
                System.out.println(this.age);


        }


        /**获取姓名*/
        public String getName(){


                return name;
        }
       
        /**给姓名赋值 通过this可以直接调用成员内容*/
        public void setName(String name){
                this.name = name;
        }


        public static void main(String[] args){
                Student p = new Student("李四",20);
                p.show();
        }
}                       
2：在测试类StudentTest中测试第一题的内容。
          ：同上题
3：编写代码测试下面这句话：
        静态方法只能访问静态成员(成员变量和成员方法)。
        /**
        编写代码测试下面这句话：
        静态方法只能访问静态成员(成员变量和成员方法)。
*/
class StudentDemo
{
        /**姓名*/
        private String name;
        private int age;
        static country = 中国;


        /**默认构造方法*/
        private StudentDemo(){}


        public StudentDemo(String name, int age){
                this.name = name;
                this.age = age;
                System.out.println(this.country);
        }


        /**定义show()方法，*/
        public void show(){
        //static void show(){
                System.out.println(this.name);
                System.out.println(this.age);
                System.out.println(this.country);


        }


        /**获取姓名*/
        public String getName(){


                return name;
        }

        /**给姓名赋值 通过this可以直接调用成员内容*/
        public void setName(String name){
                this.name = name;
        }


        public static void main(String[] args){
                StudentDemo p = new StudentDemo("李四",20);
                p.show();


        }


}
                               


4：自学Random类，使用Random类改进猜数字小程序。


/**
        猜数字游戏，直到猜中才结束(怎么设置次数限制，并且给出还剩多少次？？


*/
import java.util.Scanner;//导入需要的Scanner类


class  GuessNumber
{
        public static void main(String[] args)
        {
                /*
                        获取一个1-100的随机数
                */
                int number = (int)(Math.random()*100)+1;
                while (true)
                {
                        /*
                                获取从键盘输入的数据
                        */
                        Scanner sc = new Scanner(System.in);
                        System.out.println("请输入1-100之间的整数：");
                        int guessNumber = sc.nextInt();
                       
                        /*
                                将系统产生的随机数与用户输入的数据进行比较
                        */
                        if (guessNumber<number)
                        {
                                System.out.println("你输入的数据"+guessNumber+"小了");


                        }
                        else if (guessNumber>number)
                        {
                                System.out.println("你输入的数据"+guessNumber+"大了");
                        }
                        else if (guessNumber==number)
                        {
                                System.out.println("你猜对了! 恭喜，请前来领奖！");
                                break;//当猜对时，退出循环
                        }       
                }


        }
}

未完待续......

敬请期待！！！

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

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

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

Day10

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

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