日志2016-1-7

课堂笔记:

package newday;
/**
 * 父类(基类)
 */
public class Human extends Object{


/**
* 继承:Inheritance
* 继承是面向对象编程思想的重要特性之一,是从已有的类中派生出新的类
* 这个类吸收了其信息特征和行为特征,可以扩展自己的新能力,这种技术的存在可以大大提升代码的复用性
* 缩短了软件开发的周期,节约了开发成本
* 
* Java语言是面向对象编程思想的语言,其继承只能够是单继承的行为
* 也就是说,一个子类只能够拥有一个父类,被继承的这个父类也叫做基类.
* 
* 在Java中为了近似的现实多继承,可以使用实现接口的方法.
* 
* 通过extends关键字使用两个类建立继承关系
* 在继承的时候是一次继承所有,而不是选择性的继承
* 
* 如果在一个类定义中没有显示的写成extends关键字,则是默认继承Object类
* Object 是所有类层次结构中的根类,所有的类都直接或者间接的继承Object类
* 
* 关于继承的三点:
*        父类有的子类都有.
*        父类没有的子类可以增加.
*        父类原有的子类可以改变.
* 关键字final可以修饰类,可以修饰属性,可以修饰方法
*        final修饰的了是最终类,不能够被继承.
*        final修饰的属性,值不能够再次发生变化.
*        修饰的方法可以被继承,但是不能够被重写(覆盖).
*        
* 父类的私有属性和私有方法不能被外部可见.
*/

public String name;
public char gender;
public int age;

//private String color;
//空参构造
public Human(){
super();
System.out.println("Human类的空参构造");
}
//有参构造
public Human(String name,char gender,int age){
super();
this.name = name;
this.gender = gender;
this.age = age;

System.out.println("Human类的有参构造");
}
//public speak method
public void speak(){
System.out.println("I can speak...");
}
//public speak method
public final void eat(){
System.out.println("leaves");
}
//private sing method
private void sing(){
System.out.println("哦.....哦.....");
}
@Override
public String toString(){
return"Human[name="+name+",gender="+gender+",age="+age+",]";
}
}

package newday;
/**
 * 子类
 */
public class Student extends Human{


public String id;
public int score;
//空参构造
public Student(){
super();
System.out.println("Student类的空参构造");
}
//有参构造
public Student(String name,char gender,int age,String id,int score){
//System.out.println("Student类的有参构造");
super(name,gender,age);
this.id = id;
this.score = score;
System.out.println("Student类的有参构造");
}
//重写了父类的speak方法
@Override
public void speak(){
System.out.println("I can speak Chinese as well as English");
}
//Student 类自身特有的learn方法
public void lenrn(){
System.out.println("good good study,day day up");
}
//Cannot override the final method from Human
//public void eat(){}

@Override
public String toString(){
return"Student[id="+id+",score="+score+",name="+name+",gender="+gender+",age="+age+"]";
}
}

package newday;
/**
 * 子类
 */
public class Teacher extends Human{
/**
* 在一个类中不管哪一个构造方法被执行,都会首先去调用指定的父类的构造方法
* 就像现实生活中没有父亲就没有孩子一样
* 
* super:超前的,父类的
* super(参数):调用父类的构造方法.
* 在构造方法中只能写在第一行,也就是说在此代码之前不能够有任何的可执行代码
* 
* 方法的重写:
*      方法重写的标识是Override
*      重写发生在父子类之间
*      父类私有的方法即不能被继承也不能被重写
*      子类的限定修饰次范围可以与父类的一致,可以比父类的范围大,
*          但是绝对不能比父类范围小
*      重写的父子类方法返回值类型必须相同.
*      重写的父子类方法名必须完全一致.
*      如果有参数的话那么参数也必须完全保持一致.
*      
* 使用方法的重写的目的就是为了改变父类的方法实现,
* 
* 面试笔试题:
*      方法重载与重写的区别?
*/
public double salary;
//空参构造
public Teacher(){
super();
System.out.println("Teacher类的空参构造");
}
//有参构造
public Teacher(String name,char gender,int age,double salary){
super(name,gender,age);
this.salary = salary;
System.out.println("Teacher类的有参构造");
}
//teach method
public void teach(){
System.out.println("I teach programming");
}
//speak method
@Override
public void speak(){
System.out.println("I can speak Chinese");
}
@Override
public String toString(){
return"Teacher[name="+name+",gender="+gender+",age="+age+",salary="+salary+"]";
}


}

