10（01）总结形式参数，包，修饰符，内部类

*/
//定义一个说英语的接口
interface SpeakEnglish {
 //说英语
 public abstract void speak();
}
//定义人的抽象类
abstract class Person {
 private String name;
 private int age;
 public Person() {}
 public Person(String name,int age) {
 this.name = name;
 this.age = age;
 }
 public String getName() {
 return name;
 }
 public void setName(String name) {
 this.name = name;
 }
 public int getAge() {
 return age;
 }
 public void setAge(int age) {
 this.age = age;
 }
 //睡觉
 public void sleep() {
 System.out.println("人都是要睡觉的");
 }
 //吃饭
 public abstract void eat();
}
//定义运动员抽象类
abstract class Player extends Person {
 public Player() {}
 public Player(String name,int age) {
 super(name,age);
 }
 //学习
 public abstract void study();
}
//定义教练抽象类
abstract class Coach extends Person {
 public Coach() {}
 public Coach(String name,int age) {
 super(name,age);
 }
 //教
 public abstract void teach();
}
//定义乒乓球运动员具体类
class PingPangPlayer extends Player implements SpeakEnglish {
 public PingPangPlayer(){}
 public PingPangPlayer(String name,int age) {
 super(name,age);
 }
 //吃
 public void eat() {
 System.out.println("乒乓球运动员吃大白菜，喝小米粥");
 }
 //学习
 public void study() {
 System.out.println("乒乓球运动员学习如何发球和接球");
 }
 //说英语
 public void speak() {
 System.out.println("乒乓球运动员说英语");
 }
}
//定义篮球运动员具体类
class BasketballPlayer extends Player {
 public BasketballPlayer(){}
 public BasketballPlayer(String name,int age) {
 super(name,age);
 }
 //吃
 public void eat() {
 System.out.println("篮球运动员吃牛肉，喝牛奶");
 }
 //学习
 public void study() {
 System.out.println("篮球运动员学习如何运球和投篮");
 }
}
//定义乒乓球教练具体类
class PingPangCoach extends Coach implements SpeakEnglish {
 public PingPangCoach(){}
 public PingPangCoach(String name,int age) {
 super(name,age);
 }
 //吃
 public void eat() {
 System.out.println("乒乓球教练吃小白菜，喝大米粥");
 }
 //教
 public void teach() {
 System.out.println("乒乓球教练教如何发球和接球");
 }
 //说英语
 public void speak() {
 System.out.println("乒乓球教练说英语");
 }
}
//定义篮球教练具体类
class BasketballCoach extends Coach {
 public BasketballCoach(){}
 public BasketballCoach(String name,int age) {
 super(name,age);
 }
 //吃
 public void eat() {
 System.out.println("篮球教练吃羊肉，喝羊奶");
 }
 //教
 public void teach() {
 System.out.println("篮球教练教如何运球和投篮");
 }
}
class InterfaceDemo {
 public static void main(String[] args) {
 //测试运动员(乒乓球运动员和篮球运动员)
 //乒乓球运动员
 PingPangPlayer ppp = new PingPangPlayer();
 ppp.setName("王浩");
 ppp.setAge(33);
 System.out.println(ppp.getName()+"---"+ppp.getAge());
 ppp.eat();
 ppp.sleep();
 ppp.study();
 ppp.speak();
 System.out.println("----------------");
 //通过带参构造给数据(留给你们)
 //篮球运动员
 BasketballPlayer bp = new BasketballPlayer();
 bp.setName("姚明");
 bp.setAge(34);
 System.out.println(bp.getName()+"---"+bp.getAge());
 bp.eat();
 bp.sleep();
 bp.study();
 //bp.speak(); //没有该方法
 //测试教练自己做
 }
}

