Java基础--面向对象(Ⅴ)

In-Deep

于 2022-08-19 22:29:31 发布

分类专栏： javaSE 文章标签： java jvm 开发语言

本文链接：https://blog.csdn.net/hu15029077038/article/details/126432785

版权

javaSE 专栏收录该内容

16 篇文章 0 订阅

订阅专栏

Java基础–数组和面向对象(Ⅰ)
Java基础–面向对象(Ⅱ)
Java基础–面向对象(Ⅲ)
Java基础–面向对象(Ⅳ)

活动地址：CSDN21天学习挑战赛

本文目录

- - - 面向对象

面向对象

1.接口

接口的成员特点:

     成员变量
     *          只能是常量,存在默认修饰符 :public static final

     成员方法
     *          只能是抽象方法,存在默认修饰符  public abstract

     构造方法
     *          没有构造方法的---通过子实现类的构造方法来实例化

     接口本身意义
     *          对外暴露这些功能,让子实现类实现

补充:
关于面向对象中牵扯关系问题: (Java中最基本的单元是类)
类和类:继承关系 extends
 Java语言中只支持单继承,不支持多继承,但是可以多层继承
类和接口: 实现关系 implements
一个类继承另一个类的同时,可以实现多个接口
class InterImpl extends SuperIner  implements  Inter,Inter2{//一个类继承另一个类的同时,可以实现多个接口
    @Override
    public void show() {
        System.out.println("sInterImpl");
    }
接口和接口:继承关系:extends
不仅支持单继承,也可以多继承
interface Inter extends StudyMath,StudyEnglish{ //接口与接口 ---- > 继承关系  :单继承 / 可以多继承
    void show() ;
}

2.包

包的真实意义:实际开发中针对代码进行分层
- 一般命名单词:全部小写,而且是多级包,中间打点隔开,点就是分包(目录/文件夹)
  - 包名: 一般域名的反写

3.关于方法的形式参数问题

基本类型 :形式参数的改变不影响实际参数,要什么基本类型,实际参数直接传递具体的数据值 (比如int)

引用类型:

如果是具体类,在调用该方法

实际参数需要这个具体类的对象

class Student{
    public void study(){
        System.out.println("学习Java");
    }
}
class StudentDemo{
    public void method(Student student){//形参为引用类型:具体类 ----> 调用该方法,实际参数需要一个学生对象
        student.study() ;
    }
}

//测试类
public class ArgsDemo1 {
    public static void main(String[] args) {
        //调用StudentDemo类的method方法
        //1.创建StudentDemo类对象
        StudentDemo sd = new StudentDemo() ;
        //2.调用该方法,实际参数需要一个学生对象
        Student s = new Student() ;
        sd.method(s); //实际参数s
    }
}

如果是抽象类,调用该方法

实际参数需要该抽象类的具体的子类对象,抽象类多态

abstract  class Person{//人类
    public abstract  void work(); //工作
}

class PersonDemo{
    //成员方法
    public void show(Person p){//形式参数是一个抽象类,抽象类不能实例化 
        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 pd = new PersonDemo() ;
        //抽象类多态
        Person p = new Worker() ;
        pd.show(p);
    }
}

如果是接口,调用该方法

实际参数:需要传递该接口的子实现类对象接口多态的形式

//接口
interface Love{
    void love() ;
}

class LoveDemo{
    public void function(Love lo){ //方法形式参数是一个接口类型,接口不能实例化,无法new
        lo.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() ;
        //接口多态的方式:接口名 对象名 = new 具体的子实现类名() ;
        Love love = new LoveImpl() ;
        ld.function(love);
    }
}

4.关于返回值的问题

返回基本类型: 如,返回int---->谁调用这个方法,调用者就必须使用int类型接收

返回引用类型:

方法的返回值,返回的是一种具体类型的情况

一定要返回当前这个具体的类的对象

//学生类
class Student{
    public void study(){
        System.out.println("正在学习JavaEE");
    }
}
//StudentDemo
class StudentDemo{
    public Student method(){//返回值是一个引用类型,具体类 ----> 方法结束,必须返回一个当前类的具体类对象

        //方式1 :
        Student s = new Student() ;
        return  s;

        //方式2:匿名对象的格式
        return  new Student() ;
    }
}

//测试
public class ReturnDemo {
    public static void main(String[] args) {
        //调用StudentDemo这个类里面的method方法
        StudentDemo sd = new StudentDemo() ;
        Student s = sd.method(); // 这个方法的本质相当于,new Student();
        s.study() ;
    }
}

方法的返回值,返回的是一种抽象类情况

必须要提供抽象类子类

//抽象类
abstract  class Person{
    public abstract void work();
}
class PersonDemo {
    public Person show(){ //方法的返回值是一个抽象类,抽象类不能直接new,则必须要提供抽象类子类
        
        //方式1:抽象类多态
        Person p = new Programmer() ;
        return  p;

        //方式2:匿名对象
        return  new Programmer() ;
    }
}
//提供一个子类:抽象类的子类   抽象类多态
class Programmer extends  Person{
	//改写方法
    @Override
    public void work() {
        System.out.println("不断的去学习Java.");
    }
}
//测试类
public class ReturnDemo {
    public static void main(String[] args) {
        //调用PersonDemo的show方法
        PersonDemo pd = new PersonDemo() ;
        Person person = pd.show(); //方法本质是,new Programmer() ;
        person.work();
    }
}

方法的返回值,返回的是一个接口

需要定义一个接口的子实现类

//定义一个接口
interface Mary{
    void mary() ;
}
//定义一个类
class MaryDemo{
    public Mary method(){  //方法的返回值是接口类型,接口不能实例化
        //方式1:接口多态
        Mary mary  = new WeddingCompany() ;
        return  mary ;

        //方式2:匿名对象
        return  new WeddingCompany() ;
    }
}
//定义一个接口的子实现类
class WeddingCompany implements Mary{
	//发法改写
    @Override
    public void mary() {
        System.out.println("正在布置婚礼现场!");
    }
}
//测试类
public class ReturnDemo3 {
    public static void main(String[] args) {
        //调用MaryDemo类名的method方法
        MaryDemo maryDemo = new MaryDemo() ;
        Mary m = maryDemo.method();//method方法本质是,创建子实现类对象new WeddingCompany() ;
        m.mary();
    }
}

5.关于成员方法权限修饰符号的范围问题

范围

