欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

JavaEE基础编程语法--面向对象入手解析语法

程序员文章站 2022-07-09 19:15:55
目录面向对象基础 对象创建内存构造方法匿名对象匿名对象存储原理编程规范面向对象进阶封装Private封装的意义:(被省略掉的)this关键字StaticStatic方法包权限修饰符代码块构造代码块静态代码块面试题:main方法详解所有的参数在执行类的时候以空格进行分割。面向对象高级继承子类实例化内存分析super关键字重写面试题final关键字抽象类不能被实例化抽象方法 常见问题抽象类和普通类的区别接口概念面向接口编程思想接口的实现 implements全局常量和抽象方法的简写接口的继承注意接口和......


目录

面向对象基础

对象创建内存

构造方法

匿名对象

编程规范

面向对象进阶

封装Private

(被省略掉的)this关键字

Static

Static方法

权限修饰符

代码块

面试题:

main方法详解

面向对象高级

继承

子类实例化内存分析

super关键字

重写

面试题

final关键字

抽象类

抽象方法

常见问题

抽象类和普通类的区别

接口

全局常量和抽象方法的简写

接口的继承

注意

接口和抽象类的区别

多态

instanceof关键字

面向接口编程:接口可以作为函数的形参,实参是实现接口具体功能的子类

Object类

equals

内部类

成员内部类

匿名内部类

注意:

所有的局部内部类只能访问final型的局部变量

静态内部类

包装类

八种基本类型的包装类

装箱和拆箱操作

字符串转换

可变参数

递归


面向对象基础

对象创建内存

JavaEE基础编程语法--面向对象入手解析语法

  • 当程序运行到第一行代码的Book时,类Book就会进入方法区。运行到b1处,就会在栈里面创建一个内存Book b1 null(此时为空值)。

  • 当程序运行到new Book()处,就会在堆内存里创建一个对象Book,并且这个对象的地址为0x1234,将地址返回给栈,作为b1的值。然后程序继续往下就是在堆内存中继续增加对象的属性及赋值等。

  • 当程序运行到Book b2 =b1时,栈线上b1的上方创建b2,然后把b1的值复制给b2。

  • 原理:实际上就是通过在栈存储的地址,找到堆内存中储存的对象,从而实现访问或修改对象。

  • 当程序运行结束时,释放栈,b2先出栈,b1最后出栈,由于堆内存中的对象的地址没有被栈内存指向(对象不存在引用),满足GC的垃圾回收,堆内存 中的对象会被回收。

JavaEE基础编程语法--面向对象入手解析语法

JavaEE基础编程语法--面向对象入手解析语法


构造方法

public static void main(String[] args) {
        // TODO Auto-generated method stub
        System.out.println(1);
        Person2 p1 = new Person2();
        System.out.println(2);
        p1.name = "张三";
        p1.age = 18 ;
        p1.say();
        
        Person2 p2 =new Person2("李四",20);
        p2.say();
    }

}

class Person2{
    
    //不建议程序员依赖程序自动生成的无参构造方法
    //建议每创建一个对象就写一个构造方法
    //构造方法的作用:用于对象初始化
    
    //无参构造方法
    Person2(){
        System.out.println("构造方法执行了");
    }
    
    //有参构造方法
    Person2(String a,int b){
        name=a;
        age=b;
    }
    
    String name;
    int age;
    
    void say() {
        System.out.println("自我介绍:我是"+name+",我的年龄:"+age);
    }



匿名对象

JavaEE基础编程语法--面向对象入手解析语法

像m这种只使用一次的对象,我们可以用匿名对象将其进行替换。替换后效果如下:

JavaEE基础编程语法--面向对象入手解析语法


匿名对象存储原理

JavaEE基础编程语法--面向对象入手解析语法

  • 如果一个对象,我们准备使用两次或以上,那么一定要给对象创建对象名。

JavaEE基础编程语法--面向对象入手解析语法

每运行一个new Person5()就会创建一个新的对象,逻辑如下图

JavaEE基础编程语法--面向对象入手解析语法

编程规范

JavaEE基础编程语法--面向对象入手解析语法

面向对象进阶

封装Private

不封装程序会出现什么问题?类的成员属性容易被更改,导致输入一些不合逻辑的内容程序也能正常运行。如下面这张图,年龄被修改成负值,这是不符合实际事实的。

JavaEE基础编程语法--面向对象入手解析语法

封装的意义:

  • 保护或者防止代码(数据)被我们无意中破坏。

  • 保护成员属性,不要让类以外的程序直接访问和修改。

    封装原则

    隐藏对象的属性和实现细节,只对外公开访问方法,并且控制访问级别。


在开发中,为了避免出现逻辑错误,我们建议对所有属性进行封装,并使用set()和get()方法进行修改和读取操作



(被省略掉的)this关键字

在编写方法时,我们通常希望方法的形参与类的属性名字相同,但是这样子程序会报错。下面给出了我们目标的赋值方式。

JavaEE基础编程语法--面向对象入手解析语法


但这样的写法,实际形参只会给自己赋值,而不是给类的属性赋值

JavaEE基础编程语法--面向对象入手解析语法

要解决这个问题,我们需要在被赋值的类属性前面加上this. ,this表示正在被创建/调用的对象。其实this一直在类属性前面,只是一般情况下程序会把this隐藏起来。

JavaEE基础编程语法--面向对象入手解析语法


  • this 既可以调变量,也可以调函数方法。

  • 在无参构造方法中调用this()可以实现无参调用有参构造方法

  • 在一个构造方法中,调用另一个构造方法时,调用的代码 必须写在构造方法的第一行,否则会报错。错误实例如下

JavaEE基础编程语法--面向对象入手解析语法



创建getter和setter的快捷键:shift+alt+s


Static

  • static属性的变量存储在方法区。

  • 被static关键字修饰的方法或者变量不需要依赖于对象来进行访问,只要类被加载了,就可以通过类名去进行访问

  • 可以这样去理解:把静态所修饰的属性看作是类的属性,是通过类去修改的;而非静态所修饰的属性看作对象的属性,是通过对象去修改的。

  • 因为对象是在类创建后才创建的,而static的资源是在类创建(第一次使用类)的时候就被加载的,所以静态资源被调用的时机早于非静态资源。

  • 第二次以后使用类都不会加载static的语句了!

  • 在访问时: 静态不能访问非静态 , 非静态可以访问静态 !

JavaEE基础编程语法--面向对象入手解析语法

JavaEE基础编程语法--面向对象入手解析语法


Static方法

JavaEE基础编程语法--面向对象入手解析语法


命名规范:通常由多个单词组成, 所有单词的字母小写, 单词与单词之间使用.隔开 ,一般命名为“com.公司名.项目名.模块名....”。

导包:import 包名.类名;

不用导的包:1.java.lang 2.当前包所含的其他类



权限修饰符

JavaEE基础编程语法--面向对象入手解析语法



代码块

构造代码块

作用:在一个类中,我们通常定义多个无参/有参的构造方法,以便重载。但是如果在每一个构造方法里都需要一个固定的操作,我们需要在构造方法中加入相应的代码,有多少个构造方法就需要重复写多少条代码。而构造代码块就是将这个固定的操作放在一个块中,从而不用重复写。

/**
     * 构造代码块,随着对象的每次创建,执行一次,且执行在构造方法之前
     * 
     * 区别于构造方法的是:
     *  无论用户调用哪一个构造方法来创建对象,构造代码块都必然执行
     */
    
    //构造代码块
    {
        System.out.println("对象创建时执行1");
    }

静态代码块

在类中使用static修饰的成员代码块, 我们称其为静态代码块, 在类加载时执行。 每次程序启动到关闭 ,只会执行一次的代码块。

/**
     * 静态代码块,随着类的加载(第一次使用),静态代码块执行。
     * 因为类只加载一次,所以静态代码块只执行一次。
     */
    
