面向对象

最新推荐文章于 2023-09-30 02:15:00 发布

种太阳的人

最新推荐文章于 2023-09-30 02:15:00 发布

阅读量125

点赞数

文章标签：多态抽象类 java

本文链接：https://blog.csdn.net/MARSUY/article/details/112708991

版权

文章目录

面向对象
附录
- 1.args 参数
- 2.return 返回值的引用类型

面向对象

1.一个类的成员的组成

一个类的组成:
成员变量 :在类中方法外
成员方法去掉了static

构造方法定义：
1)方法名和类名相同
2)没有具体的返回值类型
3)没有void

构造方法的注意事项:
1)无参的构造方法,我们不给出,系统会默认提供
2)如果我们提供了有参构造方法,那么系统就不会再提供无参构造方法
3)构造方法是可以重载的（overLoad）
4)构造的方法作用: 为了给类中属性进行赋值!

给成员变量赋值有几种方式?
1)通过setXXX(xxx)公共的访问方法赋值
2)通过构造方法进行赋值

什么时候将变量定义为成员变量?
当前一些变量能够描述事物的属性的时候,就将属性设置为类中的成员变量如果不能够描述事物的属性,就将变量为设置局部变量

总结:
1）成员方法都是去掉了static(非静态的),以后编程题中,除非有强制性要求,定义静态的功能,其他都是非静态
2）有具体的返回值类型的成员方法,根据返回值类型去接收:
数据类型变量名= 使用对象名.成员方法名() ; 赋值调用
3）如果没有具体返回值类型,使用对象名.成员方法名() 进行单独调用

成员变量的访问问题:
1)当局部变量和成员变量名称不一致的情况: 分别访问
2)当局部变量和成员变量名称一致的情况:遵循就近原则

2.引入static关键字

静态变量和成员变量(非静态的)的区别:
1)在类中位置相同的,成员位置(类中,方法外),写法格式不同：
静态变量: static修饰数据类型变量名;
成员变量 : 数据类型变量;

2)内存中位置不一样:
静态成员变量:方法区中的静态区域
成员变量:堆内存中

3)生命周期不同 (静态的变量优先于对象存在的)：
静态成员变量:随着类的加载而加载, 类就加载一次,static变量加载一次,随着类的加载完毕,在方法区中不会立即消失；
成员变量:随着对象的创建而存在, 随着对象的创建完毕,等待垃圾回收器回收

4)初始化时机不同：
静态成员变量:类加载的时候可以直接初始化
成员变量:对象创建完毕,才进行初始化

static(静态修饰符)的特点什么:
1)被静态修饰的变量,方法，静态变量/静态方法随着类的加载而加载
2)被静态修饰的优先于对象存在
3)被静态修饰:有共享,共用的意思
4)被静态修饰的变量/方法,可以被类名直接访问

关于静态的注意事项
1)定义静态的变量，成员位置，成员变量要加入static
2)非静态的成员方法既可以访问非静态的成员变量,也可以访问静态的变量
3)静态的成员方法只能访问静态的成员变量

总结:
非静态的成员方法,既可以访问静态的成员变量/非静态的成员变量非静态的成员方法,既可以访问静态的成员方法/非静态的成员方法

3.代码块

代码块:在Java中,使用{} 括起来的内容
分类:
局部代码块:在局部位置,方法定义中书写{},作用:限定局部变量的生命周期
构造代码块:在类的成员位置,使用{}—构造代码块
特点:每次执行构造方法之前,先执行构造代码块
作用:将构造方法中的相同的内容放在

静态代码块:在类的成员位置,使用static{…}
作用:在加载类的时候,随着类加载而加载,优先于对象存在，类就加载一次,静态代码块执行一次!
优先级:静态代码块 > 构造代码块 > 构造方法代

4.继承

什么是继承（extends）?
将多个类的共性内容,抽取到一个独立的类中,让这独立的类和其他类产生一种关系

格式： class 子类名 extends 父类名{}

继承的好处:
1)提高了代码的复用性
2)提高了代码维护性
3)类与类产生的关系—是多态的前提条件!

类与类之间的关系:也是弊端，因为要遵循低耦合，高内聚

继承的特点:
1)仅仅是在Java中,只支持单继承 (类与类之间的关系)

2)虽然Java中类与类之间的关系,不支持多继承,但是可以多层继承

