JAVA方法，类及类的继承，重载、方法重写，super关键字

已于 2023-02-27 00:00:16 修改
阅读量377 收藏
点赞数
分类专栏： JAVA 文章标签： 类 方法 重写 重载 super
于 2020-06-26 18:40:49 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Mwyldnje2003/article/details/106963838
版权

方法的定义

方法作用

节省重复代码编写，分工合作

格式

修饰符 返回值 方法名（参数列表）{
方法体
}

public void show(){
	System.out.println{"这是一个方法"}
}

public class method {

	public static void main(String[] args) {
		// 普通数组遍历
		int[] arr1= {1,2,3,4};
		for(int i=0;i<arr1.length;i++) {
			System.out.println(arr1[i]);
		}
		System.out.println("=========================");
		int[] arr2= {10,9,8,7,6,5};
		for(int j=0;j<arr2.length;j++) {
			System.out.println(arr2[j]);
		}
		//调用自定义遍历数组的方法
		goThrougharr(arr1);
		goThrougharr(arr2);
		

	}
	//自定义方法遍历数组
	public static void goThrougharr(int[] arr) {
		for(int i=0;i<arr.length;i++) {
			System.out.println(arr[i]);
		}
		System.out.println("==============");
	}

}

方法重载

在同一个类中出现了方法名相同，参数列表不同的方法时，我们称之为方法重载
例如：

public int add(int a, int b){
	return a+b;
}
public double add(double a, double b){
	return a+b;
}

public class Overloaded {

	public static void main(String[] args) {
		// 方法重载
		int a=10;
		int b=5;
		int sum1=add(a,b);
		System.out.println(sum1);
		double c=13.5;
		double d=16.5;
		double sum2=add(c,d);
		System.out.println(sum2);
	}
	public static int add(int a, int b) {
		return a+b;
	}
	public static double add(double a, double b) {
		return a+b;
	}

}

面向对象

  • 面向对象：把事情交给对象去完成
  • 面向过程：所有的事情自己亲自去完成；

类与对象

类：模板，一类实物。静态的属性，动态的是方法。
比如：学生，姓名、年龄是属性，学习，睡觉时方法。
对象：类的具体实现，比如张三、李四都是学生类的实现

定义类

public class student { //类
	String name; //类的属性
	int age;
	public void study(String course, int time) { //类的方法
		System.out.println(name+"学习"+course+time);			
	}
	public void sleep(String place) {
		System.out.println(name+"在"+place+"睡觉");
	}
}

创建对象调用类的方法和属性

创建对象格式：对象名= new 类名（）;
调用属性：对象.属性名称=值；
调用方法：对象.方法名（参数）
输出对象：打印的是地址值

public class CallClass {

	public static void main(String[] args) {
		// 创建对象并调用属性和方法
		Student s1=new Student();
		s1.name="张三";
		s1.age=23;
		System.out.println(s1.name);
		System.out.println(s1.age);
		s1.study("English", 20);
		s1.sleep("教室");
	}
}

构造方法

作用：创建对象，给成员变量赋值，如果不填写任何构造方法，java会提供一个空参构造，如果写了任意构造方法，将不再提供空参构造。
格式：

publice 类名（）{
	//无参构造
}
public 类名（）（String name,int age）{
		//有参构造
		this.anme=name;
		this.age=age;

}

实例：

public class Student {
	String name; //类的属性
	int age;
	public Student() {
		//无参构造
	}
	public Student(String name,int age) {
		//有参构造
		this.name=name;
		this.age=age;
	}

}

调用

public class CallClass {

	public static void main(String[] args) {
		//构造方法
		//调用空参构造
		Student s1=new Student();
		//调用有参构造
		Student s2=new Student("李四",17);
		
		System.out.println(s1.name+"=========="+s1.age);
		System.out.println(s2.name+"=========="+s2.age);

	}

}

输出结果：
null0
李四17

成员变量和局部变量

定义位置：成员变量在类中方法外定义，局部变量在方法内或者方法参数或语句内定义
范围：成员变量本类中所有方法都能使用，局部变量：当前所属的区域（方法或语句）

this关键字

this关键字代表的是本类对象，调用的就是成员属性（相当于python中的self）

static关键字

作用：无需创建对象直接用类名点的方式可以调用
可以使用在方法和变量
特点：静态智能直接访问静态

public class Teacher {
	String name;  //非静态属性
	static int age; //静态的属性，不需要创建对象可以直接用类名点的方法调用
	public void eat(){ //非静态方法
		System.out.println("Teacher is eating");
		
	}
	public static void sleep() { //静态方法，不需要创建对象可以直接用类名点的方法调用
		System.out.println("Teacher is sleeping");
	}
}

调用

public class CallTeacher {

