Java学习日志Day13_形式参数问题_包_权限修饰符_综合练习题

最新推荐文章于 2022-11-10 20:54:27 发布

igfff

最新推荐文章于 2022-11-10 20:54:27 发布

阅读量167

点赞数 1

分类专栏：学习文章标签： java 编程语言多态接口

本文链接：https://blog.csdn.net/igfff/article/details/116805066

版权

学习专栏收录该内容

42 篇文章 1 订阅

订阅专栏

一、形式参数问题

形式参数问题研究
基本数据类型, 实际参数传递的是当前这个数据值!
引用数据类型
数组:需要传递数组对象
类: 具体类:传递的当前类的对象

举例1：
//定义一个类Demo
class Demo{
    public int add(int a,int b){ //形式参数:基本数据类型
        return a + b;
    }
}

//学生类
class Student{
    public void study(){
        System.out.println("学习JavaSE");
    }
}
class StudentDemo{
    public void method(Student s){ //形式参数:引用类型: 具体类---传递的当前类的对象!
        s.study();
    }

}
public class ArgsDemo {
    public static void main(String[] args) {

        //创建Demo类对象
        Demo d  = new Demo() ;
        int result = d.add(10, 20);
        System.out.println(result);

        System.out.println("------------------------");
        //访问的StudentDemo类中method方法
        StudentDemo studentDemo = new StudentDemo() ;
        Student s = new Student() ;
        studentDemo.method(s) ;
        //studentDemo.method(new Student());

        System.out.println("------------------------");
        new StudentDemo().method(new Student());
    }
}

1.1 方法的形式参数引用类型:
如果是抽象类型,如何传递呢?
调用该方法,实际参数需要传递的是当前抽象类的子类对象! (抽象类多态)

举例2：
//定义一个Person类,抽象类
abstract class Person{

    //定义一个抽象方法
    public abstract void work() ;
}
//定义PersonDemo类
class PersonDemo{
    public void show(Person p){ //形式参数引用类型:抽象类   Person person = new 子类名() ;
        p.work();
    }
}

//需要提供抽象类的子类:具体类
class Worker extends  Person{

    @Override
    public void work() {
        System.out.println("爱生活,爱工作,爱Java...");
    }
}

//测试类
public class ArgsDemo2 {
    public static void main(String[] args) {
        //要访问PersonDemo类中的show方法?
        //创建PersonDemo类的对象
        PersonDemo pd = new PersonDemo() ;
//        Person p = new Person() ;抽象类不能实例化
        //抽象类多态
        Person p = new Worker() ; //父类引用指向子类对象
        pd.show(p) ;

        System.out.println("---------------------");
        pd.show(new Worker()); //匿名对象
    }
}

1.2 方法的形式参数引用类型:
如果是接口类型,如何传递呢?
那么调用该方法,实际参数需要传递的是当前接口的子实现类对象!
通过接口多态来进行实例化!

举例3：
//定义一个接口
interface Love{
    void love() ;
}
//定义一个类LoveDemo
class LoveDemo{
    public void function(Love l){//形式参数是引用类型, 接口类型---实际参数需要传递这个接口的子实现类对象
                                        //接口多态:Love l = new LoveImpl() ;
        l.love() ;
    }
}
//定义接口的子实现类
class LoveImpl implements  Love{

    @Override
    public void love() {
        System.out.println("love Java...") ;
    }
}

//测试类
public class ArgsDemo3 {
    public static void main(String[] args) {
        //要访问LoveDemo类中的function方法,如何访问?

        //创建LoveDemo类的对象
        LoveDemo ld = new LoveDemo() ;
        //Love love= new Love() ;接口不能实例化

        //接口多态
        Love love = new LoveImpl() ;
        ld.function(love);
    }
}

研究返回值问题
方法的返回值类型:
基本数据类型:----返回当前基本类型的具体数据值即可!
引用数据类型 :
如果返回值类型是一个具体类,方法如何结束?
方法return 需要的该具体类对象!

举例4：
import  java.util.Scanner ;
//定义一个User类
class User{
    public boolean login(String username,String password){
        //登录的业务
        //假设:如果当前username就是"eric",
        //密码就是"123456"
        if("eric".equals(username) && "123456".equals(password)){
            System.out.println("登录成功");
            return true ;
        }else{
            System.out.println("登录失败");
            return false ;
        }
    }
}

