Java面向对象高阶笔记

最新推荐文章于 2024-07-27 13:31:57 发布
最新推荐文章于 2024-07-27 13:31:57 发布
阅读量148 收藏
点赞数
分类专栏： 笔记 文章标签： java 面向对象编程 抽象类 多态 接口
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44607024/article/details/108163771
版权

Java面向对象高阶笔记

继承
概述：

​ 继承是Java面向对象编程技术的一块基石，因为它允许创建分等级层次的类

​ 继承就是子类继承父类的特征和行为，使得子类对象（实列）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为

格式：
class  父类 {

}

class  子类  extends  父类{

}

//人类
class Person{
    private String name;
    private int age;
    
    public Person(){
        super();
    }
    
    public String getName(){
        return name;
    }
    
    public void setName(String name){
        this.name = name;
    }
    
     public int getAge(){
        return age;
    }
    
    public void setAge(int age){
        this.age = age;
    }
    
    public void say() {
        System.out.println("我是："+name+",我今年"+age+"岁了");
    }
    
}

//学生
class Student extends Person{
    
}


public class Demo{
    public static void main(String[] args){
        Student stu = new Student();
        stu.setName("王芳");
        stu.setAge(22);
        stu.say();
    }
}

//运行结果
我是：王芳，我今年22岁了
继承的限制：

​ Java中只有单继承，多重继承，没有多继承

super详解
通过super：

​ 可以访问父类的构造方法；

​ 可以访问父类的属性；

​ 可以访问父类的方法。

//人类
class Person{
    private String name;
    private int age;
    public int sex;
    
    public Person(){
        super();
    }
    
    public Person(String name, int age){
        super();
        this.name = name;
        this.age = age;
    }
    
    public String getName(){
        return name;
    }
    
    public void setName(String name){
        this.name = name;
    }
    
     public int getAge(){
        return age;
    }
    
    public void setAge(int age){
        this.age = age;
    }
    
    public void say() {
        System.out.println("我是："+name+",我今年"+age+"岁了");
    }
    
}

//学生
class Student extends Person{
    public Student(){
        super("王小二"，20);//调用父类构造方法
        super.sex = "男";//调用父类属性
        super.setName("无名氏");//调用父类方法
    }
}


public class Demo{
    public static void main(String[] args){
        Student stu = new Student();
        stu.say();
    }
}

//运行结果
我是：无名氏，我今年20岁了
重写，重载与重写的区别
重写（Override）规则：
  1. 参数列表必须完全与被重写的方法相同；
  2. 返回类型必须完全与被重写的方法的返回类型相同；
  3. 访问权限不能比父类中被重写的方法的访问权限更低。例如：如果父类的一个方法被声明为public，那么在子类中重写该方法就不能声明为protected。
  4. 父类的成员方法只能被他的子类重写。
  5. 声明为static和private的方法不能被重写，但是能够被再次声明。
//人类
class Person{
  public void say() {
        System.out.println("我是个普普通通的人");
    }  
}

//学生
class Student extends Person{
    //重写父类的方法
     public void say() {
        System.out.println("我是个普普通通的学生");
    }
}

public class Demo{
    public static void main(String[] args){
        Student stu = new Student();
        stu.say();
    }
}
//运行结果
我是个普普通通的学生
重载和重写的区别：

  1. 发生的位置

    重载：一个类中

    重写：子父类中

  2. 参数列表限制

    重载：必须不同的

    重写：必须相同的

  3. 返回值类型

    重载：与返回值类型无关

    重写：返回值类型必须一致

  4. 访问权限

    重载：与访问权限无关

    重写：子的方法权限必须不能小于父类的方法权限

  5. 异常处理

    重载：于异常无关

    重写：异常范围可以更小，但是不能抛出新的异常。

final关键字
final:

  1. 用于修饰属性、变量

    ​ 变量成为了常量，无法对其再次进行赋值

    ​ final修饰的局部变量，只能赋值一次（可以先声明后赋值）

    ​ final修饰的是成员属性，必须在声明时赋值

    ​ 全局常量（public static final）

    ​ 常量的命名规范：

    ​ 由1个或多个单词组成，单词与单词之间必须使用下划线隔开，单词中所有字母大写

    ​ 例如：SQL_INSERT

  2. 用于修饰类

    ​ final修饰的类，不可以被继承

  3. 用于修饰方法

    ​ final修饰的方法，不能被子类重写

