12月30日 面向对象04------类的练习、包

//类 抽象类 接口的案例
/*
有足球运动员和篮球运动员
    足球教练和篮球教练
为了出国交流 跟足球相关的人员都需要学习英语
*/


abstract class People
{
abstract void eat();
}
//创建一个运动员类
//属性：姓名 年龄
//功能：比赛 训练 吃饭


abstract class SportMan
{
String name;
int age;
public void eat()
{
System.out.println("吃饭");
}
abstract void train();
abstract void match();
abstract void show();
}
//创建一个教练类
//属性：姓名 年龄
//功能：教学 吃饭
abstract class Coach
{
String name;
int age;
public void eat()
{
System.out.println("吃饭");
}
abstract void teach();
abstract void show();
}




//创建一个学英语的接口
interface StudyEnglish
{
public abstract void study();
}


//足球运动员类
class FootballPlayer extends SportMan implements StudyEnglish
{

public void train()
{
System.out.println("射门训练");
}
public void match()
{
System.out.println("中超联赛");
}
public void show()
{
System.out.println("这是一名足球运动员，他的名字叫："+this.name+
",他今年"+this.age+"岁。");
}
public void study()
{
System.out.println("运动员学英语");
}
}


//篮球运动员类
class BasketballPlayer extends SportMan
{
public void train()
{
System.out.println("投篮训练");
}
public void match()
{
System.out.println("NBA");
}
public void show()
{
System.out.println("这是一名篮球运动员，他的名字叫："+this.name+
",他今年"+this.age+"岁。");
}


}


//足球教练
class FootBallCoach extends Coach implements StudyEnglish
{
public void teach()
{
System.out.println("教人踢球");
}
public void show()
{
System.out.println("这是一名足球教练，他的名字叫："+this.name+
",他今年"+this.age+"岁。");
}
public void study()
{
System.out.println("教练在学英语");
}
}


//篮球教练
class BasketBallCoach extends Coach
{
public void teach()
{
System.out.println("教人投篮");
}
public void show()
{
System.out.println("这是一名篮球教练，他的名字叫："+this.name+
",他今年"+this.age+"岁。");
}
}






//测试类
public class FuZiDemo
{
public static void main(String[] args)
{
SportMan sport = new FootballPlayer();
FootballPlayer fbp = (FootballPlayer)sport;
fbp.name = "杨旭";
fbp.age = 27;
fbp.show();
fbp.train();
}
}




形参和返回值的问题


形参：
基本类型
引用类型：
  类：（匿名对象) 需要的是一个该类的对象


  抽象类：需要的是该抽象类的子类对象
  abstract class Person
{
abstract void study();
}


class Student extends Person
{
void study()
{
System.out.println("OK");
}
}


class PersonDemo
{
public void method(Person p)
{
p.study();
}
}


public class FuZiDemo
{
public static void main(String[] args)
{
PersonDemo pd = new PersonDemo();
Person p = new Student();
pd.method(p);
}
}
 


 接口：需要的是该接口实现类的对象
interface Love
{
abstract void love();
}


class LoveDemo 
{
public void method(Love l)
{
l.love();
}
}


class Person implements Love
{
public void love()
{
System.out.println("love love love");
}
}


public class FuZiDemo
{
public static void main(String[] args)
{
LoveDemo ld = new LoveDemo();
Love l = new Person();
ld.method(l);
}
}




返回值类型
  基本类型：
  引用类型：
      类 
      抽象类：返回的是该抽象类的子类对象
      接口：返回的是该接口实现类的对象




链式编程：每次调用完毕后，返回的是一个对象




包：其实就是文件夹
 作用：
    把相同的类名放到不同的包中
    对类进行分类管理
按照模块和功能分


package 包名;
为程序的第一条可执行代码
只能有一个package语句


带包的编译和运行
A 手动式：
   a.编写带包的java文件
   b。通过javac编译
   c.手动创建包名
   d。将b中的class文件放在c目录的最底层
java cn.ysck.HelloWorld


B 自动式
  javac -d . *.java


不同包下的类之间的访问：
导包：import 
import 包名.类名;


package class import之间的顺序：
package（只能有一个） > import（可以有多个） > class（可以有多个，但是建议只一个）




权限修饰符
              本类       同一个包       不同的包下（子类）   不同的包下（无关类）
private        Y                                                                 
默认           Y           Y                                                         
protected      Y           Y                Y                                     
public         Y           Y                Y                     Y                  




类及其组成所常用的修饰符


用于修饰类：public final abstract
成员变量：private protected public static final
构造方法：public protected private
成员方法：private protected public static final abstract