Java学习笔记-03【面向对象】【上】

已于 2022-08-23 19:18:12 修改
阅读量824 收藏 2
点赞数 1
分类专栏： Java学习笔记 文章标签： java 学习 开发语言
于 2022-07-07 20:18:10 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiaochen_2715/article/details/125666349
版权

Java学习笔记-03【面向对象】【上】

面向对象的特点

封装性（是面向对象的核心思想，将对象的属性和行为封装起来）、继承性（主要描述类与类之间的关系，通过继承，可以在无需重新编写原有类的情况下，对原有类的功能进行扩展）和多态性（指的是在程序中允许出现重名现象，它指在一个类中定义的属性和方法被其他类继承后，它们可以具有不同的数据类型或表现出不同的行为，使得同一个属性和方法在不同的类中具有不同的语义。例如听到cut时，理发师的行为是剪发，演员的行为是停止表演）。

在程序中创建对象，首先需要定义一个类。类中可以定义成员变量（用于描述对象的特征）和成员方法（用于描述对象的行为）。

class Person{
    int age = 23;   //定义在类中的变量为成员变量
    //定义speak()方法
    void speak(){
        int age = 30;   //定义在方法中的变量为局部变量
        System.out.println("我今年"+age+"岁！");
        /*局部变量可以和成员变量同名，此时方法中通过变量名访问到的是局部变量*/
    }
}

class Person{
    int age;
    void speak(){
        System.out.println("我今年"+age+"岁！");
    }
}
public class Test {
    public static void main(String[] args) {
        Person p1 = new Person();
        Person p2 = new Person();
        p1.age = 23;
        p1.speak();
        p2.speak();
    }
}

运行结果：

我今年23岁！
我今年0岁！

注：在实例化对象时，Java虚拟机会自动为成员变量进行初始化。但是局部变量必须赋值，否则会报错。

类的封装

是指在定义一个类时，将类中的属性私有化，即是用private关键字来修饰，私有属性只能在它所在类中被访问。公有的获取属性值的getXxx()方法和设置属性值额setXxx()方法。

class Student{
    private int age;    //将age属性私有化
    private String name;    //将name属性私有化
    //下面是公有的获取属性值的getXxx()方法和设置属性值额setXxx()方法
    public String getName(){
        return name;
    }
    public void setName(String stuName){
        name = stuName;
    }
    public int getAge(){
        return age;
    }
    public void setAge(int stuAge){
        //下面对传入的参数进行检验
        if(stuAge<=0)
            System.out.println("年龄不合法...");
        else
            age = stuAge;
    }
    public void introduce(){
        System.out.println("大家好，我叫"+name+"，今年"+age+"岁！");
    }
}
public class Test {
    public static void main(String[] args) {
        Student stu = new Student();
        stu.setAge(-30);
        stu.setName("Payne");
        stu.introduce();
    }
}

运行结果：

年龄不合法...
大家好，我叫Payne，今年0岁！

构造方法

构造方法的定义：必须满足以下三个条件：

  1. 方法名与类名相同
  2. 在方法名的前面没有返回值类型的声明
  3. 在方法中不能使用return语句返回一个值

无参构造

/*Person类中定义了一个无参的构造方法Person()。“new Person()”语句除了会实例化Person对象，还会调用构造方法Person()。*/
class Person{
    public Person(){
        System.out.println("无参的构造方法被调用了...");
    }
}
public class Test {
    public static void main(String[] args) {
        Person p = new Person();    //实例化Person对象
    }
}

运行结果：

无参的构造方法被调用了...

有参构造

/*Person类中定义了有参的构造方法Person(int a)。“new Person(23)”会在实例化对象的同时调用有参的构造方法，并传入参数23。*/
class Person{
    int age;
    public Person(int a){
        age = a;    //为age属性赋值
    }
    public void speak(){
        System.out.println("I am "+age+" years old.");
    }
}
public class Test {
    public static void main(String[] args) {
        Person p = new Person(23);    //实例化Person对象
        p.speak();
    }
}

运行结果：

I am 23 years old.

构造方法的重载

与普通方法一样，构造方法也可以重载，在一个类中可以定义多个构造方法，只要每个构造方法的参数类型或参数个数不同即可。