//定义学生类
class Student{
    public void study(){
        System.out.println("天道酬勤...");
    }
}
//StudentDemo类
class StudentDemo{
    public Student method(){ //如果的方法返回值是一个引用类型,具体类----> 需要的空间地址值(返回当前类的具体对象)
        //补全代码?

        //分步走
     //   Student s = new Student ;
       // return s ;

        //匿名对象

        return new Student() ;
    }
}
//测试类
public class ReturnDemo1 {
    public static void main(String[] args) {
        //创建键盘录入对象
        Scanner sc = new Scanner(System.in) ;
        System.out.println("请您输入用户名:");
        String username = sc.nextLine() ;

        System.out.println("请您输入密码:");
        String password = sc.nextLine() ;

        //封装User
        User user = new User() ;
        boolean flag = user.login(username, password); //返回值类型基本类型
        System.out.println(flag);
        System.out.println("-----------------------------------");

        //访问:StudentDemo类中的method方法?
        StudentDemo sd = new StudentDemo() ;
        Student student = sd.method();//相当于:Stduent student = new Student() ;
        student.study();
    }
}

2.1 返回值问题研究
引用类型:
方法的返回值如果是抽象类的情况,如何结束方法?需要返回什么?
需要返回当前抽象类的子类对象。

举例5：
import java.io.InputStream;
import  java.util.Scanner ;
abstract class Person{
    public abstract void work() ;
}
//定义PersonDemo
class PersonDemo{
    public Person show(){
        //?
        //Person p = new Person();抽象类不能实例化

        //需要返回当前抽象类的子类对象

        //Person p = new Teacher() ; //抽象类多态
        //return p ;

        return new Teacher() ;//匿名对象
    }
}

//需要提供子类
class Teacher extends Person{

    @Override
    public void work() {
        System.out.println("不断去教授课程...");
    }
}
//测试类
public class ReturnDemo2 {
    public static void main(String[] args) {
        //需要调用PersonDemo类中的show方法
        PersonDemo pd = new PersonDemo() ;
        Person person = pd.show(); //相当于---- >Person person = new Teacher() ;
        person.work();

        //其实键盘录入就是这一个构造方法的形式参数是抽象类
        //Scanenr(InputStream in) ;

        //InputSteam:抽象类 --- java.io.InputStream:字节输入流:(io流去讲)
        InputStream inputStream = System.in; //底层方法--->非Java语言实现的:
        Scanner sc = new Scanner(inputStream) ;
    }
}

2.2 如果一个方法的返回值是引用类型: 返回值类型是接口类型 ,这个方法返回的是什么?
需要返回的是该接口的子实现类对象!

举例7：
//定义接口
interface  Love{
    public abstract  void love() ;
}
//类MethodDemo
class MethodDemo{
    public Love function(){
        //?
        //Love love = new Love(); //接口特点:就是不能实例化,比抽象类抽象
        //需要返回的该接口子实现类对象
        //return new LoveImpl() ;
        //接口多态
        Love love = new LoveImpl() ;
        return love ;
    }
}
//定义一个接口的子实现类,实现接口中的love方法
class LoveImpl implements  Love{

    @Override
    public void love() {
        System.out.println("love loveImpl...");
    }
}

//测试类
public class ReturnDemo3 {
    public static void main(String[] args) {
        //需要调用MethodDemo类中的function方法?
        //创建MethodDemo类对象
        MethodDemo md = new MethodDemo() ;
        Love love = md.function();//Love love = new LoveImpl() ;
        love.love();
    }
}

二、包：(package:书写位置在class上面)----java 中包里面存储的就是java文件(src目录:源码目录包 xx.java)

