Java面向对象复习笔记

最新推荐文章于 2024-07-08 14:58:49 发布
最新推荐文章于 2024-07-08 14:58:49 发布
阅读量112 收藏
点赞数 1
分类专栏： Java基础 文章标签： java 面向对象编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xingranzhihuo/article/details/116791856
版权

Java面向对象复习笔记

一、Java内存简单解析

二、属性（成员变量）VS局部变量

相同点

  1. 定义变量的格式相同：数据类型 变量名 = 变量值；
  2. 先声明，后使用。
  3. 变量都有其对应的作用域。

不同点

  1. 在类中声明的位置不同，属性是直接定义在类的一对{}内，而局部变量生命在方法内、方法形参、代码块内、构造器形参、构造器内部变量；
  2. 权限修饰符不同。声明属性时指明其权限，局部变量不可以使用权限修饰符。
  3. 属性是有默认初始化值，而局部变量没有初始化值，所以必须声明初始值。特别地，形参调用时在方法（）里面直接赋值即可。
  4. 内存中加载的位置。属性：加载到堆空间（非static）;局部变量加载到栈空间。

三、对象数组的内存解析

四、关于匿名对象的使用

注意：下面这个例子说明匿名对象是可以实现多次调用的。

public class ClassSolution {
    public static void main(String[] args) {
        PhoneMall p= new PhoneMall();
        p.show(new Phone());
    }
}
class Phone {
    public void playGame () {
        System.out.println("玩游戏");
    }
    public void chat () {
        System.out.println("聊天");
    }

}
class PhoneMall {
    public void show (Phone phone) {
        phone.playGame();
        phone.chat();
    }
}

这里复习一下，在Java中相同包下不同类方法调用时，如果是静态方法，直接调用即可；如果不是则应该先声明该类的对象实例再调用。

五、可变个数的形参

JavaSE5.0提供了Varargs(Variable Number of Arguments)机制，允许直接定义能和多个实参相匹配的形参。具体用法见实例。

import java.util.Arrays;

public class ClassSolution {
    public static void main(String[] args) {
        Phone test = new Phone();
        test.show("d");
        test.show("d", "da");
        test.show("d", "da", "dad");

    }
}
class Phone {
    public void show (String ... string) {
        System.out.println(Arrays.toString(string));
    }

}

作为对比：

JDK5.0之前

public void show (int a, String [] string)

JDK5.0之后

public void show (int a, String ... string) // 参数可变

特别地，此种特性也可以重载，代码如下：

public void show (String s) {}
public void show (String ... s) {}
// 但是下面这种方法是和可变个数形参方法冲突的，不可以称为重载
public void show (String[] s) {}

类比可得，这里的String可变个数形参和String数组是相同的，所以想要得到每一个元素或者打印出来遍历时直接采用数组操作即可。值得注意的是：遍历计数器上限是string.length而不是string.length()，因为string被视为数组。代码如下：

import java.util.Arrays;

public class ClassSolution {
    public static void main(String[] args) {
        Phone test = new Phone();
        test.show("d", "da", "dad");

    }
}
class Phone {
    public void show (String ... string) {
        //System.out.println(Arrays.toString(string));
        for (int i = 0; i < string.length; i++) {
            System.out.print(string[i]);
        }

    }

}

注意：一个方法中最多含有一个可变个数形参，并且只能放在方法最后面，原因显而易见，多了或者没有放在最后都会导致编译器无法分清楚参数到底是谁的，匹配失败。

六、JavaBean拓展

JavaBean特性

  • 类是公共的；
  • 有一个无参的公共的构造方法（构造器）；
  • 有属性，且有对应的get,set方法。

这样的类称为一个JavaBean。

七、Object类

当我们输出一个对象的引用时，实际上就是调用当前对象的toString()方法。

常见的String,Date,File,包装类等都重写了toString()方法。

八、基本数据类型、包装类与String型相互转化

基本数据类型、包装类转化为String

①连接运算

int num = 10;
String str = num + "";

②调用String 重写的valueOf方法

int num = 10;
String str = String.valueOf(num);

String转化为基本数据类型、包装类

调用包装类parsexxx方法

String str = "123";
int num = Integer.parseInt(str);

九、Integer Cache