继承中的注意事项:
1)在继承关系中,子类继承父类,只能继承父类非私有的成员,私有的成员要访问,间接通过公共访问方法间接访问
2)子类继承父类,构造方法是不能被继承的,通过子类访问父类的构造方法同关键字:super :（）来访问
3)不能为了使用部分功能,使用继承

前提条件：A类是B类的一种或者B类是A类的一种,体现的一种 "is a"的关系;

继承关系中成员变量的访问问题:
类的成员：成员变量构造方法成员方法
继承关系中:
子类继承父类,如果子类中的成员变量名称和父类的成员变量名称不一致的情况,分别访问

子类继承父类,如果子类中的成员变量名称和父类的成员变量名称一致的情况要遵循 “就近原则”

就近原则：
1）现在子类的局部位置中找,如果存在,就使用
2)如果子类的局部位置找不到,就在本类的成员位置中找,如果存在,就使用
3)如果本类的成员位置中都找不到,就在父类的成员位置中找,如果存在,就使用
4)如果父类的成员位置中找不到,就报错

继承关系中构造方法的访问问题：
1)子类继承父类,子类的所有的构造方法都有默认的访问父类的无参构造方法,通过super() ; 可以省略不写
2)super():在子类中构造方法中第一句话:可以省略

为什么在创建子类对象的时候,为什么要去访问父类的无参构造方法?
1）因为存在继承关系,创建子类对象的时候,可能需要用到父类的数据;
2）子类的所有构造方法必须有一个让父类初始化(分层初始化:先让父类初始化,然后在是子类)，默认的访问方式:super(),但是也可以间接访问父类的有参构造方法

如果父类中没有无参方法,子类的构造方法会有什么问题?如何解决?
子类的所有构造方法都会报错
解决方案:
1)手动给出父类的无参构造方法
2)可以让子类的构造方法通过super(xxx)；访问父类的有参构造方法
3)在本类中的有参构造中，通过this()访问本类的无参构造方法，然后在本类的无参构造中super（）；来访问父类的有参构造。（只需要保证子类的一个构造方法让父类初始化即可）

super()或者this():为什么一定要定义在第一行？
super（）：
因为子类继承了父类的属性和方法，所以在先初始化父类的属性和方法，
这样子类才可以初始化自己特有的，因为java中不允许调用没有初始化的成员。
this():
因为要先初始化父类和this代表的构造函数,
因为当前构造函数可能用到那些成员，所以那些成员得要先初始化。

super()或者this()的区别:
this.变量名; 访问的本类的成员变量
super.变量名; 访问的是父类的成员变量
this.方法名(); 访问的是本类的成员方法
super.方法名(); 访问的父类的成员方法
this(): 访问的本类的无参构造
this(xxx): 访问的是本类的有参构造
super() :访问的父类的无参构造
super(xx):访问的父类的有参构造方法

5.多态

什么是方法是重写?
子类出现了和父类一模一样的方法声明,子类将父类的功能覆盖了,复写了;
重写的目的:就是他不仅有父类的功能,还可以延用子类自己的功能!

Overload和Override的区别?
方法重载 :
定义方法的时候,方法名相同,参数列表不同,与返回值无关的方法称为"重载方法"
参数类型不同
参数个数不同
方法重写:
继承中出现,子类要使用自己的功能,需要将父类的功能覆盖(复写)掉, 子类出现了和父类一模一样的方法

final关键字
不可改变。可以用于修饰类、方法和变量。

final的特点：
类：被修饰的类，不能被继承。
方法：被修饰的方法，不能被重写
变量：被修饰的变量，不能被重新赋值

使用方式
1)final 可以修饰类,该类不能被继承!

final class 类名 {
}

2)final可以修饰成员方法,该方法不能被重写

修饰符 final 返回值类型 方法名(参数列表){
//方法体
}

3)final可以修饰成员变量(常量)必须给一个初始化值的,防止类加载完毕,这个变量还没有初始化

public class User {
final String USERNAME = "张三";
private int age;
}

4)而final修饰局部变量的时候,可以先定义,在使用之前必须初始化,而且只能赋值一次

public class FinalDemo1 {
public static void main(String[] args) {
// 声明变量，使用final修饰
final int a;
// 第一次赋值
a = 10;
// 第二次赋值
a = 20;
// 报错,不可重新赋值
// 声明变量，直接赋值，使用final修饰
final int b = 10;
// 第二次赋值
b = 20; // 报错,不可重新赋值
}
}