抽象类

概念

抽象类必须使用abstract class声明

一个抽象类中可以没有抽象方法，抽象方法必须写在抽象类或者接口中。

格式：
abstract class 类名 {  //抽象类

}
抽象方法

只能声明而未实现的方法称为抽象方法（未实现指的是：没有”{}“方法体），抽象方法必须使用abstract关键字声明。

格式：
abstract class 类名 {//抽象类
	public abstract void 方法名();//抽象方法，只能声明而未实现

}
不能被实例化

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

  1. 抽象类本身是不能直接进行实例化操作的，即：不能直接使用关键字new完成。
  2. 一个抽象类必须被子类所继承，被继承的子类（如果不是抽象类）则必须重写抽象类中的全部抽象方法
public abstract class Person {//抽象类
	public abstract void say();//抽象方法，只能声明而未实现

    public void say1(){
         System.out.println("我是人类");
    }
}
public class Student extends Person {

	@Override
	public void say() {
		//必须重写父类的抽象方法，否则会报错
		System.out.println("我是学生");
	}
}
抽象类常见问题

  1. 抽象类能否使用final声明？

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

  2. 抽象类能否有构造方法呢？

    能有构造方法，而且子类对象实例化的时候的流程与普通类的继承是一样的，都是要先调用父类中的构造方法（默认是无参的），之后再调用子类自己的构造方法。

抽象类和普通类的区别
  1. 抽象类必须用public或protected修饰（如果为private修饰，那么子类则无法继承，也就无法实现其抽象方法）。默认缺省为public
  2. 抽象类不可以使用new关键字创建对象，但是在子类创建对象时，抽象父类也会被JVM实例化。
  3. 如果一个子类继承抽象类，那么必须实现其所有的抽象方法。如果有未实现的抽象方法，那么子类也必须定义为abstract类

接口

概念

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

格式：
interface 接口名称{
    全局常量;
    抽象方法;
}
面向接口编程思想

这种思想是接口的定义（规范，约束）与实现（名实分离的原则）的分离

优点
  1. 降低程序的耦合性
  2. 易于程序的扩展
  3. 有利于程序的维护
接口的实现implements

接口可以多实现

格式：
class 子类 implements 父接口1,父接口2...{

}

以上代码称为接口的实现，那么如果一个类即要实现接口，又要继承抽象类的话，则按照以下格式编写即可：

class 子类 extends 父类 implements 父接口1,父接口2...{

}
接口的继承

接口因为都是抽象部分，不存在具体实现，所有允许多继承，例如：

interface C extends A,B{
    
}

public interface Person{
    //全局常量
    public static final int a = 10;//public static final可省略 
    //int b = 10;
   //抽象方法
    public abstract void say();//public abstract可省略
    //void say1();
}

public class Student implements Person{
    @Override
    public void say(){
       System.out.println("我是学生");
    }
}

public class Demo{
    public static void main(String[] args){
        Student stu = new Student();
        stu.say();
    }
}
//运行结果
我是学生
注意

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

接口和抽象类的区别
  1. 抽象类要被子类继承，接口要被类实现。
  2. 接口只能声明抽象方法，抽象类中可以声明抽象方法，也可以声明非抽象方法。
  3. 接口里定义的变量只能是公共的静态的常量，抽象类中的变量是普通变量。
  4. 抽象类使用继承来使用无法多继承，接口使用实现来使用，可以多实现
  5. 抽象类中可以包含static方法，但是接口中不允许（静态方法不能被子类重写。，因此接口中不能声明静态变量）
  6. 接口不能有构造方法，但是抽象类可以有

多态

概念

多态：就是对象的多种表现形式，（多种体现形态）

多态的体现

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

ps：

方法的重载和重写也是多态的一种，不过是方法的多态（相同方法名发多种形态）。

​ 重写：一个类中方法的多态性体现。

​ 重载：子父类中方法的多态性体现。

多态的使用：对象的类型转换