	public static void main(String[] args) {
		// static关键字
		//不创建对象的情况下直接调用非静态属性或方法
		Teacher.age=30;
		Teacher.sleep();
		System.out.println(Teacher.age);
		//非静态属性或方法，必须创建对象后才能调用
		Teacher t1=new Teacher();
		t1.name="Mr zhang";
		t1.eat();
		System.out.println(t1.name);		
	}

}

修饰符

在这里插入图片描述

封装

定义：封装，即不关注对象的属性和实现细节，仅对外公开接口，控制程序中属性的读和写的访问级别。

简单理解：提高了代码的阅读性，提高了代码可维护性，无需关注内部实现，只需要调用即可。
get/set方法

  • 封装
public class Phone {
	private String brand;  //定义私有属性
	private String price;
	
	//封装私有属性
	public void setBrand(String brand) {
		this.brand=brand;
	}
	public String getBrand() {
		return this.brand;
	}

}
  • 调用
public class CallPhone {

	public static void main(String[] args) {
		// 调用封装
		Phone p= new Phone(); 
		//因为对属性进行了私有化的封装，因此无法直接用点属性的方式直接调用
		//此时必须通过set方法设置属性值，并用get方法调用属性值
		p.setBrand("华为");  //通过set方法设置属性
		String myphone=p.getBrand();//通过get方法获得属性
		System.out.println(myphone);
		}

}

继承

  • 继承：子承父业
  • java 两个类之间通过extends关键字描述父子关系，子类便可拥有父类的公共方法和公共属性
  • 优点：提高了代码复用性，代码的维护性更高
  • 继承的格式： extend 父类名称

定义父类

public class FatherClass {
	public String name;  //子类只能继承父类公共属性或方法
	private int age;
	
	public void canInherit() {
		System.out.pringln("公共方法可以继承");
	}
	private void canotInherit() {
		System.out.println("私有方法不可以继承");
	}

}

定义子类

package com.darlyl.inherit;

public class SonClass extends FatherClass{  // extends 父类名，指明此类事继承父类的属性和方法
	//不定义属性及方法，仅继承父类的属性和方法

}

调用

public class CallSon {

	public static void main(String[] args) {
		// 调用子类，验证是否继承了父类的属性和方法
		SonClass son1=new SonClass();
		son1.name="张三 ";
		System.out.println("son1.name");
		son1.canInherit();
		
	}

类继承的特点

子类不能继承父类的private成员（属性，方法）
类与类智能单继承，多层继承
一个类如果不继承任何类，自动继承Object类，Object是所有类的祖宗；
先出事话父类在初始化子类。

super关键字

super:代表父类对象，在子类中不用new创建父类对象，直接用super代表父类对象调用父类属性或方法；

public class SonClass extends FatherClass{  // extends 父类名，指明此类事继承父类的属性和方法
	
	public void hello() {
		System.out.println();
		super.canInherit();//canInherit是父类中的方法
	}
}

super（…）:只能出现在构造方法第一行，super(…)调用父类构造
当父类构造是空参时用super（），默认情况是调用父类无惨的。所有时候不写；
当父类构造是有参时用super（参数）
定义父参空参构造

public class FatherClass {
	public String name;  //子类只能继承父类公共属性或方法
	private int age;
	public FatherClass() {
		System.out.println("这是父类的空参构造");
	}
}

子类调用父类空参

public class SonClass extends FatherClass{  // extends 父类名，指明此类事继承父类的属性和方法
	public SonClass() {
		super(); //代表调用父类的空参构造，此语句只能写在构造函数的最前面
	}

}

主函数实例化子类，

public class CallSon {

	public static void main(String[] args) {
		// 调用子类，验证是否继承了父类的属性和方法
		SonClass son1=new SonClass();
	}

}

定义父类有参构造

public class FatherClass {
	public String name;  //子类只能继承父类公共属性或方法
	private int age;
	public FatherClass(String name, int age) {
		System.out.println("这是父类的有参构造");
		this.name=name;
		this.age=age;
	}
}

子类调用父类有参构造

public class SonClass extends FatherClass{  // extends 父类名，指明此类事继承父类的属性和方法
	public SonClass() {
		super("王五",30);
	}
}

创建对象

public class CallSon {

	public static void main(String[] args) {
		// 调用子类，验证是否继承了父类的属性和方法
		SonClass son1=new SonClass();

	}

}

方法重写

重写：父类和子类出现了一模一样的方法
作用：对父类方法进行升级或者改造

定义父类方法

public class FatherClass2 {
	public String name;  //子类只能继承父类公共属性或方法
	private int age;
	