final修饰基本数据类型和引用数据类型的区别?

final修饰基本数据类型:
基本数据类型的值不能再改变了!(已经是一个常量了)
final修饰引用数据类型:
引用数据类型的空间地址值不能再改变了

多态概述
某一个事物，在不同时刻表现出来的不同状态

多态前提和体现

1）.有继承关系
2）.有方法重写
3）.有父类引用指向子类对象， “向上转型”
格式:
父类名对象名 = new 子类名() ;

成员访问特点

访问成员变量：
编译看左边，运行看左边
如果编译没有报错,那说明父类的存在这个成员变量,运行的时候使用的父类的变量
访问成员方法：
编译看左边，运行看右边
因为存在子类重写了父类的功能,方法重写
访问静态方法
编译看左边，运行看左边
静态修饰的都和类有关---- 不存在重写,因为类加载的时候,这些静态的功能就已经进入到方法区中，静态方法不能算方法的重写
访问构造方法:
分层初始化:先让父类进行初始化,然后子类初始化

多态的好处和弊端

多态的好处
提高了程序的维护性(由继承保证)
提高了程序的扩展性(由多态保证)
多态的弊端
不能访问子类特有功能，只有通过多态中的转型才能访问

6.抽象类

关于返回值问题的研究

一个方法的返回值类型:
要么是基本数据类型
要么引用数据类型

关键字:instanceof
对象名 instanceof 引用类型(类) ；
判断当前对象名是否为这个数据类型,如果是: 则返回true;否则,false

什么是抽象类?
将一个类的成员方法给出一个声明，不给出具体实现（类中存在抽象方法），那么这个类就是抽象类，能够描述显示世界某一种事物（概括性）

抽象方法:跟之前的方法定义是一样,不过在方法声明省加入一个关键字 abstract,而且这个方法没有{},方法名后面直接是分号结束;

抽象类的格式： abstract class 类名{ }

抽象类的特点:
1)不能直接实例化,但是可以间接通过子类实例化
父类名对象名= new 子类名() ; 父类----抽象类
2)抽象类体现的是一种强制子类必须完成的事情:将抽象类中抽象方法,子类必须重写

抽象类的成员特点有哪些
成员方法：既可以是常量也可以是变量
成员方法：既可以是抽象方法，也可以是非抽象方法
构造方法：既可以是无参构造，也可以是有参构造，目的都是为当前类的数据进行初始化

一个类如果没有抽象方法，这个类可不可以定义为抽象类？意义是什么呢？
可以定义为抽象类
意义：为了让当前类不能直接创建对象，一般都会存在静态功能，返回值类型就是该类。

7.接口

什么是接口?
接口是针对某个具体事物提供的一种扩展功能(额外的功能)

格式:
interface 接口名{}
接口名的命名规则:和类名一致: 大驼峰命名法

接口中的特点:
1)接口中的方法只能是抽象方法
2)接口的子实现类和接口之间的关系: implements 实现关系，接口的子实现类必须要实现接口中的抽象方法
3)接口不能直接实例化—不能直接new 接口名() ;接口的实例化:通过具体的子实现类进行实例化

附录

1.args 参数

方法的形式参数:
基本数据类型: 形式参数的改变不会影响实际参数—传递的实际参数是具体的数值
引用数据类型: 形参的改变会直接影响实际参数(除过String:特殊的引用类型) 数组:冒泡排序
public static void bubbleSort(int[] arr){}
类：
具体类
抽象类

接口

形式参数是引用类型：具体类

//定义一个学生类:具体类
class Student{
    public void study(){
        System.out.println("good good Study,day day Up!!!");
    }
}

//定义一个StudentDemo类
class StudentDemo{
    public void show(Student student){  //形式参数:传递是一个引用类型;具体类  Student s = new Student()
        student.study(); // ---->s.study()
    }
}

//测试类
public class Test1 {

    public static void main(String[] args) {

        //需要访问StudentDemo类中show方法
        StudentDemo sd = new StudentDemo() ;
        //Student对象创建
        Student s = new Student() ;
        sd.show(s);//实际参数需要改具体类的 具体对象 :类名 对象名  = new 类名() ;
    }
}

形式参数是引用类型: 抽象类

//抽象的父类
abstract class Person{

  /*  public  void work(){
        System.out.println("人都需要工作...");
    }*/