package newday;


public class Test {


public static void main(String[] args){
Student student = new Student();
System.out.println(student);

Student student2 = new Student("小明",'m',12,"9527",59);
System.out.println(student2);

student2.speak();
student2.lenrn();
student2.eat();
// sutdent2.sing()

Teacher teacher = new Teacher();
System.out.println(teacher);

Teacher teacher2 = new Teacher("苍老师",'f',22,998);

teacher2.speak();
teacher2.teach();
teacher2.eat();
}
}

package newday3;


public class Parent {

public String name;
public char gender;
public int age;

public Parent(){

}

public Parent(String name, char gender,int age){
this.name = name;
this.gender = gender;
this.age = age;
}
public void speak(){
System.out.println("I can speak Chinese");
}
public void work(){
System.out.println("working in a factory");
}

@Override
public String toString(){
// return super.toString();
return"Parent[name="+name+",gender"+gender+",age"+age+"]";
}


}

package newday3;


public class Son extends Parent{

public Son(){

}

public Son(String name,char gender,int age){
super(name,gender,age);
}
@Override
public void speak(){
System.out.println("I can speak Chinese as well as English");
}
public void play(){
System.out.println("play football");
}


}

package newday3;


public class Test {

public static void main(String[] args){

Parent p = new Parent("张翠山",'m',40);
System.out.println(p.toString());

//获得对象的hashCode值
int hashCode = p.hashCode();
//将对象的hashCode值转变为16进制的无符号位表示形式
String hex = Integer.toHexString(hashCode);
//如果没有在类中重写Object类中的toString()方法,则得到如下结果
String str = p.getClass().getName()+"@"+hex;
System.out.println(str);

p.speak();
p.work();

System.out.println("**************");

Son s = new Son();
s.speak();
s.play();

System.out.println("*****************");

/**
* 这里就是多态.
* 父类声明指向子类对象(上转型对象)
* 这是一种安全的行为
*/
Parent ps = new Son();

/**
* 父类声明指向子类对象(上转型对象)可以调用子类从父类中继承过来的方法,
* 可以调用子类中重写了父类的发那个发,但是不能够调用子类特有的方法.
* 
* 上转型对象调用方法的执行过程:
*       首先会去父类中查看是否有这个方法的定义,
*       如果有,则在子类中调用执行;
*       如果不存在,则编译报错.
*/

ps.speak();
ps.work();
//The method play() is undefined for the type Parent
//ps.play();
}


}

课后作业:

package newday2;


public class Demo {


public static void main(String[] args){
new D();

System.out.println("***************");

new B();

System.out.println("**************");

new D();
}
}


class A{

public A(){
System.out.println("A空参构造");
}
static{
System.out.println("这是A的静态代码块");
}
}


class B extends A{

public B(){
super();
System.out.println("B的空参构造");
}
static{
System.out.println("这是B的静态代码块");
}
}


class C extends B{

public C(){
super();
System.out.println("C的空参构造");
}
static {
System.out.println("这是C的静态代码块");
}
}


class D extends C{
public D(){
super();
System.out.println("D的空参构造");
}
static{
System.out.println("这是D的静态代码块");
}
}

package newday2;


public class Role {

public String name;
public char gender;
public int hp;

public int x;
public int y;

public Role(){

}
public Role(String name,char gender, int hp){
this.name = name;
this.gender = gender;
this.hp = hp;
}

public void attack(){
System.out.println("受到伤害,血量减少");
}
public void move(){
System.out.println("左移动,右移动");
}

@Override
public String toString(){
return"Role[name="+name+",gender="+gender+",hp="+hp+"]";
}


}

package newday2;


public class Hero extends Role{

//加上Hero特有的属性

public Hero(){

}
public Hero(String name,char gender,int hp){
super(name,gender,hp);
}
public void jump(){
System.out.println("比移动的更快");
}
public void attack(){
System.out.println("更多攻击方式");
}
@Override
public String toString(){
return"Hero[name"+name+",gender"+gender+",hp"+hp+",x"+x+",y="+y+"]";
}


}

package newday2;


public class Boss extends Role{

//自己的属性
//自身的构造

//随机的走动


}

package newday2;


public class Game {


//逻辑控制
}

package newday2;


public class Test {

public static void main(String[] args){

}


}

要求:建立坐标网.boss出在随机坐标上.

课后总结:    老师太黑