Java基础_11方法的重载_super关键字_static关键字_final关键字_抽象类

于 2024-04-09 09:17:05 发布
阅读量661 收藏 23
点赞数 22
分类专栏： java基础 文章标签： java python 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44682264/article/details/137535956
版权
本文详细介绍了Java中的方法重载、super关键字的使用、static关键字的特性（静态变量、方法和代码块）、抽象类的概念及其应用，以及final关键字在成员变量、方法和类上的作用。
摘要由CSDN通过智能技术生成

今天的内容

1.重载【overload】

2.super关键字

3.static 关键字

4.抽象类

5.final关键字

1.重载【overload】

在Java中，同一个类中有很多方法，方法的名字是可以一样的，但是参数列表不一样。那么这些方法就是方法的重载

package com.qf.b_overload;

public class Person {
	public void test () {
		System.out.println("嘻嘻 test");
	}
	public void test (int a) {
		System.out.println(a);
	}
	//方法重载和修饰符无关
	void test (String name) {
		System.out.println(name);
	} 
	//方法的重载和返回值无关的
	public int test (int a, int b) {
		return a + b;
	}
}


总结:
1.方法的重载必须写在同一个类中
2.方法的名字一定是一样的
3.方法的参数一定不一样
4.方法的返回值和修饰符可以一样也可以不一样
5.无参构造和有参构造也是方法的重载

面试题:

方法的重写和重载的区别

2.super关键字【鸡肋】

食之无味弃之可惜

this：

​ 代表是当前对象

​ 在当前类中书写 一个类

​ 1.可以调用属性和方法

​ 2.可以调用构造方法

super:

​ 代表父类的对象

​ 必须在子类中写，代表父类的对象

​ 1.可以调用父类的属性和方法（用）

​ 2.可以调用父类的构造方法

package com.qf.c_super;

class Father {
	String name;
	int age;
	public Father () {
		System.out.println("嘻嘻父类的无参构造方案");
	}
	public Father (String name, int age) {
		System.out.println("嘻嘻父类的有参构造方案");
	}
	public void eat () {
		System.out.println("嘻嘻要吃窝窝头了啊");
	}
}
class Son extends Father {
	
	public Son () {
		//调用父类的有参的构造方法  默认就是   不写也会调用父类的无参的构造方法
		super("哈哈", 12);
	}
	public void test () {
		//super调用属性和方法
		super.name = "狗蛋";
		super.age = 12;
		super.eat();
	}
	@Override
	public void eat() {
		System.out.println("哈哈要吃山珍海味了啊");
	}
}
public class Demo1 {
	public static void main(String[] args) {
		Son son = new Son();
		son.test();
		son.eat();
	}
}

3.static 关键字

静态的意思

static 修饰的东西和对象无关的

3.1生活中静态的东西

公共厕所

饮水机

不属于某一个对象，但是对象可以用的

即使你不实例化对象，也能用

3.2Java中静态的

1.修饰变量 静态变量

2.修饰方法 静态方法

3.修饰代码块 静态代码块

3.2.1使用static修饰变量 叫 静态变量

语法格式:

权限修饰符 static 数据类型 变量名字;

在main主函数中调用静态变量的时候

类.静态属性

package com.qf.d_static;

class Person{
	String name;
	int age;
	static String country;//国家变量
}
public class Demo1 {
	public static void main(String[] args) {
		Person.country  = "PRC";
		System.out.println(Person.country);
		Person person = new Person();
		//The static field Person.country should be accessed in a static way
		System.out.println(person.country);
		person.country = "中华人民共和国";
		System.out.println(person.country);//中华人民共和国
		System.out.println(Person.country);//中华人民共和国
		
		Person person2 = new Person();
		System.out.println(person2.country);
		//注意：以后碰到静态的变量的时候，一定要用类名.静态属性即可
	}
}

在这里插入图片描述

总结:

​ 1.使用static修饰的变量，叫静态变量。当还没有对象的时候，只要加载类，就会在静态区域开辟

空间存储咱们的静态变量。

3.2.2使用static修饰方法叫静态方法

语法格式:

public static void 方法的名字() {
    
}

面试题:静态方法中能不能使用非静态的成员变量和调用非静态的成员方法
不能。 为啥？静态方法早于对象的创建。this代表当前对象

package com.qf.d_static;