  public abstract  void work() ;
}
//定义一个类PersonDemo
class PersonDemo{
    public void method(Person person){//形式参数是引用类型: 抽象类----->实际参数:需要改抽象类的子类(具体类)对象
                                        //Person p = new Worker() ;
            person.work();          //p.work()
    }
}

//需要定义Person类的子类
class Worker extends  Person{

    @Override
    public void work(){
        System.out.println("工人需要不断的去创造利益...");
    }
}

//测试类
public class Test {
    public static void main(String[] args) {
        //需求:需要访问PersonDemo类中method方法
        PersonDemo pd = new PersonDemo() ;
       // Person person  = new Person() ;//抽象类不能实例化
        //抽象类多态
      //  Person p = new Worker() ;
       // pd.method(p);

        pd.method(new Worker()); //匿名对象


    }
}
/*

System类:
        成员变量:
        public static final InputStream in
        //Scanner类
        //构造方法:public Scanner(InputStream source)
*   Scanner sc  = new Scanner(System.in) ;
* */

形式参数是引用类型:接口

//定义了一个接口
interface Love{
    void love();
}

//定义一个类
class LoveDemo{
    //成员方法
    public void function(Love l){//形式参数是引用类型:接口---->接口可以通过子实现类(具体类)实例化
        l.love();                   //Love love = new LoveImpl() ;
                                    //love.love();
    }
}

//定义一个接口的子实现类(具体类)
class LoveImpl implements  Love{

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


//测试类
public class Test {

    public static void main(String[] args) {
            //需求:访问LoveDemo类中function方法
        //创建LoveDemo类的对象
        LoveDemo ld = new LoveDemo() ;
        //Love love = new Love() ;//接口是不能实例化的
//        ld.function(love);

        //提供了接口的子实现类: 通过接口多态方式进行
        Love love = new LoveImpl() ;
        ld.function(love);
        System.out.println("------------------------");
        ld.function(new LoveImpl()); //匿名对象
    }
}

2.return 返回值的引用类型

方法的返回值问题研究
返回值类型是基本数据类型：需要返回该基本数类型的具体的结果

返回值类型是引用数据类型
类
具体类:需要返回该具体类型具体对象
抽象类
接口

返回值类型是引用数据类型：具体类

class Student{
    public void study(){
        System.out.println("好好学习,天天向上");
    }
}
class StudentDemo{
    public Student method(){
        //分步走
       /* Student student = new Student() ;
        return student ;*/
        //一步走
        return new Student() ;
    }
}
//测试类
public class Test {

    public static void main(String[] args) {
        //调用StudentDemo类中method方法
        StudentDemo sd = new StudentDemo() ;
        Student s = sd.method(); //相当于:Student s = new Student() ;
        s.study();
    }
}

返回值类型是引用数据类型：抽象类

//定义一个抽象类
abstract  class Person{

    public abstract void study() ;
}

class PersonDemo{
    public Person show(){ //需要返回的Person类的对象

        //分步走
        //Person p = new Person() ; //抽象类不能实例化,间接通过具体的子类来实例化:抽象类多态
        //retur
        // n p ;

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


        //一步走
//        return new Teacher() ;


    }
}
//定义一个具体的子类 继承 Person 重写方法
class Teacher extends  Person{

    @Override
    public void study() {
        System.out.println("老师不断要学习技术...");
    }
}


public class Test {

    public static void main(String[] args) {
            //需要:访问PersonDemo类中show方法
        PersonDemo pd = new PersonDemo() ;
        Person person = pd.show();   //相当于---Person perosn   = new Teacher() ;
        person.study();
    }
}

返回值类型是引用数据类型：接口

//定义一个接口
interface  Love{
    void love() ;
}

class LoveDemo{
    public Love function(){//返回值类型:接口类型

       // Love love = new Love() ; //接口不能实例化,需要通过具体的子实现类进行实例化
       // return love ;

        //返回的子实现类对象对象
      /*  Love love = new LoveImpl() ; //接口多态
        return love ;*/

      //一步走:匿名对象
        return new LoveImpl() ;
    }
}
//定义具体的子实现类 实现接口
class LoveImpl implements  Love{

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

//测试类
public class Test {

    public static void main(String[] args) {
        //需要调用LoveDemo类中function方法
        LoveDemo ld = new LoveDemo();
        Love love = ld.function();   //相当于:Love love = new LoveImpl() ;

        love.love();

    }
}