*/
class Student {
 public void study() {
 System.out.println("Good Good Study,Day Day Up");
 }
}
class StudentDemo {
 public void method(Student s) { //ss; ss = new Student();  Student s = new Student();
 s.study();
 }
}
class StudentTest {
 public static void main(String[] args) {
 //需求：我要测试Student类的study()方法
 Student s = new Student();
 s.study();
 System.out.println("----------------");
 //需求2：我要测试StudentDemo类中的method()方法
 StudentDemo sd = new StudentDemo();
 Student ss = new Student();
 sd.method(ss);
 System.out.println("----------------");
 //匿名对象用法
 new StudentDemo().method(new Student());
 }
}
/*
 形式参数：
 基本类型(太简单，不是我今天要讲解的)
 引用类型
 类名:(匿名对象的时候其实我们已经讲过了)需要的是该类的对象
 抽象类:需要的是该抽象的类子类对象
 接口
*/
abstract class Person {
 public abstract void study();
}
class PersonDemo {
 public void method(Person p) {//p; p = new Student();  Person p = new Student(); //多态
 p.study();
 }
}
//定义一个具体的学生类
class Student extends Person {
 public void study() {
 System.out.println("Good Good Study,Day Day Up");
 }
}
class PersonTest {
 public static void main(String[] args) {
 //目前是没有办法的使用的
 //因为抽象类没有对应的具体类
 //那么，我们就应该先定义一个具体类
 //需求：我要使用PersonDemo类中的method()方法
 PersonDemo pd = new PersonDemo();
 Person p = new Student();
 pd.method(p);
 }
}
/*

*/
//定义一个爱好的接口
interface Love {
 public abstract void love();
}
class LoveDemo {
 public void method(Love l) { //l; l = new Teacher();  Love l = new Teacher(); 多态
 l.love();
 }
}
//定义具体类实现接口
class Teacher implements Love {
 public void love() {
 System.out.println("老师爱学生,爱Java,爱林青霞");
 }
}
class TeacherTest {
 public static void main(String[] args) {
 //需求：我要测试LoveDemo类中的love()方法
 LoveDemo ld = new LoveDemo();
 Love l = new Teacher();
 ld.method(l);
 }
}

/*
 返回值类型
 基本类型:(基本类型太简单，我不准备讲解)
 引用类型：
 类:返回的是该类的对象
 抽象类:
 接口:
*/
class Student {
 public void study() {
 System.out.println("Good Good Study,Day Day Up");
 }
}
class StudentDemo {
 public Student getStudent() {
 //Student s = new Student();
 //Student ss = s;
 //Student s = new Student();
 //return s;
 return new Student();
 }
}
class StudentTest2 {
 public static void main(String[] args) {
 //需求：我要使用Student类中的study()方法
 //但是，这一次我的要求是，不要直接创建Student的对象
 //让你使用StudentDemo帮你创建对象
 StudentDemo sd = new StudentDemo();
 Student s = sd.getStudent(); //new Student(); Student s = new Student();
 s.study();
 }
}
/*
 返回值类型
 基本类型:(基本类型太简单，我不准备讲解)
 引用类型：
 类:返回的是该类的对象
 抽象类:返回的是该抽象类的子类对象
 接口:
*/
abstract class Person {
 public abstract void study();
}
class PersonDemo {
 public Person getPerson() {
 //Person p = new Student();
 //return p;
 return new Student();
 }
}
class Student extends Person {
 public void study() {
 System.out.println("Good Good Study,Day Day Up");
 }
}
class PersonTest2 {
 public static void main(String[] args) {
 //需求：我要测试Person类中的study()方法
 PersonDemo pd = new PersonDemo();
 Person p = pd.getPerson(); //new Student();  Person p = new Student(); 多态
 p.study();
 }
}
/*
 返回值类型
 基本类型:(基本类型太简单，我不准备讲解)
 引用类型：
 类:返回的是该类的对象
 抽象类:返回的是该抽象类的子类对象
 接口:返回的是该接口的实现类的对象
*/
//定义一个爱好的接口
interface Love {
 public abstract void love();
}
class LoveDemo {
 public Love getLove() {
 //Love l = new Teacher();
 //return l;
 return new Teacher();
 }
}
//定义具体类实现接口
class Teacher implements Love {
 public void love() {
 System.out.println("老师爱学生,爱Java,爱林青霞");
 }
}
class TeacherTest2 {
 public static void main(String[] args) {
 //如何测试呢?
 LoveDemo ld = new LoveDemo();
 Love l = ld.getLove(); //new Teacher(); Love l = new Teacher(); 多态
 l.love();
 }
}

/*
 链式编程。
 每次调用完毕方法后，返回的是一个对象。
*/
class Student {
 public void study() {
 System.out.println("Good Good Study,Day Day Up");
 }
}
class StudentDemo {
 public Student getStudent() {
 return new Student();
 }
}
class StudentTest3 {
 public static void main(String[] args) {
 //如何调用的呢?
 StudentDemo sd = new StudentDemo();
 //Student s = sd.getStudent();
 //s.study();
 //大家注意了
 sd.getStudent().study();
 }
}

 cn.itcast.add
 AddStudent
 AddTeacher
 cn.itcast.delete
 DeleteStudent
 DeleteTeacher
 cn.itcast.update
 UpdateStudent
 UpdateTeacher
 cn.itcast.find
 FindStudent
 FindTeacher
 方案2：按照模块分
 cn.itcast.teacher
 AddTeacher
 DeleteTeacher
 UpdateTeacher
 FindTeacher
 cn.itcast.student
 AddStudent
 DeleteStudent
 UpdateStudent
 FindStudent