包:
               单级包
                       com
                               xxx.java
               多级包(推荐)
                       cn.hsbc.www
                               cn
                                       hsbc
                                               www
                                                    xxx.java

 尽量:刚开始书写包:使用多级包
  包在真实开发环境中:代码分包,分层!
     包的命名:公司域名反写
 
      (第二阶段:MVC 三层架构思想)
       M:Model:业务模型
       V:View :视图
       C:Controller:控制器
 
           实体类层
 
                      com.qf.pojo/entity/domain/
                                 /User类Product类/Order类/Cart类/Account类...
 
                                 User类
           业务层
                     com.qf.service
                               UserService:用户接口
                                           boolean login(User user) ;
 
                               UserServiceImpl:接口的实现类
                                   业务逻辑判断
                                   举例:用户登录
 
                                           从数据库中查询到数据
                                           UserDao ud = new UserDaoImpl() ;
 
                                           :通过用户名查询用户
                                           如果查询到用户了,判断用户的密码是否和用户输入的密码匹配
 
 
 
           数据库访问层:
                       com.qf.dao
                                   UserDao:用户的数据库访问接口
                                        通过用户名来查询用户:
                                        User findUserByUserName(String username) ;
                                   UserDaoImpl :用户的数据库访问接口实现
                                           1)第一阶段集合: "小型数据库"
                                           2)第二阶段:JDBC的操作  :真实java连接数据库:mysql/oracle
 
 
 
           控制层
                   com.qf.controller
                                   UserController类:用户的控制器
                                               //调用业务层代码
                                               获取业务数据----通过 JAVAEE技术:实现页面的 跳转:在页面中渲染后台数据!
 
 
           测试层(单元测试)
                   com.qf.test
                               UserTest
                                       使用单元测试
                                                   junit单元测试   junit.jar       (第三方类)    

public class PackageDemo {
    public static void main(String[] args) {        //main---->Jvm调用---->底层:Runner:启动器
        System.out.println("学习了包");
    }
}

不使用idea工具,带包的文件如何编译和运行!

方式1:
手动方式编译
1)先在当前这个Java文件的所在目录中,对这个Java文件使用javac HelloWorld.java
2)编译完成之后---->HelloWorld.class
3)手动方式创建com文件夹 ,子文件夹qf
将2)产生的字节码文件放进去
4)运行这个类
java com.qf.HelloWorld

方式2:(推荐这种:带包的编译和运行)
自动方式编译
1)进入到当前java文件所在目录中,直接编译
javac -d . HelloWorld.java
2)自动的将包名以及字节码文件放在package下面
3)运行这个类
java com.qf.HelloWorld
当前Demo类和Test测试类不在同一个package下面,所以不能直接使用!
需要将Demo类的包导入进来
import 包名.类名; //此时这个类的访问权限必须足够大,否则报错

不同包下:
1)导入包
2)将导入的类:先进行编译
3)在当前类使用自定编译的方式:javac -d . xxx.java
4)带包的运行

三、权限修饰符:

默认修饰符
private:私有的
protected:受保护的
public:公开的,公共的,访问权限很大

			当前类_同一个包     同一个包_子类 /同一个包_无关类      不同包_子类          不同包_无关类
  private          Y
  默认修饰符        Y                        Y
  protected        Y                        Y                       Y
  public           Y                        Y                       Y					Y

总之：public > protected >默认>private

四、综合练习题：

/*
举例1：
设计一个Java程序
 
  		(1)定义一个接口CanCry，描述会吼叫的方法public void cry()
  		(2)分别定义狗类（Dog）和猫类（Cat），实现CanCry接口。实现方法的功能分别为：
  				打印输出“我是狗，我的叫声是汪汪汪”、“我是猫，我的叫声是喵喵喵”
 
  		(3)定义一个主类G，
  			定义一个void  makeCry(CanCry c)方法，其中让会吼叫的事物吼叫。
  			在main方法中创建狗类对象（dog）、猫类对象（cat）、G类对象（g），用
  		g调用makecry方法，让狗和猫吼叫。
 */
 public class Cat implements CanCry {

    @Override
    public void cry() {
        System.out.println("我是猫，我的叫声是喵喵喵");
    }
}

public class Dog implements CanCry {
    @Override
    public void cry() {

        System.out.println("我是狗，我的叫声是汪汪汪");
    }
}

public interface CanCry {

    public void cry() ;//吼叫的方法

}

public class G {

        public void makeCry(CanCry c){//形式参数:引用类型:接口:需要接口的子实现类对象
            c.cry();
        }

    public static void main(String[] args) {

            //创建狗类对象
        Dog d = new Dog() ;
        //狗
        Cat c = new Cat() ;

        G g = new G() ;
        g.makeCry(d);
        g.makeCry(c);
    }
}