Integer内部定义了IntegerCache结构，IntegerCache中定义了Integer[]，保存了从-128到127范围内所有整数，所以如果使用自动装箱的方式，给Integer赋值的范围在这个范围之内时，可以直接使用该数组中的元素，不用再去new了，提高效率。

Integer i = 1;
Integer j = 1;
System.out.println(i == j); // true
//**************f分割线*****************
Integer m = 128;
Integer n = 128;
System.out.println(m == n); // false

十、单例模式

饿汉式

public class SingletonTest1 {
	public static void main (String[] args) {
        Bank bank1 = new Bank();
        Bank bank2 = new Bank();
        System.out.println(bank1 == bank2);// true
    }
}
class Bank {
	// 1.私有化类的构造器
    private Bank() {
	
    }
    // 2.内部创建类的对象
    // 4.所以对象也得声明为静态
    private static Bank instance = new Bank();
    // 3.提供公共的方法，返回类的对象(静态方法只能调用静态结构)
    public static Bank getInstance () {
        return instance;
    }
}

懒汉式

public class SingletonTest2 {
	public static void main (String[] args) {
        Order order1 = new Order();
        Order order2 = new Order();
        System.out.println(order1 == order2);// true
    }
}
class Order {
    // 1.私有化类的构造器
    private Order() {

    }
    // 2.声明当前类对象，并未初始化
    // 4. 同样该对象设置成static
    private static Order instance = null;
    // 3.声明public，static的返回当前类对象的方法
    public static Order getInstance() {
        if (instance == null) {
            instance = new Order();
        }
        return instance;
    }

}

饿汉式VS懒汉式

饿汉式：

坏处：对象加载时间过长；

好处：饿汉式是线程安全的。

懒汉式：

好处：延迟对象的创建；

坏处：目前的写法线程不安全。

十一、对于属性赋值的顺序

  1. 默认初始化
  2. 显式初始化 / 代码块中赋值
  3. 构造器中初始化
  4. 有了对象以后，通过“对象.属性”或者“对象.方法”的方式进行赋值

十二、abstract注意点

  1. abstract不能用来修饰属性，构造器等结构；
  2. abstract不能用来修饰私有方法，静态方法，final方法和类。

十三、多态的应用：模板方法设计模式

解决的问题：在软件开发中实现一个算法，整体步骤固定通用，并且在父类中已经写好了；但是某些部分易变，易变部分可以抽象出来，供不同子类实现。这就是模板模式。

public class ClassSolution {
    public static void main(String[] args) {
        Template t = new SubTemplate();
        t.spendTime();
    }
}
abstract class Template {
    public void spendTime() {
        long start = System.currentTimeMillis();
        // 这里就是不确定的，易变的代码
        this.code();
        long end = System.currentTimeMillis();
        System.out.println("运行时间为： " + (end - start));
    }
    public abstract void code();
}
class SubTemplate extends Template{
    @Override
    public void code() {
        for (int i = 0; i < 100; i++) {
            System.out.println(i);
        }
    }
}

十四、工厂模式

实现了创建者与调用者的分离。即将创建对象的具体过程屏蔽隔离起来，达到提高灵活性的目的。

核心本质

  • 实例化对象，用工厂方法代替new操作；
  • 将选择实现类，创建对象统一管理，从而将调用者和实现类解耦。

1.无工厂模式

public class ClassSolution {
    public static void main(String[] args) {
        Car a = new Audi();
        Car b = new BYD();
        a.run();
        b.run();
    }
}
interface Car {
    public void run();
}
class Audi implements Car{
    @Override
    public void run(){
        System.out.println("奥迪");
    };
}
class BYD implements Car{
    @Override
    public void run(){
        System.out.println("比亚迪");
    };
}

2.简单工厂模式

public class ClassSolution {
    public static void main(String[] args) {
        Car a = CarFactory.getAudi();
        Car b = CarFactory.getBYD();
        a.run();
        b.run();
    }
}
interface Car {
    public void run();
}
class Audi implements Car{
    @Override
    public void run(){
        System.out.println("奥迪");
    };
}
class BYD implements Car{
    @Override
    public void run(){
        System.out.println("比亚迪");
    };
}
class CarFactory {
    public static Car getAudi() {
        return new Audi();
    }
    public static Car getBYD() {
        return new BYD();
    }
}