class Dog {
	static String name;
	public void eat () {
		this.name = "狗蛋";
		System.out.println("吃饭");
	}
	//面试题:静态方法中能不能使用非静态的成员变量和调用非静态的成员方法
	//不能。 为啥？静态方法早于对象的创建。this代表当前对象
	public static void sleep() {
		//this.name = "嘻嘻";
		Dog.name = "休息";
		//eat();
		System.out.println("睡觉。。。");
	}
}
public class Demo2 {
	public static void main(String[] args) {
		//类.静态方法 
		Dog.sleep();
	}
	
	
}
3.2.3使用static修饰的代码块叫静态代码块

代码块:

{
	语句体
}

静态代码块:

static {
	语句体
}

在类中写了静态代码块，只要这个类被加载，静态代码块一定执行，早于对象创建。

package com.qf.d_static;


class Cat {
	public Cat () {
		System.out.println("嘻嘻 我是无参构造方法");
	}
	{
		System.out.println("代码块也要执行的哦");
	}
	//static修饰的代码块，只要类被加载就一定执行
	static {
		System.out.println("这个是静态代码块");
	}
	
	
}
public class Demo4 {
	public static void main(String[] args) throws ClassNotFoundException {
		//写下面这段代码的意思是为了让Cat这类加载jvm
		//Class.forName("com.qf.d_static.Cat");
		Cat cat = new Cat();
	}
}

执行顺序: 静态代码块-》代码块-》构造方法

总结:

1.静态属性
		类名.属性  赋值和取值即可
2.静态方法
		类名.方法  直接调用
3.静态代码块
		只要类被加载，然后静态代码一定执行的

4.抽象类

在面向对象，所有对象都是可以通过类来描述（创建）

反过来说，并不是所有的类可以创建对象的。如果一个类中没有

足够的信息描述一个对象的时候，那么这个类就是抽象类

4.1抽象类的声明

在Java中使用abstract修饰的类叫抽象类

语法格式:

abstract class 类{
	属性
	方法
	抽象方法
}

入门案例

package com.qf.e_abstract;

abstract class Person {
	public void test () {
		System.out.println("你是普通的方法");
	}
	//抽象方法的
	//如果一个类中没有

//足够的信息描述一个对象的时候，那么这个类就是抽象类
	public abstract void sleep();
	
	
}
class Man extends Person {

	@Override
	public void sleep() {
		// TODO Auto-generated method stub
		System.out.println("睡吧");
	}
	
}
public class Demo1 {
	public static void main(String[] args) {
		Man man = new Man();
		man.test();
		man.sleep();
	}
}
4.2抽象类的细节

1.如果一个类中有抽象的方法，那么这个类一定是抽象类。换句话说:抽象方法必须定义在抽象类

2.抽象的方法一定是没有方法体的方法，并且使用abstract修饰的

3.抽象类不能被实例化

4.由于抽象类无法被实例化，咱们只能新建一个类去继承此抽象类，然后才能使用抽象类中的方法

5.一定要重写抽象类中的抽象方法。普通方法可以重写也可以不重写

6.一个抽象类可以去继承另外一个抽象类吗？ 可以

但是在继承的时候在非抽象的类中一定要重写抽象方法的。

7.抽象类能不能继承一个非抽象的类? 可以的

package com.qf.e_abstract;

class Animal {
	public void drink () {
		System.out.println("喝水");
	}
}
abstract class Monkey extends Animal{
	public abstract void play();
}
abstract class People extends Monkey{
	//没有方法体，就是没有那个大括号的！！！
	public abstract void eat();
	
	//普通方法
	public void  sleep () {
		System.out.println("人睡觉睡4个小时");
	}
}
class Child extends People {

	@Override
	public void eat() {
		System.out.println("小孩吃糖");
	}
	@Override
	public void sleep() {
		System.out.println("小孩睡觉9个小时");
	}
	//
	@Override
	public void play() {
		// TODO Auto-generated method stub
		System.out.println("玩玩具");
	}
	
}
public class Demo2 {
	public static void main(String[] args) {
		//不能被实例化 真愁人 那咋办？
		//People people = new People();
	}
}
4.3案例

抽象类:

​ Animal ：

​ eat()；抽象的方法

普通类:

​ Dog

​ Cat

package com.qf.e_abstract;