	在同一个包下的同一个类中	在同一个包下的子类中/在同一个包下的无关类中	在不同包下的子类中	在不同包下的无关类中
private 私有修饰符	可以访问	不能访问	不能访问	不能访问
默认修饰符	可以访问	可以访问	不能访问	不能访问
protected 受保护的	可以访问	可以访问	可以访问	不能访问
public 公开的	可以访问	可以访问	可以访问	可以访问

权限修饰符的范围:

     private最小,其次默认修饰符,然后protected受保护的,最大为public

6.内部类和外部类

一个类中定义另一个类
- 在A类中定义了一个B类
  - A类称为B类的外部类,B类称为A类的内部类

格式:

     成员内部类:在一个类的成员位置定义的类
     *          类中,方法外

     局部内部类:在一个类的局部位置定义的类
     *          方法中

class Outer{
    //类中,方法外:  成员内部类
    class Inner{
    //成员方法
    public void method(){

        //局部内部类
        class Inner{
            int num = 20 ;
        }
    }
}

2.成员内部类的特点:

     成员内部类的成员方法
     *          可以直接访问外部类的成员包括私有

     外部类的成员方法
     *          要去访问成员内部类的成员方法,必须通过成员内部类的对象来访问!

     如何直接通过外部类访问内部类的成员方法
     *          前提条件:是成员内部类是非静态的
     *          外部类名.内部类名 对象名  = new 外部类名(). new 内部类类名()

In-Deep

关注

2
点赞
踩
2
收藏
打赏
4
评论
Java基础--面向对象(Ⅴ)

Java基础面向对象包内部类外部类
复制链接

扫一扫

专栏目录