这种简单的工厂模式实现了调用者和创建者隔离，但是也有缺点：对于新增产品，不修改代码的话，无法扩展，违反了开闭原则。

3.工厂方法模式

为了避免简单工厂模式的缺点，这种方法模式有一组实现了相同接口的工厂类，而简单工厂模式只有一个工厂类。

interface Car {
    public void run();
}
class Audi implements Car{
    @Override
    public void run(){
        System.out.println("奥迪");
    };
}
class BYD implements Car{
    @Override
    public void run(){
        System.out.println("比亚迪");
    };
}
// 工厂接口
interface CarFactory {
    Car getCar();
}
class AudiFactory implements CarFactory{
    @Override
    public Audi getCar() {
        return new Audi();
    }
}
class BYDFactory implements CarFactory{
    @Override
    public BYD getCar() {
        return new BYD();
    }
}
public class ClassSolution {
    public static void main(String[] args) {
        Car a = new AudiFactory().getCar();
        Car b = new BYDFactory().getCar();
        a.run();
        b.run();
    }
}

上述方法模式算是基本实现了开闭原则，当出现新的车系时只需要添加新的实现工厂类就行。

十五、Java8新特性

  • 在接口中，除了抽象方法和全局静态变量之外，JDK8也允许定义静态方法和默认方法。
    • 接口中的静态方法只能自己调用，不能有继承该接口的子类调用；
    • 如果子类（或者实现类）继承的父类和实现的接口中声明了同名同参数的默认方法，那么子类在没有重写此方法的情况下，默认调用的是父类中的同名同参数的方法。（类优先原则）
    • 如果实现类实现了多个接口，而这多个接口中定义了同名同参数的默认方法，那么在实现类没有重写此方法的情况下，报错。接口冲突。

十六、局部内部类典型应用

public Comparable getComparable() {
	// 创建一个实现Comparable接口的类：局部内部类
    class MyComparable implements Comparable {
        @Override
        public int comparaTo(Object o) {
            return 0;
        }
    }
    return new MyComparable();
}

能自己调用，不能有继承该接口的子类调用；

  • 如果子类（或者实现类）继承的父类和实现的接口中声明了同名同参数的默认方法，那么子类在没有重写此方法的情况下，默认调用的是父类中的同名同参数的方法。（类优先原则）
  • 如果实现类实现了多个接口，而这多个接口中定义了同名同参数的默认方法，那么在实现类没有重写此方法的情况下，报错。接口冲突。

十六、局部内部类典型应用

public Comparable getComparable() {
	// 创建一个实现Comparable接口的类：局部内部类
    class MyComparable implements Comparable {
        @Override
        public int comparaTo(Object o) {
            return 0;
        }
    }
    return new MyComparable();
}
莫枢
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 6
    评论