abstract class Pet {//宠物类  抽象的类
	public abstract void eat();
}
class Dog extends Pet{
	@Override
	public void eat() {
		System.out.println("狗吃大骨头");
	}
}
class Cat extends Pet {
	@Override
	public void eat() {
		System.out.println("猫吃鱼");
	}
}
public class Demo3 {
	public static void main(String[] args) {
		Dog dog = new Dog();
		dog.eat();
		Cat cat = new Cat();
		cat.eat();
	}
}
5.final关键字

final: 字面意思 最终的最后的

用法:

1.final可以修饰成员变量
	使用final修饰的成员变量，一定要赋值。一旦赋值成功，无法修改。
2.final可以修饰局部变量
	可以先不赋值，然后使用的时候再赋值。一旦赋值成功 无法修改。
3.final可以修饰成员方法
	不能被重写
4.final可以修饰一个对象的引用
	修饰以后无法修改
5.final可以修饰一个类
	修饰的类无法被继承

package com.qf.f_final;

final class Person {
	final String name = "狗蛋";//name 最终的值是狗蛋
	int age;
	
	public void test () {
		final int i;//局部变量： 用的时候个要赋值
		i = 20;
		//i = 30; 局部变量不能再被赋值了
		System.out.println(i);
	}
	final public  void eat () {
		System.out.println("人类再吃");
	}
}

//class Man extends Person{
//	//final 修饰的方法无法被重写
	@Override
	public void eat() {
		
	}
//}
public class Demo1 {
	public static void main(String[] args) {
		final Person person1 = new Person();
		//person.name = "张三";
		//person.test();
		System.out.println(person1);//com.qf.f_final.Person@15db9742
		Person person2 = new Person();
		System.out.println(person2);//com.qf.f_final.Person@6d06d69c
//		person1 = person2;//person2赋值给了person1
//		System.out.println(person1);//com.qf.f_final.Person@6d06d69c
		
		
	}
}


package com.qf.g_zongjie;

abstract class Moneky {
	public abstract void drink();
}
class Person extends Moneky{
	private String name;
	private int age;
	public final char sex = '男';
	public static double weight;
	public Person () {
		
	}
	public Person (String name) {
		this.name = name;
	}
	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 final void eat () {
		System.out.println("吃饭");
	}
	public static void sleep () {
		System.out.println("静态方法");
	}
	@Override
	public void drink() {
		// TODO Auto-generated method stub
		System.out.println("喝酒");
	}
	
}
class Man extends Person{
//	public Man () {
//		super("狗蛋");
//	}
	@Override
	public void drink() {
		System.out.println("喝娃哈哈");
	}
}
public class Demo1 {
	public static void main(String[] args) {
		Man man = new  Man();
		System.out.println(man.sex);
		man.setName("狗蛋");
		System.out.println(man.getName());
		man.drink();
		Man.weight = 78.9;
		Man.sleep();
	}
}

列一个纲要:

1.
2.
3.
4.

tic void sleep () {
System.out.println(“静态方法”);
}
@Override
public void drink() {
// TODO Auto-generated method stub
System.out.println(“喝酒”);
}

}
class Man extends Person{
// public Man () {
// super(“狗蛋”);
// }
@Override
public void drink() {
System.out.println(“喝娃哈哈”);
}
}
public class Demo1 {
public static void main(String[] args) {
Man man = new Man();
System.out.println(man.sex);
man.setName(“狗蛋”);
System.out.println(man.getName());
man.drink();
Man.weight = 78.9;
Man.sleep();
}
}