类似于基本数据类型的转换：

  1. 向上转型：将子类实例变为父类实例

    ​ 格式：父类 父类对象 = 子类实例；

  2. 向下转型：将父类实例变为子类实例

    ​ 格式：子类 子类对象 = （子类）父类实例；

public class Person { 
	public void say(){
         System.out.println("我是人类");
    }
}
public class Student extends Person {
	public void say() {
		System.out.println("我是学生");
	}
}

public class Demo{
    //父类引用指向子类对象
    public static void main(String[] args){
        Student stu1 = new Student();//子类
        Person p = stu1;//父类
        p.say();//这个人说我是学生
        
        Student stu2 = (Student)p;//将父类实例变为子类实例
        stu2.say();
    }
}
//运行结果
我是学生
我是学生

instanceof

作用：

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

格式：

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

public interface Person { 
	void say();    
}

public class Student implements Person {
	public void say() {
		System.out.println("我是学生");
	}
}

public class Nurse implements Person {
	public void say() {
		System.out.println("我是护士");
	}
}
public class Demo{
    
    public static void main(String[] args){
        Student stu = new Student();
        say(stu);
        Nurse n = new Nurse();
        say(n);
    }
    
  	public static void say(Person p){
  		//判断某个对象是否是指定类的实例
  		if(p instanceof Student){
  			Student s = (Student)p;
  			s.say();
  		}else{
  			System.out.println("必须传入学生形态");
  		}
  	}
}
//运行结果
我是学生
必须传入学生形态

Object类

概念

Object 类是所有类的父类（基类），如果一个类没有明确的继承某一个具体的类，则将默认继承Object类。

例如：

public class Person{
} 
其实它使用时是这样的：
public class Person extends Object{
}
Object的多态

使用Object可以接收任意的引用数据类型

public class Demo{
    public static void main(String[] args){
        String s = "abc";
        say(s);
        int a = 123;
        say(a);
    }
    private static void say(Object o) {
		System.out.println(o);
	}
}
//运行结果
abc
123
toString
public String toString{}

返回对象的字符串表现形式。通常，toString方法返回一个文本表示此对象的字符串。结果应该是简洁但信息丰富的表示，便于人们阅读，建议所有子类都覆盖此方法。

Object 的toString方法返回的是对象的内存地址

equals

建议重写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。

public class Person{
	private String name;
	private String age;
    
    public Person(String name, String age) {
		super();
		this.name = name;
		this.age = age;
	}
	public String getName() {
		return name;
    }
	public void setName(String name) {
		this.name = name;
	}
	public String getAge() {
		return age;
	}
	public void setAge(String age) {
		this.age = age;
	}
    
    //创建快捷键Shift+Alt+S  点击创建toString方法
	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + "]";
	}
	//创建快捷键Shift+Alt+S  点击创建equals方法
    @Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Person other = (Person) obj;
		if (age == null) {
			if (other.age != null)
				return false;
		} else if (!age.equals(other.age))
			return false;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		return true;
	}
    /*//手写的equals方法
    public boolean equals(Object o){
        if(this == o){//地址相同为true
            return true;
        }
        if(o == null){//为空则为false
            return false;
        }
        if(o instanceof Person){//如果类型相同
            Person p = (Person) o;
            if(this.name.equals(p.name) && this.age == p.age){//如果内容相同
                //相同
                return true;
            }
        }else{
            return false;
        }
        return false;
    }*/

    
}