	public void canInherit() {
		System.out.println("公共方法可以继承 ");
	}
	private void canotInherit() {
		System.out.println("私有方法不可以继承");
	}
}

子类重写父类方法

public class SonClass2 extends FatherClass2{  // extends 父类名，指明此类事继承父类的属性和方法
	public void canInherit() {
		//对父类方法的升级改造，放弃父类方法，完全重写
		System.out.println("对父类继承方法的重写 ");
		//在父类方法基础上补充内容
		super.canInherit();
		System.out.println("在父类的基础上进行改造 ");
	}
	

}

创建子类对象，并调用子类方法

public class CallMain {
	public static void main(String[] args) {
		SonClass2 son2= new SonClass2();
		son2.canInherit();
	}
	

}
Mwyldnje2003
关注
专栏目录
【JAVA学习笔记】方法的重写和super关键字的使用
Z1415926535的博客
07-28 768
本文章主要讲了java中方法的重写以及super关键字的使用
java 继承 重写 重载 super关键字
weixin_30386713的博客
04-27 74
继承： 当一个子类继承一个父类的时候，子类会首先调用父类的无参构造方法。 当父类明确写出有参构造方法，且没有写无参构造方法时，继承时则需要用，super(参数。。。) 去调用父类的构造方法，调用父类的构造方法必须放在子类的构造方法的首行。 当父类没有写构造方法时，super(参数。。。)可以不写。但是依旧会调用父类的无参构造。 （当一个类中没有写构造方法时，编译器会自动加上一个无参构造方法...
java继承重写super关键字用法
m0_51186260的博客
11-09 252
父类 package 继承2; //植物 public class Botany { public double height; public int age; public Double getHeight() { return height; } public void setHeight(double height){ this.height = height; } public int getAge(){ return age; } public void setage(int age){ th
Java 单例设计模式、继承、super关键字
EIUC_Thread的博客
10-28 253
Java 单例设计模式单例设计模式1、设计模式单例设计模式继承supe关键字方法的重写（覆盖）常见的面试题静态成员的继承 单例设计模式 1、设计模式     针对特定的问题提供的固定的最优的解决方案；     在面向对象的编程语言中有23中设计模式； 单例设计模式     确保唯一性；     拿到某个类的对象，始终是同一个对象，多个对象引用的引用地
java中继承的理解，super关键字，方法的重写和重载以及注意事项理解
公子&小白的博客
01-06 527
一、类的继承理解 在java中类的继承是指：在一个现有类的基础之上去构建一个新的类，构建出来的新的类被称为子类，现有类是父类，子类会自动拥有父类所有可继承的属性和方法。继承类是现有类的更具体一些，继承类可能只拥有一部分父类的属性和方法。 如图，这就表示了继承类是父类的一种更具体形式。 二、继承类的使用 1、需要关键字extends如图继承了Employee类 一旦继承，父类的所有...
Java中的继承、方法覆盖（方法重写）、super关键字、多态
qq_38637725的博客
10-17 4579
Java继承 继承 继承是面向对象的一个重要的特性，它体现了类与类之间的一些逻辑关系，目的是为了代码复用（以减少开发成本）。当多个类之间有一些共同的属性（成员变量）和功能（成员方法）时，我们可以将他们共同的部分拿出来作为一个父类定义实现这些共性，这些类中可以不再定义这些共性而直接继承父类，得到这些属性和功能。 继承体现了客观事物中事物的层次关系。在Java程序中支持单继承（任何一个子类都只能有...
Java类继承、方法重写与重载、抽象类和抽象方法以及接口
成长ing中的w的专栏
08-12 3510
1.继承:父类和子类之间是层级结构关系，子类通过继承父类拥有父类的非private的属性和方法。提高了代码的复用性。 1）单继承：只能允许继承自一个父类； 2）子类可以扩展，即拥有自己的属性和方法； 3）子类可以重写父类的方法； 4）super关键字来实现对父类成员的访问，用来引用当前对象的父类。this关键字：指向自己的引用。 5）final 关键字声明类可以把类定义为不能继承的，即最终类；或者用于修饰方法，该方法不能被子类重写。 6）子类是不继承父类的构造器（构造方法或者构造函数）的，它只是调用（隐式或
java基础之继承，super关键字以及方法重写与方法重载
weixin_50691399的博客
10-13 508
本文主要是java的继承相关知识
Java面向对象之方法重载、重写和关键字this、super
qq15035899256的博客
01-11 1702
认识方法重载、方法重写，它们的区别。认识关键字this和super，并了解其用法。
Java——类和对象（类的继承、重载与重写、对象转型、关键字abstract）
guochaoHNU的博客
06-12 2498
Java 类的继承、对象转型 目录Java 类的继承、对象转型类的继承构造器方法方法重写对象转型向上转型应用场景向下转型 类的继承 java当中一个类可以被另一个类通过关键字extends继承，继承的类成为子类或派生类，被继承的类成为父类、基类或者超类。 eg:public class UNStudent extends Student{} 子类： UNStudent 父类: UNStudent 现在有一个父类Student public class Student { private
java方法重写和super关键字实例详解
08-31
Java 方法重写和 super 关键字实例详解 Java 方法重写是 Java 编程语言中的一种机制，允许子类提供特定于自己的实现以替代父类的方法。这种机制可以使得子类可以根据自己的需求来修改父类的方法，以满足自己的需求...
AbstractTest.java帮助理解多重继承、抽象方法重写调用、super、this关键字、构造方法、重载知识点
02-16
定义抽象类以及抽象方法，构造方法，将子类1定义为抽象类，子类2继承子类1，子类2重写抽象方法。用以帮助理解多重继承、抽象方法重写调用、super、this关键字使用、构造方法、重载这几个的知识点
Java方法重载和重写原理区别解析
08-19
方法重写和重载是两个不同的概念，方法重写是指子类中的方法和父类中继承的方法有完全相同的返回值类型、方法名、参数个数和参数类型，方法重载是指在一个类中，多个方法的方法名相同，但是参数列表不同。方法重写是...
7. 吴恩达机器学习课程-作业7-Kmeans and PCA
wujing1_1的博客
02-22 1062
fork了别人的项目，自己重新填写，我的代码如下 https://gitee.com/fakerlove/machine-learning/tree/master/code 代码原链接 文章目录7. 吴恩达机器学习课程-作业7-Kmeans and PCA7.1 k-means7.1.1 题目介绍7.1.2 算法流程7.1.3 实现k-means7.1.4 测试7.2 图像压缩与k-均值7.3 PCA7.3.1 题目介绍7.3.2 算法流程7.3.3 代码1) 示例数据集2) 实现PCA3) 脸图像数据集
算法提高分类学习刷题——1.动态规划——1.3背包模型
m0_51474171的博客
02-25 3537
（1）01背包 模型 题目介绍 有 N件物品和一个容量为 V 的背包，每件物品有各自的价值且只能被选择一次，要求在有限的背包容量下，装入的物品总价值最大。 「0-1 背包」是较为简单的动态规划问题，也是其余背包问题的基础。 动态规划是不断决策求最优解的过程，「0-1 背包」即是不断对第 i个物品的做出决策，「0-1」正好代表不选与选两种决定。 二维 （1）状态f[i][j]定义：前i个物品，背包容量j下的最优解（最大价值）： 当前的状态依赖于之前的状态，可以理解为从初始状态f[0][0] = 0开.
算法提高分类学习刷题——1.动态规划——1.2.最长上升子序列模型
m0_51474171的博客
02-21 1500
最长上升子序列模型 1.最长上升子序列 题目描述 给定一个长度为 N 的数列，求数值严格单调递增的子序列的长度最长是多少。 输入格式 第一行包含整数 N。 第二行包含 N 个整数，表示完整序列。 输出格式 输出一个整数，表示最大长度。 数据范围 1≤N≤1000， −109≤数列中的数≤109 输入样例： 7 3 1 2 1 8 5 6 输出样例： 4 解题思路 因为以i结尾的子序列，一定是由前i-1个数结尾的子序列长度加一取max 比如一个子序列a[j]a[i] ,那么当a[j]<a[i
类和对象进阶
sqjddb的博客
02-23 546
/关于访问限定符的几点说明 /类的实例化 /计算类对象的大小 /深入理解this指针 /六大默认成员函数 /const修饰成员函数 /细谈成员函数 /对象成员的初始化 /static成员 /友元 /内部类
经典的图像分类模型
最白の白菜的博客
02-22 5406
目录经典的图像分类模型AlexNetAlexNet的网络架构手写数字势识别数据读取模型编译模型训练模型评估VGGVGG的网络架构手写数字势识别数据读取模型编译模型训练模型评估GoogLeNetInception 块GoogLeNet模型B1模块B2模块B3模块B4模块B5模块手写数字识别数据读取模型编译模型训练模型评估延伸版本InceptionV2InceptionV3ResNet残差块ResNet模型手写数字势识别数据读取模型编译模型训练模型评估 经典的图像分类模型 AlexNet 学习目标 知道Ale
年薪20W的自动化测试工程师教你用Postman做接口测试
02-23 2058
The higher your test coverage, the more flexible and bug-resistant your code will be, and the less time you’ll spend debugging hot fixes in production. 测试覆盖率越高，代码就越灵活，生产中调试修补程序所花费的时间就越少。 首先，比较遗憾的一点是，Postman对并发测试并不好，但支持指定次数与间隔时间的串行测试。 官方文档链接：Postman .
Java继承与多态：方法重写与抽象类、接口应用解析
"Java继承、抽象类与接口的应用，包括方法重写（Overwrite）、super关键字、方法重载（Overload）、final修饰符、abstract修饰符、抽象类和接口的介绍，以及它们之间的对比和使用场合实例。" 在Java编程语言中，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值