列一个纲要:
码叔义
关注
专栏目录
Java基础_Java编程思想_面向对象之抽象类的特点
9.冄2.7.號的博客
03-12 121
抽象类的特点 抽象类的特点 修饰符： 修饰符 abstract class 类名 {} 修饰符 abstract 返回类型 方法名 {} 抽象类不能被实例化，只能创建子类对象 抽象类子类的两个选择 重写父类所有的抽象方法 定义成抽象类 抽象类成员的特点 成员变量 可以有普通的成员变量，也可以有成员常量（final） 成员方法 可以有普通方法，也可以有抽象方法 抽象类不一定有抽象方法，有抽象方法的类一定是抽象类（或接口） 构造方法 像普通类一样有构造方法，且可以重载 代码演示 //父类, 动物类(抽
Java学习总结之this关键字、继承、多态、super关键字、final关键字
weixin_45068278的博客
09-23 212
this关键字 this是一个关键字，全部小写 this是什么？ 一个对象一个this，this是一个引用。 作用：this保存当前对象的内存地址，指向自身，所以严格意义上来说，this代表的就是“当前对象”，this只能用在实例方法中。this存储在堆内存中对象的内部。 “this.”大部分情况下是可以省略的，但是用来区分局部变量和实例变量时，不能省略。 通过当前的构造方法去调用另一个本类的构造方法，可以使用以下的语法格式：this（实际参数列表） this（）语法的作用：代码复用 继承（extend
java基础：super和覆盖方法、重载方法(0921.2016)
sxb956347789的博客
09-21 846
super 覆盖 重载
java重写和重载 关键字_Java 重写 & 重载 & super 关键字
weixin_26834815的博客
02-13 207
重写(Override)重写是子类对父类的允许访问的方法的实现过程进行重新编写, 返回值和形参都不能改变。即外壳不变，核心重写！重写的好处在于子类可以根据需要，定义特定于自己的行为。 也就是说子类能够根据需要实现父类的方法。重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。例如： 父类的一个方法申明了一个检查异常 IOException，但是在重写这个方法的时候不能抛出 Except...
java重写和重载 关键字_java重载和重写(示例代码)
weixin_42303078的博客
02-13 402
重载(Overloading)(1) 方法重载是让类以统一的方式处理不同类型数据的一种手段。多个同名函数同时存在，具有不同的参数个数/类型。重载Overloading是一个类中多态性的一种表现。(2)Java的方法重载，就是在类中可以创建多个方法，它们具有相同的名字，但具有不同的参数和不同的定义。调用方法时通过传递给它们的不同参数个数和参数类型来决定具体使用哪个方法, 这就是多态性。(3) 重载...
构造方法、重载与this关键字
snow_adfe的博客
04-25 228
构造方法与this关键字 一、构造方法     构造方法能够在创建对象时调用。在AVA中，所有的类都包含一个默认构造方法，该构造放方法，参数为空。当使用者显示声明一个构造方法时，会覆盖掉默认的构造方法。作为构造方法还能够实现数据的初始化。 1.1 构造方法的分类 构造器： 1.和类名相同 2.没有返回值 作用： 1.new 本质在调用构造方法 2.初始化对象的值 注意点： 1.定义有参构造之后，如果想使用无参构造，显示的定义一个无参的构造 默认构造方法 指的是JAVA自动生成的构造方法。 pub
Java重载及关键字------this关键字/super关键字/final关键字
Muzili_L的博客
05-01 562
1 重载要求 要求 1. 重载是要求在同一个类内，或者接口interface内 2. 重载要求方法名必须一致！！！ 3. 重载要求方法的参数必须不一致！！！ 4. 重载对于方法的返回值没有任何的约束！！！ 2重载能解决的问题 1.简化代码结构，在同一个类内同名方法功能一致，但是参数满足多样化 2.简化程序员的开发压力 3.能够做到统一化处理方式【后面项目中案例给大家安排】 ...
【3-4】《Java面向对象高级知识》——继承、重写和重载、final关键字、抽象类、接口、多态、Object类、内部类、包装类、可变参数、递归
程序媛乐园
09-27 939
文章目录一、继承格式二、子类实例化内存分析三、super详解四、重写1、重写的概念2、重写和重载的区别五、final关键字六、抽象类1、抽象类的概念2、抽象类常见问题3、抽象类和普通类的区别七、接口1、面向接口编程思想2、接口的编写3、接口和抽象类的区别八、多态1、多态的体现2、instanceof九、Object类概述1、toString2、equals十、内部类概述1、成员内部类（了解）2、局部内部类3、匿名内部类4、静态内部类 一、继承格式 非常重要的部分！！！ 格式：先描述父类，再描述子类，子类通
CoreJava_面试题
04-28
抽象类中可以有静态的main方法，用于程序的入口点。 19. clone()方法中通常有一行是super.clone()，用于调用父类的clone方法。 20. 面向对象的特征包括封装、继承和多态。 21. Java中实现多态的机制是通过方法...
JAVA继承_接口_抽象类等练习.doc
04-20
**概念:** Java中定义常量时通常使用`final`关键字，同时还需要加上`static`关键字来表示该常量属于类而非类的实例。 **选择题示例:** 第3题中，正确答案是A选项：“static final int i = 100;”。这是因为在定义...
java重写和重载 关键字_Java重写和重载的区别
weixin_35749786的博客
02-17 353
一、重写(Override)重写是子类对父类的允许访问的方法的实现过程进行重新编写, 返回值和形参都不能改变。即外壳不变，核心重写！二、重载(Overload)重载(overloading) 是在一个类里面，方法名字相同，而参数不同。返回类型可以相同也可以不同。每个重载的方法(或者构造函数)都必须有一个独一无二的参数类型列表。三、重写与重载的区别四、总结在 Java 中重载是由静态类型确定的，在类...
方法重写，方法重载，static、this、super、final关键字。
sky274548769的博客
06-01 377
方法的重写： 当我们两个类之间存在继承关系，子类觉得父类的某个方法不好用，可以通过重写来实现调用方法的时候自己控制，条件是方法名、参数、返回值必须一模一样，方法体不一样。 方法的重载： 同一个类当中，方法名相同，返回值相同，参数不同（类型，个数，顺序），就叫方法的重载 public void gongji(int num1) { System.out.pri...
C#运算符重载----关键字operator
天富儿的博客
08-06 1657
C#运算符重载----operator运算符重载的实现可重载和不可重载运算符实例原文链接 您可以重定义或重载**C#**中内置的运算符。因此，程序员也可以使用用户自定义类型的运算符。重载运算符是具有特殊名称的函数，是通过关键字operator后跟运算符的符号来定义的。与其他函数一样，重载运算符有返回类型和参数列表。 例如，请看下面的函数： public static Box operator+ (Box b, Box c) { Box box = new Box(); box.length =
C++ operator关键字（重载操作符）
热门推荐
CodingStart
05-29 6万+
重载运算符 operator是C++的关键字，它和运算符一起使用，表示一个运算符函数，理解时应将operator=整体上视为一个函数名。
《java入门第一季》之面向对象面试题
weixin_30252155的博客
05-05 146
1：方法重写和方法重载的区别?方法重载能改变返回值类型吗? 方法重写： 在子类中，出现和父类中一模一样的方法声明的现象。 方法重载： 同一个类中，出现的方法名相同，参数列表不同的现象。 方法重载能改变返回值类型，因为它和返回值类型无关。 Override：方法重写 Overload：方法重载 2：this关键字和super关键字分别代表什么?以及他们各自的使用场景和作用...
c++ operator 重载
woxincd的专栏
01-29 984
operator是C++的关键字，它和运算符一起使用，表示一个运算符函数，理解时应将operator=整体上视为一个函数名。     这是C++扩展运算符功能的方法，虽然样子古怪，但也可以理解：一方面要使运算符的使用方法与其原来一致，另一方面扩展其功能只能通过函数的方式（c++中，“功能”都是由函数实现的)。 一、为什么使用操作符重载？ 对于系统的所有操作符，一般情况下，只支持基本数据类
(this 和 super 重载和重写)的区别_11
猫腻的博客
05-27 103
标题 this 和 super 的区别 1.this代表本来对象的引用,super代表父类对象的引用 2.this用于区分局部变量和成员变量 3.super用于区分本类变量和父类的变量 4.this.成员变量 / this.成员方法 / this.(参数)代表调用本类中的内容 5.super.成员变量 / super.成员方法 / super(参数) 代表调用父类中的内容 重写与重载的区别 1.重载：是指同一个类中的多个方法具有相同的名字,但这些方法具有不同的参数列表,即参数的数量或参数类型不能完全相同
this、super关键字/重载与重写的一些区别
weixin_42291074的博客
12-09 196
this、super关键字/重载与重写的一些区别补充与拓展（this、super关键字）(重载与重写)1 、 this关键字2 、 super关键字3 、 this和super的区别4 、 重载与重写的区别重载：重写： 补充与拓展（this、super关键字）(重载与重写) 1 、 this关键字 ​ this关键字是Java中常用的关键字，它表示当前类的当前对象本身，明确的说明this代表当前对象的一个引用。this只能出现在类的构造方法或者方法中，获得当前类的对象引用。引用即对象的别名，通过引用可以访问
Java关键字与保留字详解
1. `abstract`: 用于声明抽象类或抽象方法，表示类或方法不包含完整实现。 2. `assert`: 用于进行断言，帮助调试代码，确保某个条件始终为真。 3. `boolean`: 表示布尔类型，有`true`和`false`两个值。 4. `break`: ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值