专栏目录
Java核心代码例程
eako的专栏
02-21 1270
Java核心代码例程1.Java核心代码例程之：HelloWorld.java// The most basic Java program public class HelloWorld {    public static void main(String args[]) throws Exception    {        System.out.println("Hello World
Java面向对象笔记
weixin_43744819的博客
05-15 86
面向对象 面向过程 & 面向对象 面向过程思想 步骤清晰简单，一步一步做 面对过程适合处理一些比较简单的问 面向对象思想 物以类聚，分类的思想，思想问题首先会解决问题需要哪些分类，然后对这些分类进行单独思考。最后才对某个分类下的细节进行面向过程的思索。 面向对象适合处理复杂的问题，适合处理需要多人协作的问题 什么是面向对象 面向对象编程 (Object Oriented Programming，OOP) 面向对象编程的本质就是：以类的方式组织代码，以对象的组织（封装）数据 抽象 三
牛客笔试main方法基本常识
qq_40813329的博客
11-23 851
main方法调用执行 自己导包 import 通过main方法调用 import java.lang.*; import java.util.*; public class Main{ public static void main(String[] args){ Scanner scanner=new Scanner(System.in); int testNums=scanner.nextInt(); for(int i=0;i<testN
面向对象Java知识笔记
今天会营业的博客
04-12 96
类： 类其实就是一种定义的模板 比如：猫类的定义是：四只脚，会抓老鼠。那么，所有有四只脚，会抓老鼠的动物都称作猫。 对象（对象=数据+操作） 对象是具体到某一个东西，是一个实体 比如：我们遇到一只猫 ，猫就是一个对象，猫是通过猫类（四只脚，会抓老鼠）的内容来定义的 数据：属性和状态（具有什么特征） 操作：函数（这个对象能做什么） ...
Java复习笔记.docx
07-08
Java 是一种广泛应用于软件开发的编程语言，具有平台独立、面向对象、简单易学等特点。下面是 Java 基础知识的汇总和学习笔记。 Java 概述 Java 是由 Sun Microsystems 公司开发的高级编程语言，于 1995 年首次...
Java基础 学习笔记 Markdownr版
06-27
本学习笔记主要涵盖了Java的基础知识，包括面向对象、集合、IO流、多线程、反射与动态代理以及Java 8的新特性等方面，旨在帮助初学者或有经验的开发者巩固和提升Java编程技能。 1. 面向对象（OOP）：Java的核心是...
Java基础尚硅谷宋红康学习笔记
05-29
理解封装、继承和多态是Java面向对象编程的关键概念。 3. **数组与集合**：数组用于存储固定数量的同类型元素，而集合框架（如ArrayList、LinkedList、HashSet、HashMap等）则提供了动态存储和操作对象的能力。 4....
Java思维导图+知识复习+框架+面向对象
09-15
在这个“Java思维导图+知识复习+框架+面向对象”的学习资料中，我们将深入探讨以下几个关键知识点： 1. **面向对象的基本概念**： - **对象**：是现实世界中的实体在程序中的抽象，具有属性（数据成员）和行为...
java复习笔记总结123456789
07-25
本复习笔记将深入探讨Java的核心概念和技术，帮助你巩固和提升对Java的理解。 1. **基础语法**：Java的基础语法与C++类似，包括变量声明、数据类型（如整型、浮点型、字符型、布尔型以及引用类型）、运算符（算术、...
JVM原理（十一）：JVM虚拟机六种必需对类进行初始化的情况
zuodingquan666的博客
07-03 533
Java虚拟机把描述类的数据从Class文件加载到内存，并对数据进行校验、转换解析和初始化，最终形成可以被虚拟机直接使用的Java类型，这个过程被称作虚拟机的类加载机制。Java天生可以动态扩展的语言特性就是依赖运行期间动态加载和动态链接这个特点实现的。
已解决 javax.xml.transform.TransformerFactoryConfigurationError 异常的正确解决方法，亲测有效！！！
小明的Java问道之路
07-08 629
已解决 javax.xml.transform.TransformerFactoryConfigurationError 异常的正确解决方法，亲测有效！！！
springboot中抽离日志
最新发布
qq_24223159的博客
07-08 185
【代码】springboot中抽离日志。
如何在淘客返利系统中实现高效的搜索与推荐算法
微赚淘客开发者博客
07-08 415
本文介绍了如何在淘客返利系统中实现高效的搜索与推荐算法，涵盖了倒排索引技术、搜索结果排序优化以及协同过滤、基于内容的推荐算法的实现方法和示例。通过合理选择和优化算法，可以显著提升系统的搜索效率和推荐精度，从而增强用户体验和平台的竞争力。微赚淘客系统3.0小编出品，必属精品，转载请注明出处！
ShardingSphere
Casual_Lei的博客
07-04 659
ShardingSphere 通过提供数据分片、分布式事务、数据加密和读写分离等功能，帮助开发者轻松构建高性能、高可用的分布式数据库系统。其灵活的架构设计和丰富的功能模块，使其成为现代分布式数据库中间件的优秀选择。
maven配置使用nexus仓库
ApexPredator的博客
07-03 233
maven配置使用nexus仓库
图片压缩代码和实际操作页面
英雄汉孑的博客
07-05 922
轻盈视界，高清依旧 —— 智能图片压缩，大容量，小体积，精彩不打折
JavaSE阶段面试题（一）
tq02的博客
07-03 610
本章节主要讲述SE阶段的常见面试题
返回值处理器器【Spring源码学习】
weixin_44794897的博客
07-05 265
定义返回值类型处理器的组合；测试使用的controller测试方法。
尚硅谷JAVA基础笔记吐血整理
02-03
尚硅谷java教程全程跟听，手动整理，从面向对象开始按章节按课时整理，适合对照视频作为笔试使用/java知识脉络梳理/八股理解背诵

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值