/*Person类中定义了两个构造方法，它们构成了重载。*/
class Person{
    int age;
    String name;
    //定义两个参数的构造方法
    public Person(String n,int a){
        name = n;   //为name属性赋值
        age = a;    //为age属性赋值
    }
    //定义一个参数的构造方法
    public Person(int a){
        age = a;    //为age属性赋值
    }
    public void speak(){
        System.out.println("My name is "+name+" ,"+"I am "+age+" years old.");
    }
}
public class Test {
    public static void main(String[] args) {
        Person p1 = new Person("Payne",23);
        Person p2 = new Person(23);
        p1.speak();
        p2.speak();
    }
}

运行结果：

My name is Payne ,I am 23 years old.
My name is null ,I am 23 years old.

注：

  1. 在Java中的每个类都至少有一个构造方法，即使没有定义构造方法，系统也会默认创建一个没有参数的构造方法。如class Person{}和class Person{public Person(){}}完全一样。
  2. 当在类中定义了有参的构造方法后，在main函数里实例化对象是必须写参数，否则会报错，如在上面代码中添加Person p3 = new Person();后会报错。
  3. 构造方法通常用public修饰，当使用private修饰时，无法在外部创建该类的实例对象。

this关键字

  1. 通过this关键字可以明确的访问成员变量，解决与局部变量的冲突问题。

    class Person{
    int age;    //定义成员变量
    public Person(int age){
        this.age = age;    //this.age代表成员变量
    }
    public int getAge(){
        return this.age;
    }
}

  2. 通过this关键字调用成员方法。

    class Person{
    public void openMounth(){
        
    }
    public void speak(){
        //调用成员方法，此处的this可以不写
        this.openMounth();
    }
}

  3. 构造方法是在实例化对象时被Java虚拟机自动调用的，在程序中不能像调用其他方法一样去调用构造方法，但可以在一个构造方法中使用this([参数1，参数2...])的形式来调用其他的构造方法。

    class Person{
    public Person(){
        System.out.println("无参的构造方法被调用了...");
    }
    public Person(String name){
        this();     //调用无参的构造方法
        System.out.println("有参的构造方法被调用了...");
    }
}

注（以下三点仅限于构造方法中使用this，成员方法不同）：

  1. 只能在构造方法中使用this调用其他的构造方法，不能在成员方法中使用。
  2. 在构造方法中，用this调用构造方法的语句必须位于第一行，且只能出现一次。
  3. 不能在一个类的两个构造方法中使用this互相调用，会报错。

垃圾回收

当对象设为null后，该对象就不能调用其他方法，但最后会运行System.gc();调用finalize()方法。

class Person{
    //下面定义的finalize方法会在垃圾回收前被调用
    public void finalize(){
        System.out.println("对象将被作为垃圾回收...");
    }
}
public class Test {
    public static void main(String[] args) {
        Person p1 = new Person();
        Person p2 = new Person();
        //将变量设置为null，让对象成为垃圾。
        p1 = null;
        p2 = null;
        System.gc();    //调用方法进行垃圾回收
    }
}

运行结果：

对象将被作为垃圾回收...
对象将被作为垃圾回收...

static关键字

静态变量

可以使用static关键字来修饰成员变量，该变量称作静态变量。静态变量被所有实例共享，可以使用类名.变量名的形式直接访问，也可以通过类的实例对象来访问。（static只能修饰成员变量，不能修饰局部变量）

class Person{
    static String sex;  //定义静态变量sex
}
public class Test {
    public static void main(String[] args) {
        Person p1 = new Person();   //创建对象p1
        Person p2 = new Person();   //创建对象p2
        Person.sex = "男";   //为静态变量赋值
        System.out.println("p1的性别是："+p1.sex);   //打印p1的性别
        System.out.println("p2的性别是："+p2.sex);   //打印p2的性别
    }
}

运行结果：

p1的性别是：男
p2的性别是：男

静态方法

静态方法，只需要在类中定义的方法前加static关键字即可，可以实现在不创建对象的情况下调用该方法。静态方法可以使用类名.方法名的方式来访问，也可以通过类的实例对象来访问。

class Person{
    //定义静态方法
    public static void sayHello(){
        System.out.println("Hello");
    }
}
public class Test {
    public static void main(String[] args) {
        Person.sayHello();  //调用静态方法
    }
}