*/
package cn.itcast;
class HelloWorld {
 public static void main(String[] args) {
 System.out.println("HelloWorld");
 }
}

/*
 Test类，测试
 导包：
 格式：import 包名;
 这种方式导入是到类的名称。
 注意：我们用谁就导谁。
 面试题：
 package,import,class有没有顺序关系?
 有。
 package > import > class
 Package:只能有一个
 import:可以有多个
 class:可以有多个，以后建议是一个
*/
package cn.itcast;
import com.liuyi.Demo;
class Test {
 public static void main(String[] args) {
 //Demo d = new Demo();
 /*
 com.liuyi.Demo d = new com.liuyi.Demo();
 System.out.println(d.sum(10,20));
 com.liuyi.Demo d2 = new com.liuyi.Demo();
 System.out.println(d2.sum(10,20));
 com.liuyi.Demo d3 = new com.liuyi.Demo();
 System.out.println(d3.sum(10,20));
 com.liuyi.Demo d4 = new com.liuyi.Demo();
 System.out.println(d4.sum(10,20));
 */
 Demo d = new Demo();
 System.out.println(d.sum(10,20));
 }
}
/*
 第一个问题：找不到Demo
 第二个问题：程序包com.liuyi不存在
 第三个问题： Demo在com.liuyi中不是公共的; 无法从外部程序包中对其进行访问
*/

/*
 权限修饰符：
 本类 同一个包下(子类和无关类) 不同包下(子类) 不同包下(无关类)
 private  Y 
 默认 Y Y
 protected Y Y Y
 public Y Y Y Y
*/
package com.liuyi;
public class Father {
 private void show() {
 System.out.println("show");
 }
 void show2() {
 System.out.println("show2");
 }
 protected void show3() {
 System.out.println("show3");
 }
 public void show4() {
 System.out.println("show4");
 }
 public static void main(String[] args) {
 Father f = new Father();
 f.show();
 f.show2();
 f.show3();
 f.show4();
 }
}

 public static final int X = 10;
 public static void show() {}
 public final void show() {}
 public abstract void show();
/*
 修饰符：
 权限修饰符：private，默认的，protected，public
 状态修饰符：static，final
 抽象修饰符：abstract
 类：
 权限修饰符：默认修饰符，public
 状态修饰符：final
 抽象修饰符：abstract
 用的最多的就是：public
 成员变量：
 权限修饰符：private，默认的，protected，public
 状态修饰符：static，final
 用的最多的就是：private
 构造方法：
 权限修饰符：private，默认的，protected，public
 用的最多的就是：public
 成员方法：
 权限修饰符：private，默认的，protected，public
 状态修饰符：static，final
 抽象修饰符：abstract
 用的最多的就是：public
 除此以外的组合规则：
 成员变量：public static final
 成员方法：public static 
           public abstract
   public final
*/
//此处不允许使用修饰符private
//此处不允许使用修饰符protected
//此处不允许使用修饰符static
public class Demo {
 //成员变量
 private int x = 10;
 int y = 20;
 protected int z = 30;
 public int a = 40;
 public final int b = 50;
 public static int c = 60;
 public static final int d = 70;
 //此处不允许使用修饰符abstract
 //abstract int e = 80;
 //构造方法
 private Demo(){}
 Demo(String name){}
 protected Demo(String name,int age) {}
 public Demo(String name,int age,String address) {}
 //此处不允许使用修饰符static
 //public static Demo(){}
 //此处不允许使用修饰符final
 //public final Demo() {}
 //此处不允许使用修饰符abstract
 //public abstract Demo(){}
 //成员方法
 //static void show() {}
 //abstract void show();
 //final void show(){}
}
package com.liuyi;
public class Son extends Father {
 public static void main(String[] args) {
 Father f = new Father();
 //f.show();
 f.show2();
 f.show3();
 f.show4();
 System.out.println("--------------");
 Son s = new Son();
 //s.show();
 s.show2();
 s.show3();
 s.show4();
 }
}
package cn.qx;
import com.liuyi.Father;
public class Son2 extends Father {
 public static void main(String[] args) {
 Father f = new Father();
 //f.show();
 //f.show2();
 //f.show3();
 f.show4();
 System.out.println("--------------");
 Son2 s = new Son2();
 //s.show();
 //s.show2();
 s.show3();
 s.show4();
 }
}
package com.liuyi;
public class Test {
 public static void main(String[] args) {
 Father f = new Father();
 //f.show();
 f.show2();
 f.show3();
 f.show4();
 }
}
package cn.qx;
import com.liuyi.Father;
class Test2 {
 public static void main(String[] args) {
 Father f = new Father();
 //f.show();
 //f.show2();
 //f.show3();
 f.show4();
 }
}