举例2：
/*
抽象类多态
 
  创建一个名称为 Vehicle类并将它声明为抽象类,在Vehicle类中声明一个NoOfWheels方法,使它返回一个字符串值.
  创建两个类,Car类和Motorbike类 继承自 Vehicle类,并在这两个类中实现 NoOfWheels方法.在Car类中,应该显示
  "四轮车"信息;而在Motorbike类中,应当显示"双轮车"信息.创建一个带main方法的类,在该类中创建 Car和Motorbike的实例,
  并在控制台显示信息!
*/

public class Car extends Vehicle {
    @Override
    public String NoOfWheels() {
        return "四轮车" ;
    }
}

public class Motorbike extends Vehicle {
    @Override
    public String NoOfWheels() {
        return "双轮车" ;
    }
}

public abstract class Vehicle {

    //NoOfWheels方法,返回一个字符串值
    public abstract String  NoOfWheels() ;

}

public class Test {

    public static void main(String[] args) {

        //创建Car类对象和Motorbike类
        //父类的引用指向子类对象
        Vehicle v = new Car() ;
        String str = v.NoOfWheels();
        System.out.println(str);
        System.out.println("---------------");
        v = new Motorbike() ;
        String str2 = v.NoOfWheels();
        System.out.println(str2);

    }
}

举例3：
/*
需求说明:
  		 在现实生活中，我们经常通过电脑的 USB 接口来使用一些设备，
  		 例如 mp3 、移动硬盘、优盘等。现在要求使用面向接口编程去模拟实现这个例子。
 		 实现步骤
  		 (1)创建 USB 接口，接口中只定义一个 work（）方法。
  		 (2)创建 MP3 类并实现 USB 接口。
  		 (3)创建优盘类(U_Disk)并实现 USB 接口。
  		 (4)创建电脑类(Computer)并定义一个使用接口的方法 useMobile(USB u)。
  		 (5)测试类中分别创建对应的对象进行测试,MP3对象,优盘
*/

public interface USB {

    public abstract  void work();
}

public class MP3 implements  USB {
    @Override
    public void work() {
        System.out.println("可以使用MP3听音乐...");
    }
}

public class U_Disk implements  USB {
    @Override
    public void work() {

        System.out.println("使用u盘文件的传输");
    }
}

public class Computer {

    public void useMobile(USB usb){  //方法的形式参数是接口类型
        usb.work();
    }
}

public class Test {
    public static void main(String[] args) {

        //创建Computer对象
        Computer computer = new Computer() ;
        //接口多态
        USB usb = new MP3() ;
        computer.useMobile(usb);

        usb = new U_Disk() ;
        computer.useMobile(usb);
    }
}

举例4：
/*
首先定义一个抽象类Animal,抽象类中定义一个抽象方法play（）抽象方法
  	创建 一个猫Cat类，继承Animal并重写play方法输出“我是猫，我玩老鼠”，
  	创建一个狗类， 继承Animal并重写play方法输出“我是狗，我玩球”。
  	最后编写测试类TestDemo，通 过多态创建猫，通过多态创建狗，并调用猫对象的play方，狗对象的play方法
 
  	最终输出的效果是:
 
  		我是猫，我玩老鼠
  		我是狗，我玩球
*/

public abstract class Animal {

    //抽象方法play（）
    public abstract  void play() ;
}

public class Cat extends Animal {
    @Override
    public void play() {
        System.out.println("我是猫，我玩老鼠...");
    }
}

public class Dog extends Animal {
    @Override
    public void play() {
        System.out.println("我是狗，我玩球");
    }
}

public class Test {
    public static void main(String[] args) {

        //抽象类多态
        Animal a = new Cat() ;
        a.play();
        a= new Dog() ;
        a.play();
    }
}

igfff

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
打赏
0
评论
Java学习日志Day13_形式参数问题_包_权限修饰符_综合练习题

一、形式参数问题形式参数问题研究基本数据类型, 实际参数传递的是当前这个数据值!引用数据类型数组:需要传递数组对象类: 具体类:传递的当前类的对象举例1：//定义一个类Democlass Demo{ public int add(int a,int b){ //形式参数:基本数据类型 return a + b; }}//学生类class Student{ public void study(){ System.out.pr
复制链接

扫一扫