运行结果：

Hello

静态代码块

用大括号包围起来的若干行代码称为代码块，用static关键字修饰的叫静态代码块。

class Person{
    static String country;
    //静态代码块
    static {
        country = "China";
        System.out.println("Person类中的静态代码块执行了");
    }
}
public class Test {
    //静态代码块
    static {
        System.out.println("测试类的静态代码块执行了");
    }
    public static void main(String[] args) {
        //下面创建了两个Person对象,静态代码块会被执行
        Person p1 = new Person();
        Person p2 = new Person();
        //由于类只加载一次，所以静态代码块只执行一次
    }
}

运行结果：

测试类的静态代码块执行了
Person类中的静态代码块执行了

单例模式

在设计一个类时，需要保证整个程序在运行期间针对该类只存在一个实例对象。就好比月亮这个类，只存在一个。

单例模式分为两类：懒汉式与饿汉式。

懒汉式即用的时候再去创建对象，饿汉式即一上来就先创建好对象，两者区别只是对象创建的时间不同而已。

//饿汉式
class Single1{
    //饿汉式提前在类的内部创建一个该类的实例对象
    private static Single1 single1 = new Single(); 
    //私有化构造方法，这样就不能在类的外部使用new关键字来创建实例对象了
    private Single1(){}
    //提供返回该对象的静态方法
    public static Single1 getInstance(){
        return single1;
    }
}
//懒汉式
class Single2{
    //懒汉式先在类的内部创建一个空对象
    private static Single2 single2 = null; 
    //私有化构造方法，这样就不能在类的外部使用new关键字来创建实例对象了
    private Single2(){}
    //提供返回该对象的静态方法
    public static Single2 getInstance(){
        if(single2 == null){
            single2 = new Single2();
        }
        return single2;
    }
}
public class Test {
    public static void main(String[] args) {
        Single s1 = Single.getInstance();
        Single s2 = Single.getInstance();
        System.out.println(s1==s2);
    }
}

运行结果：

true

内部类

成员内部类

class Outer{
    private int num = 23;   //定义类的成员变量
    //下面的代码定义了一个成员方法，方法中访问内部类
    public void test(){
        Inner inner = new Inner();
        inner.show();
    }
    //下面的代码定义了一个成员内部类
    class Inner{
        void show(){
            //在成员内部类的方法中访问外部类的成员变量
            System.out.println("num = "+num);
        }
    }
}
public class Test {
    public static void main(String[] args) {
        Outer outer = new Outer();  //创建外部类对象
        outer.test();   //调用test()方法
        
        //外部类名.内部类名 变量名 = new 外部类名().new 内部类名()
        Outer.Inner inner = new Outer().new Inner();//这里的new Outer()也会调用构造方法
        inner.show();
    }
}

运行结果：

num = 23
num = 23

静态内部类

可以使用static关键字来修饰一个成员内部类，该内部类称为静态内部类，它可以在不创建外部类对象的情况下被实例化。

class Outer{
//这里写static可以让静态内部类调用此变量
    private static int num = 23;
    //下面的代码定义了一个静态内部类
    static class Inner{
        void show(){
            System.out.println("num = "+num);
        }
    }
}
public class Test {
    public static void main(String[] args) {
        //外部类名.内部类名 变量名 = new 外部类名.内部类名();
        Outer.Inner inner = new Outer.Inner();  //创建内部类对象
        inner.show();   //调用内部类方法
    }
}

运行结果：

num = 23

注：在静态内部类中可以定义静态成员，而在非静态的内部类中不允许定义静态的成员。

方法内部类

方法内部类是指在成员方法中定义的类，他只能在当前方法中被使用。

class Outer{
    private int num = 23;   //定义成员变量
    public void test(){
        //下面是在方法中定义的内部类
        class Inner{
          void show(){
              System.out.println("num = "+num); //访问外部类的成员变量
          }
        }
        Inner inner = new Inner();     //创建内部类对象，方法内部类只能在其定义的当前方法中进行实例化
        inner.show();      //调用内部类方法
    }
}
public class Test {
    public static void main(String[] args) {
        Outer outer = new Outer();  //创建外部类对象
        outer.test();   //调用test()方法
    }
}

运行结果：

num = 23

Java的文档注释

以/* * 开头，以*/结束。

