java4android十八集到20集。。记录

第18集  继承初步.

1.什么是继承.
2.为什么要使用继承.
3.继承的基本语法特点.

在面向对象的世界当中,继承就是一个类得到了另外一个类当中的成员变量和成员方法.

java当中只支持单继承,不允许多继承.
一个子类只能继承一个父类！！
但在C++里面一个子类可以有多个父类.

关键字extends.扩展.

面对对象的终极目标是减少应该程序的重复代码.
其实继承一方面就是为了减少重复的代码.

class Person{  	    
		String name;  	   
		int age;  
	      
	  void eat(){  
	        System.out.println("吃饭");  
	        }  
	          
	    void introduce(){  
	        System.out.println("我的名字是" + name + "年龄" + age);  
	    }  
	}  

	class Student extends Person{  
	    int grade;  
      
      void study(){  
	        System.out.println("学习");  
	          
	    }  
	}  

	class TestStu{  
	    public static void main(String args[])  
	    {  
	        Student student = new Student();  
	        student.name = " 张三 ";  
	        student.age  = 15;  
          
	        student.grade = 3;  
	          
        student.eat();  
        student.introduce();  
        student.study();  
	    }  
	}  

总结 :
1.使用继承是为了减少重复代码.

2.继承的基本语法.带有点扩展的意思在里面.

第19集       子类实例化过程.

 本集主要内容.
  1.生成子类的过程.
  2.使用super调用父类构造函数的方法.
 
  由于子类继承了父类的成员变量,却无法继承父类的构造函数 所以,在为成员变量赋值的时候有可能会出现重复代码,
  为了解决这个问题,子类可以使用super调用父类的构造函数,

class Person19{  
      String name;  
	    int age;  
	    Person19(){ 	              
	        System.out.println("Person的无参数构造函数");  
	    }  
	    Person19(String name,int age){  
	        this.name = name;  
        	this.age = age;  
	        System.out.println("Person的有参数构造函数");  
	    }  
	    void eat(){  
	        System.out.println("吃饭");  
        }  
	}  


	class Student19 extends Person19{  
	    int grade;  
    //在子类的构造函数当中,必须调用父类的构造函数,为什么?  减少重复代码
	    Student19(){  
	        super(); //调用父类的构造函数,如果用户没有写,编译器会自动添加.,在函数的第一句语句.  
	        System.out.println("Student 无参数构造函数");        
	    }  
	      
	    Student19(String name,int age,int grade){  
	       //this.name = name;  
        //this.age =age;  
        super(name,age);//调用父类的构造函数  
        this.grade =grade;  
    }  
	}  

	class Test19{  
	    public  static void main(String args[]){  
	        Student19 student  = new Student19("zhangsan",18,3);  
	        System.out.println(student.name);  //注意这的括号内的变量不给加引号
	        System.out.println(student.age);  
	        System.out.println(student.grade);  
	    }  
	}  

二十集

本集主要内容.
  1.函数的复写(override).
   2.使用super调用父类的成员函数.
   
  复写与重载是不同的.
   复写在两个类中,在父类与子类中.
   重载在一个类中.

	class Person20{  
	    String name;  
   		int age;	      
	    void introduce(){  
	        System.out.println("我的名字"+ name+"年龄"+age);  
	    }  
	}
	//复写(override)也称之为覆盖或者重写  
	//1.在具有父子关系的两个类当中.  
	//2.父类和子类各有一个函数,这两个函数的定义(返回值 ,函数名和参数列表)完全相同  
	  
	class Student20 extends Person20{  
	    String address;  
	      
    void introduce(){  
        //anotherFun();  
        super.introduce();//调用父类的成员函数,减少重复代码,  
	        //System.out.println("我的姓名是"+name+"我的年龄是"+age);  
	        System.out.println("我的家在"+address);  
	    }  
	}  

	class Test20{  
	    public static void main(String args[]){  
	        Student20 s = new Student20();  
	        s.name = "张三";  
	        s.age  = 20;  
	        s.address = "深圳";     
	        s.introduce();  
	        Person20 p = new Person20();  
	                  
	        //p.name = "李四";  
          //p.age = 30;  
	        //p.introduce();  
	        //p.address = "广州";  
	    }  
	}