    //静态代码块
    static{
        System.out.println("静态代码块执行");
    }

面试题:

构造方法 与 构造代码块 以及 静态代码块的执行顺序: 静态代码块 --> 构造代码块 --> 构造方法


main方法详解

main()方法一直写到了今天:

public static void main(String args[])

以上的各个参数的含义如下:

· public:表示公共的内容,可以被所有操作所调用

· static:表示方法是静态的,可以由类名称直接调用。java StaticDemo09

· void:表示没有任何的返回值操作

· main:系统规定好的方法名称。如果main写错了或没有,会报错:NoSuchMethodError: main

· String[] args:字符串数组,接收参数的

public class StaticDemo10{
    public static void main(String args[]){
        for(int i=0;i<args.length;i++){ 
            System.out.println(args[i]) ; 
        } 
    } 
};

所有的参数在执行类的时候以空格进行分割。

java StaticDemo10 1 2 3 4 5 6 7

但是,如果现在我要输入的是以下几种参数“hello world”、“hello vince”、“hello mjw”

因为以空格分割,所以以上的三组参数会当做六组参数输入,那么此时如果要想完成有空格的内容输入,则参数需 要使用“"”括起来。

java StaticDemo10 "hello world" "hello vince" "hello mjw"


面向对象高级

继承

  • 继承是java面向对象编程技术的一块基石,因为他允许创建分等级层次的类

  • 继承就是子类继承父类的特征(类的属性)和行为(类的方法),使得子类对象(实例)具有父类的实例域和方法,或子类从父类是继承方法,使得子类具有父类相同的行为。

  • 继承的限制:

    • java中只有单继承,多重继承(c继承b,b再继承a),没有多继承(多继承就是一个儿子有多个父亲)

  • 格式

     class 父类{
      
      }
     
     class 子类 extends 父类{
     
      }


子类实例化内存分析

JavaEE基础编程语法--面向对象入手解析语法

  • 当创建子类student的对象时,堆首先创建它的父类对象person,再创建子类的对象。然后再子类对象中通过super关键字存储父类的地址(相当于super把父亲引进来,使得父类成为子类的一部分)。

  • 当子类调用方法时,先查看堆里的子类本身有没有这个方法或属性,如果没有,就往父类找。如此类推。

  • 父类中只有被public或protected所修饰的属性或方法,才能被子类继承。


super关键字

  • 通过super,可以访问父类的构造方法;默认通过无参构造方法访问,所以父类必须要有一个无参构造方法,否则会报错。调用super构造方法的代码,必须写在子类的第一行。在子类中,super就是被创建的父类对象。子类创建了多少个,就会自动创建多少个父类对象。

  • 通过super,可以访问父类的属性

  • 通过super,可以访问父类的方法


重写

重写规则:

  • 1.参数列表必须完全与被重写方法的相同。

  • 2.返回类型必须完全与被重写方法的返回类型相同。

  • 3.访问权限不能比父类中被重写的方法的访问权限更低。例如,如果父类的一个方法被声明为public,那么在子类中重写该方法就不能声明为protected.

  • 4.父类的成员方法只能被它的子类重写。

  • 5.声明为static和private的方法不能被重写,但是能被再次声明


面试题

重写:重写子类继承父类的方法。

重载:一个类中有相同名称的但参数不同的函数

java中重写(override)与重载(Overload)的区别

  • 1.发生的位置

    • 重载:一个类中

    • 重写:子父类

  • 2.参数列表限制

    • 重载:必须不同的

    • 重写:必须相同的

  • 3.返回值类型

    • 重载:与返回值类型无关

    • 重写:返回值类型必须一致

  • 4.访问权限

    • 重载:与访问权限无关

    • 重写:子类的方法权限必须不能低于父类的方法权限

  • 5.异常处理

    • 重载:与异常无关

    • 重写:异常范围可以更小,但是不能抛出新的异常。



final关键字

功能:用来定义常量

  • final用于修饰属性,变量。

    • 变量变成了常量,无法对其再次进行赋值。

    • final修饰的局部变量,只能赋值一次。(可以先声明后赋值)

    • final修饰的是成员属性,必须在声明使赋值

  • final用于修饰类

  • final用于修饰方法

  • 全局常量(public static final)



抽象类

不能被实例化

在抽象类的使用中有几个原则:

  • 抽象类本身是不能直接进行实例化操作的,即:不能直接使用关键字new完成。

  • 一个抽象类必须被子类所继承,被继承的子类(如果不是抽象类)则必须覆写(重写)抽象类中的全部抽象方法。

如果想对类的抽象部分进行实例化怎么办?

  • 必须把抽象,模糊的部分明确(即编写一个子类,把原来在父类不能确定的部分在子类中确定下来。)这种操作称为重写抽象类中的抽象方法

抽象方法

只声明而未实现的方法称为抽象方法(未实现指的是:没有“{}”方法体),抽象方法必须使用abstract关 键字声明。

格式:

abstract class 类名{ // 抽象类 
    public abstract void 方法名() ; // 抽象方法,只声明而未实现 }


常见问题

1、 抽象类能否使用final声明?

不能,因为final属修饰的类是不能有子类的 , 而抽象类必须有子类才有意义,所以不能。

2、 抽象类能否有构造方法?

能有构造方法,而且子类对象实例化的时候的流程与普通类的继承是一样的,都是要先调用父类中的

构造方法(默认是无参的),之后再调用子类自己的构造方法。

抽象类和普通类的区别

1、抽象类必须用public或procted 修饰(如果为private修饰,那么子类则无法继承,也就无法实现其

抽象方法)。默认缺省为 public

2、抽象类不可以使用new关键字创建对象, 但是在子类创建对象时, 抽象父类也会被JVM实例化。

3、如果一个子类继承抽象类,那么必须实现其所有的抽象方法。如果有未实现的抽象方法,那么子类也必须定义为 abstract类



接口

概念

如果一个类中的全部方法都是抽象方法,全部属性都是全局常量,那么此时就可以将这个类定义成一个接口。

定义格式:

interface 接口名称{ 
    全局常量 ; 
    抽象方法 ; 
}

面向接口编程思想

这种思想是接口是定义(规范,约束)与实现(名实分离的原则)的分离。

优点:

1、 降低程序的耦合性

2、 易于程序的扩展

3、 有利于程序的维护


接口的实现 implements

接口可以多实现: 
格式:
class 子类 implements 父接口1,父接口2...{ 
} 
以上的代码称为接口的实现。那么如果一个类即要实现接口,又要继承抽象类的话,则按照以下的格式编写 即可:
class 子类 extends 父类 implements 父接口1,父接口2...{
}


全局常量和抽象方法的简写

因为接口本身都是由全局常量和抽象方法组成 , 所以接口中的成员定义可以简写:

1、全局常量编写时, 可以省略public static final 关键字,例如:

public static final String INFO = "内容" ;

简写后:

String INFO = "内容" ;

2、抽象方法编写时, 可以省略 public abstract 关键字, 例如:

public abstract void print() ;

简写后:

void print() ;


接口的继承

接口因为都是抽象部分, 不存在具体的实现, 所以允许多继承,例如:

interface C extends A,B{ 

} 

注意

如果一个接口要想使用,必须依靠子类。 子类(如果不是抽象类的话)要实现接口中的所有抽象方法。


接口和抽象类的区别

1、抽象类要被子类继承,接口要被类实现。

2、接口只能声明抽象方法,抽象类中可以声明抽象方法,也可以写非抽象方法。

3、接口里定义的变量只能是公共的静态的常量,抽象类中的变量是普通变量。

4、抽象类使用继承来使用, 无法多继承。 接口使用实现来使用, 可以多实现

5、抽象类中可以包含static方法 ,但是接口中不允许(静态方法不能被子类重写,而接口中所以的方法必须要子类继承和重写,因此接口中不能声明 静态方法)

6、接口不能有构造方法,但是抽象类可以有



多态

概念

多态:就是对象的多种表现形式,(多种体现形态)


多态的体现

对象的多态性,从概念上非常好理解,在类中有子类和父类之分,子类就是父类的一种形态 ,对象多态性 就从此而来。

ps: 方法的重载 和 重写 也是多态的一种, 不过是方法的多态(相同方法名的多种形态)。

重载: 一个类中方法的多态性体现

重写: 子父类中方法的多态性体现。


instanceof关键字

作用:

判断某个对象是否是指定类的实例,则可以使用instanceof关键字

格式:

实例化对象 instanceof 类 //此操作返回boolean类型的数据

public static void say(Person4 p) {  //面向接口编程:接口可以作为函数的形参,实参是实现接口具体功能的子类
        
        //如何判断传入的对象 是此类型的哪种形态(哪个子类的对象)
        /**
         * 格式:
         * 实例化对象  instanceof 类    //此操作返回boolean类型的数据
         * 
         */
        
        if(p instanceof Student4) {
            Student4 s = (Student4) p;
            s.say();
        }
        else {
            System.out.println("必须输入学生形态,才可以执行");
        }
    }


面向接口编程:接口可以作为函数的形参,实参是实现接口具体功能的子类


Object类

概念

Object类是所有类的父类(基类),如果一个类没有明确的继承某一个具体的类,则将默认继承Object 类。
例如我们定义一个类: 
public class Person{ }
其实它被使用时 是这样的: 
public class Person extends Object{ }


Object的多态

使用Object可以接收任意的引用数据类型,例子如下图

JavaEE基础编程语法--面向对象入手解析语法


查看类的源码:放到类的位置上,然后用ctrl+鼠标左键


toString方法

建议重写Object中的toString方法。 此方法的作用:返回对象的字符串表示形式。

Object的toString方法, 打印对象时默认返回对象的内存地址 。如下图所示。

JavaEE基础编程语法--面向对象入手解析语法

在类里面修改tostring方法(可以用shift+alt+s)之后,如下图

JavaEE基础编程语法--面向对象入手解析语法

JavaEE基础编程语法--面向对象入手解析语法


equals

与tostring一样,建议重写Object中的equals(Object obj)方法,此方法的作用:指示某个其他对象是否“等于”此对象。

Object的equals方法:实现了对象上最具区别的可能等价关系; 也就是说,对于任何非空引用值x和

y ,当且仅当x和y引用同一对象( x == y具有值true )时,此方法返回true 。


equals方法重写时的五个特性:

自反性 :对于任何非空的参考值x , x.equals(x)应该返回true 。

对称性 :对于任何非空引用值x和y , x.equals(y)应该返回true当且仅当y.equals(x)回报

true 。

传递性 :对于任何非空引用值x , y和z ,如果x.equals(y)回报true个y.equals(z)回报true

,然后x.equals(z)应该返回true 。

一致性 :对于任何非空引用值x和y ,多次调用x.equals(y)始终返回true或始终返回false ,前

提是未修改对象上的equals比较中使用的信息。

非空性 :对于任何非空的参考值x , x.equals(null)应该返回false 。

可以用shift+alt+s一键生成对应类默认的equals,一般无特殊需求建议用此方法进行equals改写。


内部类

概念

在Java中,可以将一个类定义在另一个类里面或者一个方法里面,这样的类称为内部类。

广泛意义上的内部类一般来说包括这四种:

1、成员内部类

2、局部内部类

3、匿名内部类

4、静态内部类


成员内部类

成员内部类是最普通的内部类,它的定义为位于另一个类的内部,形如下面的形式:

 class Outer { 
    private double x = 0; 
    public Outer(double x) { 
        this.x = x; 
    }
    class Inner { //内部类 
        public void say() { 
            System.out.println("x="+x); 
        } 
    } 
 }

特点:

  • 成员内部类可以无条件访问外部类的所有成员属性和成员方法(包括private成员和静态成员)。

  • 不过要注意的是,当成员内部类拥有和外部类同名的成员变量或者方法时,会发生隐藏现象,即默 认情况下访问的是成员内部类的成员。如果要访问外部类的同名成员,需要以下面的形式进行访问:

    • 外部类.this.成员变量

    • 外部类.this.成员方法


内部类的应用:作为实现接口的子类。

注意:局部内部类就像是方法里面的一个局部变量一样,是不能有public、protected、private以及 static修饰符的。


匿名内部类

匿名内部类由于没有名字,所以它的创建方式有点儿奇怪。创建格式如下:

new 父类构造器(参数列表)|实现接口() 
{
    //匿名内部类的类体部分 
}

注意:

在使用匿名内部类的过程中,我们需要注意如下几点:

1、使用匿名内部类时,我们必须是继承一个类或者实现一个接口,但是两者不可兼得,同时也只能

继承一个类或者实现一个接口。

2、匿名内部类中是不能定义构造函数的。

3、匿名内部类中不能存在任何的静态成员变量和静态方法。

4、匿名内部类为局部内部类,所以局部内部类的所有限制同样对匿名内部类生效。

5、匿名内部类不能是抽象的,它必须要实现继承的类或者实现的接口的所有抽象方法。

6、只能访问final型的局部变量


所有的局部内部类只能访问final型的局部变量

因为局部类是单独编译成一个.class文件,所有要使用a的话,具备了在编译成.class文件时,备份了a的值在.class文件中,但是由于局部类和主程序是编译成两个不同的.class文件,所以a必须是被final修饰的常量,否则a是常量的话,就会发生如果在主程序中a的值发生变化,而局部类中所用的a并没有及时改变,导致逻辑和程序出错。

简单来说,就是因为局部类被单独编译成.class文件,所以必须使用常量。

JavaEE基础编程语法--面向对象入手解析语法


静态内部类

静态内部类也是定义在另一个类里面的类,只不过在类的前面多了一个关键字static。

静态内部类是不需要依赖于外部类对象的,这点和类的静态成员属性有点类似,并且它不能使用外部类的非 static成员变量或者方法.


包装类

存储原理

int 类型变量储存在栈中,Integer对象如下。

Integer包装类的好处:

  • 可以作为函数的参数进行传递

  • Integer还有很多其他的方法可以进行整数操作,如Integer.parseInt(“"")方法,可以把字符串转化为相应的整型。

JavaEE基础编程语法--面向对象入手解析语法


八种基本类型的包装类

概述

在Java中有一个设计的原则“一切皆对象”,那么这样一来Java中的一些基本的数据类型,就完全不符合于 这种设计思想,因为Java中的八种基本数据类型并不是引用数据类型,所以Java中为了解决这样的问题,引入了八种基本数据类型的包装类。

JavaEE基础编程语法--面向对象入手解析语法

以上的八种包装类,可以将基本数据类型按照类的形式进行操作。

但是,以上的八种包装类也是分为两种大的类型的:

  • Number:Integer、Short、Long、Double、Float、Byte都是Number的子类表示是一个

数字。

  • Object:Character、Boolean都是Object的直接子类。


装箱和拆箱操作

以下以Integer和Float为例进行操作

  • 将一个基本数据类型变为包装类,那么这样的操作称为装箱操作。

  • 将一个包装类变为一个基本数据类型,这样的操作称为拆箱操作,

因为所有的数值型的包装类都是Number的子类,Number的类中定义了如下的操作方法,以下的全部方法都是进行拆箱的操作。

JavaEE基础编程语法--面向对象入手解析语法

版本更新

JavaEE基础编程语法--面向对象入手解析语法

查看类的结构:把鼠标放在类的位置上,然后按ctrl +T即可查看。

字符串转换

JavaEE基础编程语法--面向对象入手解析语法


可变参数

一个方法中定义完了参数,则在调用的时候必须传入与其一一对应的参数,但是在JDK 1.5之后提供了新的 功能,可以根据需要自动传入任意个数的参数。

语法:

返回值类型 方法名称(数据类型…参数名称){ 

//参数在方法内部 , 以数组的形式来接收 

} 

注意:

  • 可变参数只能出现在参数列表的最后

JavaEE基础编程语法--面向对象入手解析语法


递归

递归,在数学与计算机科学中,是指在方法的定义中使用方法自身。也就是说,递归算法是一种直接或者间 接调用自身方法的算法。

递归流程图如下:

JavaEE基础编程语法--面向对象入手解析语法


递归实现5的阶乘的程序分析

JavaEE基础编程语法--面向对象入手解析语法

本文地址:https://blog.csdn.net/qq_36279562/article/details/108035938