/**
 * @author 用于对类的说明，表示这个程序的作者。
 * @version 用于对类的说明，表示这个程序的开发版本号。
 * @param 用于对方法的说明，表示方法定义的参数以及参数对应的说明。
 * @return 用于对方法的说明，表示方法的返回值代表的意义。
 */
小辰~
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Java面向对象选择题
PPDY93的博客
11-13 3464
一、选择题 在java中，以下程序的运行结果是（C） A. 输出：null B.正常运行，但不会输出任何内容 C. 编译出错，不能运行 D. 能运行，但运行时会出现异常 在类的继承关系中，需要遵循以下哪个继承原则？（B ） A 多重 B 单一 C 双重 D 不能继承 下面代码运行的正确结果是（C） A 编译错误，无法正常运行 B 编译正确，但运行时产生错误 C hello D world （A）空间用于存储使用new关键字所创建的对象 A 堆 B 栈 C 代码
this关键字的使用注意
m0_53291740的博客
11-27 1204
只能在构造方法中使用this()调用其他的构造方法，不能在成员方法中使用。 在构造方法中使用this()调用构造方法的语句必须位于第一行，而且只能出现一次。 不能在一个类中的两个构造方法中使用this()互相调用。 public class Student { String name;//成员变量name int age; public Student() { System.out.println("这是无参构造方法...."); }
Java中使用this调用构造方法
最新发布
a402498234的博客
02-15 3235
在 Java 中，可以使用 this() 关键字来调用同一个类中的其他构造方法。这种方式通常被用于避免代码重复，或者在构造方法中需要进行额外的初始化操作时。
java学习 第三章练习题
yikuaidabin的博客
11-09 7104
java
Java中的this关键字
weixin_42886824的博客
06-18 297
this关键字在程序中的常用用法 通过this关键字访问一个类的成员变量，解决与局部变量名称冲突问题。 class Person{ String name; int age; // 定义两个参数的构造方法 private Person(String name,int age) { this.name = name; this.age = age; } 通过this关...
this调用构造方法那必须放在构造方法中的第一条语句
u012575573的专栏
01-09 5493
public class ThisQuoteTest { String name; int age; String work; public ThisQuoteTest() { this("Lily",23,"teacher"); } public ThisQuoteTest(String name,int age,String work) { this.name =nam
JAVA基础篇（8）——【this调用属性，方法，构造方法】
qq_39077728的博客
07-27 562
  Java关键字this只能用于各种方法方法（普通方法和构造方法）体内。当一个对象创建后，Java虚拟机（JVM）就会给这个对象分配一个引用自身的指针，这个指针的名字就是 this。但是在static修饰的静态方法中，是不允许使用this的，这里需要特别注意！ （1）this 调用属性 public class ThisDemo { String name; int ...
this关键字
xiaoxiaoxinhuan的博客
05-01 560
一、通过this关键字可以明确的去访问一个类的成员变量，解决与局部变量名称冲突问题。 class Person{ int age; public Person(int age){ this.age=age; } }二、通过this关键字调用成员方法。 class Person{ public void openMouth(){
java语法基础8——面向对象(多态)
GXWZ_ljf的博客
06-15 152
多态 接口 接口与接口之间的继承 接口与实现类 多态 1.基本操作 2.调用 类型转换 多态的好处 多态的USB案例
默认空构造方法java_【判断题】Java 中的每个类都至少有一个构造方法，一个类中如果没有定义构造方法，系统会自动为这个类创建一个默认的构造方法。...
weixin_36466165的博客
02-24 1426
水准测量中,转点的作用是_________,在同一转点上,既有_________又有__________读数。说比听重要，说是更重要的沟通技巧。水准点的符号,采用英文字母_______表示。说服对方时，最好站在 的立场。水文化遗产分为哪些两大部分？( )说安宁疗护是医学人道主义的重要发展，是因为( )水中的含盐量对啤酒酿造过程很有影响，常规指标中影响最大的是：税收增加会导致有效需求减少。说...
java每个类都定义构造方法吗,Java中的每个类都至少有一个构造方法,一个类中如果没有定义构造方法,系统会自动为这个类创建一个默认的构造方法。()...
weixin_29483853的博客
03-11 1802
钢轨接头处4根木桥枕(支接时为5根)中有一根或其他部位有连续2根及以上的失效木桥枕时，行车速度大于()km/h区段钢梁明桥面有隔一或连二失效木桥枕时，均应立即抽换。办理二手房交易业务，应进入的功能模块是：()用500V摇表以120r／min的转数摇测低压电器的带电部分与外壳，带电部分之间的绝缘电阻应不低于()MΩ。票务室在节假日前()个工作日对提报的预制单程票进行制作。“清明时节雨纷纷，路上行人欲...
第四章（三）·方法1
Ryan_gos的博客
08-21 265
1.什么是方法？    在java中，方法就是用来完成解决某件事情或实现某个功能的办法。 2.方法的语法格式 在Java中如何声明一个方法，格式如下 修饰符 返回值类型 方法名（参数类型 参数名，参数类型 参数名，……………………）{ 执行语句； 。。。。。。。。。 return 返回值; } 注解 修饰符： 修饰符很多，对其方法进行限定（有可能不是很准确这么说） 返回值类型:用于限制方法返回值类型的数据类型 方法名：该设定此方法的名字 参数类型：用于限定调
什么是构造 java_（Java）什么是构造方法
weixin_36272416的博客
03-02 504
在Java中，每个类都需要至少一个的构造方法(可以有多个)，它用于构造类的对象；在Java中构造方法必须与类名相同；构造方法可以不带有参数、也可以带有参数，不带有参数的构造方法被称为无参构造(no-arg)方法。这里大家可能会觉得奇怪，我们之前的MainClass好像就没有构造方法。其实是这样的，如果我们不给类提供构造方法，编译器会自动提供一个无参构造方法。定义构造方法的语法如下：Java代码co...
题目：关于构造方法，下面说法正确的是（）
qq_42449963的博客
05-16 1万+
题目：关于构造方法，下面说法正确的是（） A、每个类都有至少一个构造方法 B、一个类中可以有多个构造方法 C、构造方法可以有返回值 D、构造方法可以有多个参数 结果：A、B、D 解释： A：即使类中没有定义构造方法，也会具有一个默认的无参构造方法 B：一个类中可以有无参构造方法，可以有多个有参构造方法，这些构造方法构成了方法重载 C：构造方法连返回值类型都没有，哪里来的返回值 D：有参构造方法中可以有多个参数 ...
java中speak方法的意思_21．编写一个Java应用程序，该程序包括3个类：Monkey类、People类和主类 E。要求： (1) Monkey类中有个构造方法：Monkey (String ...
weixin_42509196的博客
02-26 1486
//Monkey类package d922;public class Monkey {Monkey(){}Monkey (String s){System.out.println(s);}public void speak(){System.out.println("咿呀");}}//人类package d922;public class Mankind extends Monkey {publi...
java中speak方法的意思_Java中的關鍵字
weixin_42527464的博客
02-26 1918
首先是訪問控制的關鍵字，分public、protected、default、private四種，權限如下：(權限) public protected default private同一類中 ok ok ok ok同一包中 ok ok ok子類...
Java pta练习题5
20岁不秃头的博客
12-01 2697
判断题 1.声明成员变量时如果没有指定初始值，Java编译器会为其指定默认值。正确答案：T 2.package语句必须放到java程序的最开始。正确答案：T 3.类及其属性、方法可以同时有一个以上的修饰符来修饰。正确答案：T
面向对象（五） this关键字
浩气长存在心中的博客
04-09 589
this关键字 使用this关键字调用本类中的属性 使用this关键字调用成员方法 使用this关键字调用构造方法
JAVA语言中的this关键字用法
weixin_68138130的博客
07-16 1632
JAVA语言中的this关键字用法
JAVA练习题二（类与对象）
热门推荐
仙王狂虐战神
03-13 1万+
一.单选题（共61题,100.0分） 1 下列关于面向对象的说法中,错误的是( )。 A、面向对象思想编程,不仅增强代码了复用性,提供了开发效率,而且为程序的修改补充提供了便利。 B、面向对象就是分析解决问题所需要的步骤,然后用函数把这些步骤一一实现,使用的时候一个一个依次调用 C、面向对象是把解决的问题按照一定规则划分为多个独立的对象,然后通过调用对象的方法来解决问题 D、面向对象虽然使程序的开...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小辰~

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值