public class Demo{
	public static void main(String[] args){
		Person p1 = new Person("张三",23);
		Person p2 = new Person("张三",23);
		System.out.println(p1.equals(p2));
		System.out.println(p1.equals(null));
	}
}
//运行结果
true
false
死磕Java的小白
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
基础第一阶段day09——方法重写习题、继承习题
qq_43775310的博客
10-13 1371
第一题 横线处该填写什么 public class Fu { public int method(int a,int b){ return a>b?a:b; } } public class Zi extends Fu { 填写什么? } A: public static int method(int a,int b){ retur...
java面向对象程序设计案例教程，java高级开发面试经验
EDGNB123的博客
05-24 111
前言 本份文档内容涵盖: Java、MyBatis、ZooKeeper、Dubbo、Elasticsearch、Memcached、Redis、MySQL、 Spring、Spring Boot、Spring Cloud、RabbitMQ、Kafka、Linux等技术栈，共1000多道面试题。 由于文档内容过多，所以只列举了以下目录部分，每个知识点都有更细化的内容！ kafka面试基础[17] 1.Kafka的用途有哪些？使用场景如何？ 2.Kafka中的ISR、AR又代表什么？ISR的伸缩又指什么
Java高阶笔记
TateBrwonJava的博客
03-04 910
Java语法糖 语法糖：Syntactic sugar 作用：make things easier to read or to express. 使得程序员更容易编写程序，更清晰准确表达逻辑业务，不仅仅是语法的转换，也包括一些小的改进。 for/for-each 没有分号，和C++类似for（个体：数组） 由5.0引入，语法更简介，避免越界错误，但是不可以删除替换元素，不知道当前具体索引，只...
【一看就懂的java学习】高级篇 之 抽象类
qq_38785034的博客
11-12 246
抽象类5 抽象类1 抽象类概述2 抽象类特点3 抽象类成员特点 5 抽象类 1 抽象类概述 在Java中，一个没有方法体的方法被定义为抽象方法，而类中如果有抽象方法，该类必须定义为抽象类 2 抽象类特点 抽象类和抽象方法必须使用abstract关键字修饰 public abstract class 类名{} public abstract void 方法名（）； 抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类 抽象类不能被实例化 如何实例化：参照多态的方式，通过子类对象实例化，叫抽象类多态
JavaSE 第六章 面向对象基础-中（封装）
weixin_45890113的博客
08-04 279
我要用洗衣机，只需要按一下开关和洗涤模式就可以了。有必要了解洗衣机内部的结构吗？有必要碰电动机吗？我们使用的电脑，内部有CPU、硬盘、键盘、鼠标等等，每一个部件通过某种连接方式一起工作，但是各个部件之间又是独立的现实生活中，每一个个体与个体之间是有边界的，每一个团体与团体之间是有边界的，而同一个个体、团体内部的信息是互通的，只是对外有所隐瞒。面向对象编程语言是对客观世界的模拟，客观世界里每一个事物的内部信息都是隐藏在对象内部的，外界无法直接操作和修改，只能通过指定的方式进行访问和修改。...
Java（基础+高级）笔记
qq_52108058的博客
09-13 402
在定义时，一个小数会被默认为double类型，因此在定义float类型时后面一定要加字母F（或者f）1.标识符可以由任意顺序的大小写字母、数字、下滑线和美元符组成，但是不能以数字开头。变量名和方法名的第一个单词首字母小写，从第二个单词开始每个单词首字母大写。十六进制：以0x或者0X开头，并且其后由0~9、A到F组成，如0xAF。多行注释可以嵌套单行注释，多行注释不可用嵌套多行注释。十进制： 由数字0~9组成的数字序列。3.文档注释 /** */2.多行注释 /* 代码*/二进制 ：由数字0和1组成。
第二章 面向对象高阶（1）
weixin_43273246的博客
06-28 186
学习笔记分工协作,专人干专事如果将所有的类文件都放在同一个包下,不利于管理和后期维护,所以,对于不同功能的类文件,可以放在不同的包下进行管理包 ：本质上就是文件夹创建包：多级包之间使用 " . " 进行分割 多级包的定义规范：公司的网站地址翻转(去掉www) 比如：csdn的网站址为https://www.csdn.net/ 后期我们所定义的包的结构就是：net.csdn.其他的包名包的命名规则：字母都是小写package语句必须是程序的第一条可执行的代码 package语句在一个java文件中只能有一个
Java基础学习笔记(三)_Java核心技术(高阶)
chenHARDEN的博客
12-31 756
本篇文章的学习资源来自Java学习视频教程：Java核心技术(高阶)_华东师范大学_中国大学MOOC(慕课) 本篇文章的学习笔记即是对Java核心技术课程的总结，也是对自己学习的总结 文章目录Java核心技术（高阶）：深层原理第一章 Java语法糖1、语法糖（Syntax sugar）和环境设置2、语法糖（1）foreach和枚举3、语法糖（2）不定项参数和静态导入4、语法糖（3）自动拆箱和装箱、多异常并列、数值类型和优化5、语法糖（4）接口方法6、语法糖（5）try-with-resource和Resou
android-notes:基本的Android笔记
04-04
它是一种面向对象的语言，具有良好的可移植性和丰富的类库。在Android中，Java主要负责应用程序的逻辑处理，如UI交互、数据管理、网络通信等。开发者通常会用到Android SDK提供的各种工具和API，如Intent用于启动...
scala讲解笔记 入门及进阶 PDF文档1-5
02-26
第三部分："Scala入门及进阶-part03-高级特性.pdf" 将深入探讨Scala的一些高级主题，比如高阶函数、匿名函数、偏函数和柯里化。同时，还会涉及类型系统，包括类型推断、类型别名和类型参数化。这部分内容对于提升...
一个涵盖了计算机基础、Java、Android、Kotlin等相关知识的总结性文档.zip
10-04
接下来是Java，一种广泛使用的面向对象编程语言。Java的核心特性包括封装、继承、多态和抽象，还有异常处理、垃圾回收机制、IO流、集合框架（ArrayList、LinkedList、HashMap等）以及多线程编程。Java还广泛应用于...
笔记Kotlin
02-11
Kotlin，由JetBrains公司开发，是一种现代、面向对象的、静态类型的编程语言，它在2016年被Google宣布为Android开发的首选语言，自此在移动开发领域广受欢迎。这份笔记涵盖了Kotlin的基础知识、高级特性以及在实际...
python的核心笔记pdf
03-17
6. **面向对象编程**：Python支持类和对象的概念，可以创建类、定义属性和方法，实现继承、封装和多态。 7. **模块和包**：Python的模块系统使得代码可以组织成可重用的组件，包则进一步提供了模块的分层结构。 8....
golang 接口
m0_70982551的博客
07-24 966
接口定义了一组方法，这些方法没有具体的实现。接口类型的变量可以存储任何实现了这些方法的类型的值。// 更多方法...在Go语言中，接口值是指存储了实现某个接口的具体类型值的变量。接口值由两部分组成：1.动态类型：这是接口值当前存储的实际类型。2.动态值：这是实际存储的值，该值必须实现了接口中定义的所有方法。
Swagger使用Map接受参数时，页面如何显示具体参数及说
a1058926697的博客
07-26 521
后端使用Map接受参数，要求在swagger页面上显示具体的参数名称、类型及说明。当Map接受参数数量少时，可以使用Swagger自带的注解。自定义注解 @ApiGlobalModel。编写处理注解对应的插件。
springboot之自动装配
weixin_50153914的博客
07-23 659
Spring Boot 通过一系列注解和条件配置实现了自动装配机制，使得开发者无需手动配置大量的 XML 文件或 Java 配置类。自动配置机制利用文件中的自动配置类，并结合条件注解和组件扫描，实现了灵活且强大的自动装配功能。这样，开发者可以专注于业务逻辑的实现，而无需处理繁琐的配置细节。
Java的@DateTimeFormat注解与@JsonFormat注解的使用对比
最新发布
訾博（ZiBo）的博客
07-27 597
在Spring和Jackson框架中，日期和时间格式化是一个常见需求。注解主要用于Spring的表单绑定，而注解则用于Jackson的JSON序列化和反序列化。了解这两个注解的使用场景和方法，可以帮助开发者更高效地处理日期和时间。和是处理日期和时间格式化的两个重要注解。主要用于Spring MVC的请求参数绑定，而主要用于Jackson的JSON序列化和反序列化。了解它们的使用场景和功能，可以帮助开发者更高效地处理日期和时间格式化需求。通过本文的介绍，希望读者能够更清晰地理解和。
Java代码基础算法练习-数的特性-2024.07.25
Sakurapaid的博客
07-25 368
小A喜欢两种性质都成立的数字，小B喜欢至少符合一种性质的数字，小C喜欢不符合这两种性质的 数字。给出一个数字，请输出三个人是否喜欢这个数字。如果喜欢输出1，否则输出0，用空格分隔。输入数字 num，先定义三个整型代表三个人的喜欢与否，先默认设为 0。之后判断num对于性质1、2的条件，分别用 boolen 类型标识。对于每个整型进行判断，是否改为 1 代表喜欢。性质2：大于4且不大于12;
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值