java基础（3）

一个对象调用另一个对象：

Public class Teacher{

  PrivateString name;

 Private String subject;

 Public teacher(){}

 Public teacher(String name,String subject){

  This.name=name;

  This.subject=subject;

}

Public void teaching(){

  System,out.println(name+“isteaching”+subject);

}

}

Public class student(){

 PrivateString name;

 Public student(){}

 Public student(String name){

 This.name=name;

}

Public void study(){

 Teacherteaher1=new Teacher(“cindy”,”software”);

 Teacher1.teaching();

System.out.println(name+”is study…”);

}

}

Public class test1{

  Publicstatic void main(String[] arg){

  Student student1=newStudent(“jack”);

  Student1.study();

}

}

多个类打包成一个应用程序（jar包）

对象间继承：

Public class Father{

 //成员变量，成员方法会被子类继承

 PublicString name;//private不能被子类继承，不能被子类使用

  PublicString bloodType;

 Public void work(){

  System,out.println(“fatheris working…”);

}

}

 

Public class Son extendsFather{

 Public static void main(String[] args){

  Father objf=new Father();

  Son objs= new Son();

  Objs.work();

  Objs.name=”jack”;

  System.out.println(objs.name);

}

}

方法的覆盖：

方法的重载overloading（是在一个类中出现多个同名方法，方法的名称相同，参数不同）

方法的覆盖overriding（子类重写父类的同名方法）

Public class Father{

 Publicvoid print(){

 System.out.println(“fatherprintln”);

}

}

Public class Son extends Father{

//方法的覆盖：子类重写父类的同名方法

 Public void print(){

 System.out.println(“sonprintln”);

}

}

覆盖的原则：1.子类方法的参数必须跟父类保持一致

           2.子类方法的修饰符的范围必须大于等于父类同名方法的修饰符

父类对象 = new 子类（）；

Father obj = new Son();//多态：obj只能调用子类继承或覆盖下来的方法，不能调用父类没有的，子类自己独有的方法

Obj.print();//输出的是父类的print还是子类的print方法？子类的方法

This和super：

Public class base{

  Publicbase(){

   System.out.println(“base类的初始构造方法”)；

}

  Publicbase(){

   System.out.println(“base类的重载构造方法”)；

}

Public void a(){

  System,out,println(“base的a方法”);

}

Public void b(){

//b方法调用a方法，a方法和b方法平级

This.a();

}

}

Public class sub extends base{

 Public sub(){

   //调用父类的构造方法

Super(100);

Super.a();//调用父类对象的方法

  System,out,println(“sub类的初始构造方法”);

}

 Public static void main(String[] args){

  //子类的对象构造时会先调用父类的构造方法再调用sub类的构造方法

Sub obj=new sub();//打印base类的初始构造方法  and sub类的初始构造方法

}

}

不该初始化的class：

抽象的类：abstract class,不能初始化对象的类，抽象类的目的就是为了被子类继承

Public abstract class animal{

  //抽象类中既可以有成员变量，构造方法，和成员方法

 Public string name;

 Public animal(){}

 Public void eat(){}

  //抽象类中可以有抽象方法：没有方法体的方法(没有花括号)

  Public abstract void run()

}

Public class tiger extends animal{

  //抽象类的抽象方法必须被子类继承和覆盖

  Public void run(){

  System.out.println(“tigerrunning…”);

}

}

Public class Test1{

  Publicstatic void main(string[] args){

  //animal ani1 = newanimal();//错误，abstract不能实例化对象

  Tiger tig1 = new tiger();//正确

}

}

接口：

抽象的最高实现

定义接口都是为了被继承

Public interface person{

//接口中的方法全部是抽象方法,所以可以省略abstract

  Publicabstract void a();

 Public void b();

  //接口中的成员变量都是public static final，必须是公共的，静态的，最终的，代表变量只//能被初始化一次不能再次赋值

  Public staticfinal int age=1;//或者int age=1;

}

//当子类实现接口的时候，必须覆盖接口中所有的方法

Public class Student implements person{

  Public void a(){};

  Public void b(){};

}

如何组织类和包：

如何使用java API：应用编程接口