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(); //没有该方法
 //测试教练自己做
 }
}

1:形式参数和返回值的问题(理解)

(1)形式参数:

类名:需要该类的对象

抽象类名:需要该类的子类对象

接口名:需要该接口的实现类对象

/*

形式参数:

基本类型(太简单,不是我今天要讲解的)

引用类型

类名:(匿名对象的时候其实我们已经讲过了) 需要的是该类的对象

抽象类:

接口

*/
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);
 }
}

(2)返回值类型:

类名:返回的是该类的对象

抽象类名:返回的是该类的子类对象

接口名:返回的是该接口的实现类的对象

/*
 返回值类型
 基本类型:(基本类型太简单,我不准备讲解)
 引用类型:
 类:返回的是该类的对象
 抽象类:
 接口:
*/
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();
 }
}

(3)链式编程

对象.方法1().方法2().......方法n();

这种用法:其实在方法1()调用完毕后,应该一个对象;

方法2()调用完毕后,应该返回一个对象。

方法n()调用完毕后,可能是对象,也可以不是对象。

/*
 链式编程。
 每次调用完毕方法后,返回的是一个对象。
*/
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();
 }
}

2:包(理解)

(1)其实就是文件夹

(2)作用:

A:区分同名的类

B:对类进行分类管理

a:按照功能分

b:按照模块分

/*

包:

A:其实就是文件夹

B:作用

a:把相同的类名放到不同的包中

b:对类进行分类管理

举例:

学生:增加,删除,修改,查询

老师:增加,删除,修改,查询

...

方案1:按照功能分

 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 包名;

多级包用.分开即可

注意事项:

A:package语句必须是程序的第一条可执行的代码

B:package语句在一个java文件中只能有一个

C:如果没有package,默认表示无包名

带包的编译和运行:

A:手动式

a:编写一个带包的java文件。

b:通过javac命令编译该java文件。

c:手动创建包名。

d:把b步骤的class文件放到c步骤的最底层包

e:回到和包根目录在同一目录的地方,然后运行

带包运行。

B:自动式

a:编写一个带包的java文件。

b:javac编译的时候带上-d即可

javac -d . HelloWorld.java

c:回到和包根目录在同一目录的地方,然后运行

带包运行。

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

(3)包的定义(掌握)

package 包名;

多级包用.分开。

(4)注意事项:(掌握)

A:package语句必须在文件中的第一条有效语句

B:在一个java文件中,只能有一个package

C:如果没有package,默认就是无包名

(5)带包的编译和运行

A:手动式

B:自动式(掌握)

javac -d . HelloWorld.java

3:导包(掌握)

(1)我们多次使用一个带包的类,非常的麻烦,这个时候,Java就提供了一个关键字import。

(2)格式:

import 包名...类名;

另一种:

import 包名...*;(不建议)

(3)package,import,class的顺序

package > import > class

/*
 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中不是公共的; 无法从外部程序包中对其进行访问
*/

4:权限修饰符(掌握)

(1)权限修饰符

本类 同一个包下 不同包下的子类 不同包下的无关类

private Y

默认 Y Y

protected Y Y Y

public Y Y Y Y

(2)这四种权限修饰符在任意时刻只能出现一种。

public class Demo {}

/*
 权限修饰符:
 本类 同一个包下(子类和无关类) 不同包下(子类) 不同包下(无关类)
 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();
 }
}

5:常见的修饰符(理解)

(1)分类:

权限修饰符:private,默认,protected,public

状态修饰符:static,final

抽象修饰符:abstract

(2)常见的类及其组成的修饰

类:

默认,public,final,abstract

常用的:public

成员变量:

private,默认,protected,public,static,final

常用的:private

构造方法:

private,默认,protected,public

常用的:public

成员方法:

private,默认,protected,public,static,final,abstract

常用的:public

(3)另外比较常见的:

 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();
 }
}

本文分享自微信公众号 - Java帮帮(javahelp)

原文出处及转载信息见文内详细说明,如有侵权,请联系 yunjia_community@tencent.com 删除。

原始发表时间:2016-11-30

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏xx_Cc的学习总结专栏

iOS-正则表达式的简单使用

50770
来自专栏Golang语言社区

Golang面试题

最近在很多地方看到了golang的面试题,看到了很多人对Golang的面试题心存恐惧,也是为了复习基础,我把解题的过程总结下来。 面试题 写出下面代码输出内容。...

1.2K90
来自专栏锦小年的博客

python学习笔记2.5-数据结构之字典

Python中的字典是python的一种数据结构,它的本质是key和value以及其对应关系的一种集合,一个key可以对应一个多个value。合理的使用字典能给...

22070
来自专栏闻道于事

Java基础类库

54460
来自专栏Hongten

python开发_python中的Boolean运算和真假值

25710
来自专栏王小雷

Python之NumPy实践之数组和矢量计算

Python之NumPy实践之数组和矢量计算 1. NumPy(Numerical Python)是高性能科学技术和数据分析的基础包。 2. NumPy的nda...

28680
来自专栏小工匠技术圈

【小工匠聊密码学】-- Base64算法

16330
来自专栏Golang语言社区

【Golang语言社区】Golang语言面试题

最近在很多地方看到了golang的面试题,看到了很多人对Golang的面试题心存恐惧,也是为了复习基础,我把解题的过程总结下来。

1.9K250
来自专栏猿人谷

一个正则表达式测试(只可输入中文、字母和数字)

  在项目中碰到了正则表达式的运用,正则还是非常强大的,不管什么编程语言,基本上都可以用到。之前在用java时特别是对用户名或密码使用正则非常爽,写脚本上用正则...

1K60
来自专栏数据结构与算法

BZOJ3671: [Noi2014]随机数生成器(贪心)

第1行包含5个整数,依次为 x_0,a,b,c,d ,描述小H采用的随机数生成算法所需的随机种子。第2行包含三个整数 N,M,Q ,表示小H希望生成一个1到 N...

9520

扫码关注云+社区

领取腾讯云代金券