JAVA 类与对象 构造方法 继承 接口详解

已于 2022-07-04 00:58:47 修改
阅读量556 收藏 1
点赞数 1
分类专栏： java基础 文章标签： java 开发语言 算法
于 2022-07-03 01:42:42 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/FakerWhite55OPEN/article/details/125580350
版权

类与对象 构造方法 继承 接口详解

什么是类和对象？
我们假设有一个类别叫动物，生活中有很多动物对象，他们都有动物的特性（属性，方法）。

public class Animal{
    //属性
    private String name;
    private int height;
    //方法
    //定义set方法，初始化属性name
    public void setName(String n){
        name = n;
    }
    //定义get方法，得到属性name
    public String getName(){
        return name;
    }
    //定义set方法，得到属性height
    public void setHeight(int h){
         height = h;
    }
    //定义get方法,得到属性 height
    public int getHeight() {
		return height;
	}
    
}

什么是父类子类，继承？
动物还可以细分为猴子、大象、狗、猫，这些细分的动物类别也是类，它们共同的都有继承动物（父类）的特性，但同时它们也有自己的特点，那么可以称它们为子类。

public class Daxiang extends Animal{

}

什么是函数的重写
这些动物都有一个会叫的特性，但每个子类，猫啊，狗啊，各自都有不同的叫法，喵喵~或者旺旺！！这就是子类对父类中函数的重写

public class Daxiang extends Animal{
	public int getHeight() {
		return height + 1;
	}
}

什么是函数的构造
每个动物都有共有的属性，比如每个动物都具有的名字，身高，那么我们在创建这个动物的时候，我们就可以通过构造来对属性进行赋值或者进行其他初始化的操作。

public class Animal{
    //属性
   ... 此处省略
    //无参构造方法
    void Animal(){
        name = "未定";
       height = 0;
    }
    //方法
    ...此处省略
    
}

什么是无参构造，有参构造？
如果我们没有定义构造函数，那么在创建对象时就会调用默认的无参构造函数，当然我们可以自己定义这个函数方法。
通过创建有参构造函数，我们可以方便的在创建对象操作时通过传递几个参数就进行属性的设置。
当我们自定义有参构造而没定义无参构造时，创建函数对象就必须传递相应的参数。当有参和无参同时出现时，就造成了函数的重载，创建对象时会自动识别传递了哪几个参数来调用相应的构造函数。

public class Animal {
	//属性
    private String name;
    private int height;
    //方法
    Animal(){
        name = "未定";
       height = 0;
    }
    Animal(String n, int h){ //这里使我们的有参构造函数
        name = n;
       height = h;
    }
    public void setName(String n){
        name = n;
    }
    public String getName(){
        return name;
    }
    public void setHeight(int h){
         height = h;
    }
    public int getHeight() {
		return height;
	}
}

什么是向上转型和向下转型？
我们创建一个子类对象，子类对象当然具有父类的特点，但是方法会有重写的情况。当把这个子类对象赋给一个父类对象，系统就会识别是否子类中有方法的重写，如果有，那么这个父类对象调用该方法时就会调用子类中重写的版本。这就是向上转型。

public class Manage {
	
	public static void main(String[] args){
        //在主函数中对类对象进行操作
		Animal dx = new Daxiang(); //向上类型转换
		String dxname = dx.getName();
        //输出我们需要的内容
        System.out.print(dxname);
    }
}

当我们强制父类对象变为子类对象，这个猴子的就又具有了自己独有的方法，而不只是动物的那些特性。这就是向下转型。

Daxiang a = (Daxiang) dx;

什么是接口？
接口像类一样也是一个可以引用的数据类型，接口中定义的变量都必须是静态固定被初始化过得，接口可以实现多继承但是类不可以。当定义了一个类继承了这个接口，这个类中就必须要重写接口中所有的抽象方法。
接口常被应用于给函数传参的时候，事先定义一个接口，在这个接口的规范下来实现需要方法，起到规范输入的作用。

//定义接口
public interface Ac extends EventListener {
	public static final int a = 0;
    public void actionPerformed(ActionEvent e);
}

//应用接口定义一个要实现的类，接口规范了类的编写
public class ButtonListener implements Ac {
	public void actionPerformed(ActionEvent e){
	 System.out.print("hello");
	};
}

//主函数中调用规范后的类对象
ButtonListener listen = new ButtonListener();
button.addActionListener(listen);

类与对象

创建一个类

类本身就是一种自己定义的数据类型

public class Animal{
    //属性
    private String name;
    private int height;
}

第一步：这里我们定义一个Animal类（动物），那么这个动物会有名字、高度，这是我们定义的每个动物都有的属性。

public class Animal{
    //属性
    private String name;
    private int height;
    //方法
    //定义set方法，初始化属性name
    public void setName(String n){
        name = n;
    }
    //定义get方法，得到属性name
    public String getName(){
        return name;
    }
    //定义set方法，得到属性height
    public void setHeight(int h){
         height = h;
    }
    //定义get方法,得到属性 height
    public int getHeight() {
		return height;
	}
    
}

第二步：这里就可以定义我们类中方法，我们创建set、get方法来对我们设置的动物属性进行赋值和获取操作

创建一个类对象

public class Manage {
	
	public static void main(String[] args){
        //在主函数中对类对象进行操作
        
        //创建一个类对象
        Animal dx = new Animal();
        //因为这个对象的属性都是私有的，所以需要调用方法进行设定或者获取
        dx.setName("大象");
        dx.setHeight(20);;
        //调用方法获取这个对象的属性
        String dxname = dx.getName();
        int height = dx.getHeight();
        //输出我们需要的内容
        System.out.print(dxname + "高" + height +"米");
        
        
    }
}

运行后得到输出：大象高20米。

这里我们用类这个数据类型创建了一个变量就是类对象。这里要用new在内存中新建出类中的内容。在new的时候我们就调用了函数中默认的无参构造方法进行初始化。

构造方法

无参构造

这里的无参构造方法可以由我们自己进行定义，默认的无参构造方法就会被替代。

public class Animal{
    //属性
   ... 此处省略
    //无参构造方法
    void Animal(){
        name = "未定";
       height = 0;
    }
    //方法
    ...此处省略
    
}

这里我们再用new新建一个对象时就可以运行我们自己的无参构造方法啦！

public class Manage {
	
	public static void main(String[] args){
        //在主函数中对类对象进行操作
        //创建一个类对象
        Animal dx = new Animal();
        String dxname = dx.getName();
        int height = dx.getHeight();
        //输出我们需要的内容
        System.out.print(dxname + "高" + height +"米");

    }
}

输出：未定高0米

重载 + 有参构造

重载就是我们定义了一个与之前定义的函数名字相同的函数，区别在于该函数的参数类型、参数多少、参数顺序总会有不同，如：

public void GG(){ };  public void GG(int a, int b){};

这两个函数可以同时出现在一个类中，当调用这些方法时，可以自动识别传的参数类型、多少、顺序来判断到底是运行哪一个

有参构造就是在无参构造基础上加入了我们自定义的几个需要传入的参数，这样可以方便在创建对象时就进行初始化操作。

无参有参可以同时存在，只需要在新建对象时识别参数就可以判断到底是运行哪一个，这就是重载的威力！

下面让我们看一下这样的代码

public class Animal {
	//属性
    private String name;
    private int height;
    //方法
    Animal(){
        name = "未定";
       height = 0;
    }
    Animal(String n, int h){ //这里使我们的有参构造函数
        name = n;
       height = h;
    }
    public void setName(String n){
        name = n;
    }
    public String getName(){
        return name;
    }
    public void setHeight(int h){
         height = h;
    }
    public int getHeight() {
		return height;
	}
}

public class Manage {
	
	public static void main(String[] args){

        //创建一个类对象
        Animal dx = new Animal("猴子", 1);//这里进行有参构造
        String dxname = dx.getName();
        int height = dx.getHeight();
        System.out.print(dxname + "高" + height +"米");
        
        
    }
}

输出为：猴子高1米

继承

继承就是父类的内的属性和方法全部都继承给子类了，语法结构如下所示

public class Daxiang extends Animal{

}

这里的Daxiang类 就是我们写出的子类，extends Animal就可以继承父类Animal中的内容

这里我们重新写一下Animal父类

public class Animal{
    private String name;
    private int height;
    
    public void setName(String n){
        name = n;
    }
    protected String getName(){
        return name;
    }
    Animal(){
        name = "未知";
    }
}

由于是继承关系，子类继承了父类的全部内容

因此主函数创建的子类对象调用时就可全部调用这些方法，private需要在方法中进行访问

public static void main(String[] args){
        //在主函数中对类对象进行操作
		Daxiang dx = new Daxiang(); //注意这里创建的是子类对象
		dx.setHeight(20);
		dx.setName("小红");
		String dxname = dx.getName();
        int height = dx.getHeight();
        //输出我们需要的内容
        System.out.print(dxname + "高" + height +"米");

    }

输出为：小红高20米

注意这里创建的是子类对象

向上类型转换

当我们定义一个父类对象，我们new一个子类对象赋给这个父类，这个时候会检测子类中是否有重写父类中的方法，将父类中的对应方法替换为子类中重写的方法，这样不同的子类向上类型转换后调用方法就会有区别。

定义一下子类

public class Daxiang extends Animal {
	public String getName(){
        return "大象";
    }
}

注意：这里重写时 访问修饰符的优先级为 public > protected > private>空。 访问修饰符只可以向上替换，不可以向下替换。

父类还是一样

public class Animal{
    private String name;
    private int height;
    
    public void setName(String n){
        name = n;
    }
    protected String getName(){
        return name;
    }
    Animal(){
        name = "未知";
    }
}

主函数

public class Manage {
	
	public static void main(String[] args){
        //在主函数中对类对象进行操作
		Animal dx = new Daxiang(); //向上类型转换

		String dxname = dx.getName();

        //输出我们需要的内容
        System.out.print(dxname);
        
        
    }
}

如果是父类中的方法，输出应该为 未知，但这时的输出是 大象，因为上面解释的向上类型转换。

向上类型转换的应用场景就是当你调用一个方法的时候，（函数）方法的参数是一个父类对象，你就可以传一个子类对象，这样，不同的对象就会执行不同的方法。

向下类型转换

就是相当于类型的强转。 （Daxiang) dx

Daxiang a = (Daxiang) dx;

这时的向下类型转换就是将向上转型的子类进行还原，还可执行子类中自己的方法。

子类中的构造过程

创建子类后，会首先调用父类中的默认构造方法，然后调用子类中的默认构造方法

如果在父类中写了一个有参构造，则无法调用父类中的默认构造方法，若创建对象会报错，有如下两种解决办法

1、该方法不常用

public class Daxiang extends Animal {

	Daxiang(){
		super("猴子",10);
	}
	protected String getName(){
        return "大象";
    }

}

在子类的默认构造中用super执行一下有参构造

2、在父类中定义默认构造，若一定要执行有参构造，则可把有参构造转换为函数方法在默认构造里使用

public class Animal{
    private String name;
    private int height;
    public void Animal(String n, int h){
    	name = n;
    	height = h;
    }
    Animal(){
        Animal("猴子", 1);
    }
    public void setName(String n){
        name = n;
    }
    private String getName(){
        return name;
    }
    
}

一般来说都要父类中一定要写默认构造函数，放置发生子类构造时无法执行父类默认构造的情况。

爱小格的达子
关注
专栏目录
Java类与对象详解PPT课件.pptx
11-23
Java类与对象详解是Java编程语言的基础知识，本节将详细介绍Java类和对象的定义、实例化、成员变量、构造方法、访问修饰符、继承等知识点。 一、Java类的定义和实例化 在Java中，类是创建对象的模板，类必须先...
接口与构造方法
Oliver6的博客
10-31 2374
1.接口概念 接口是功能的集合，同样可看做是一种数据类型，是比抽象类更为抽象的”类”。 接口只描述所应该具备的方法，并没有具体实现 2.接口的定义 接口定义时需要使用interface关键字，可以看做是一种只包含了功能声明的特殊类。 定义格式： public interface 接口名 { 抽象方法1; 抽象方法2; 抽象方法3; } 3.类实现接口 类与接口的关系为实现关系，即类实现接口。实现的...
构造方法，静态方法，抽象方法，接口中的默认方法
weixin_49187233的博客
02-20 1493
一. 构造方法： 1.创建实例的时候，其实是通过构造方法来创建的。 2.构造方法的格式是：public + 类名（参数）{方法体} 3.和普通方法相比，构造方法没有返回值，也没有void，在调用构造方法时，需要使用new关键字 4.创建实例的格式为：类名 + 引用（对象） = new 类名（参数/无参）； 5.在没有定义参数时，构造方法是默认有一个无参构造方法的public +类名 （）{方法体} 注意：（如果我们自定义了一个构造方法，那就没有编译器默认的无参构造方法了）！！！ 6.如果既要使
java基础_面向对象_DAY03
zrjuanjuan的博客
06-18 188
面向对象 面向对象&面向过程 属性+方法 = 类 ⚠️面向过程：打开冰箱，放进大象，关闭冰箱； ⚠️面向对象：手工耿造了个专门放大象的工具，找到这个工具，直接放冰箱里就好了，怎么放的？要不要开门？怎么开门的？我不管啦，手工耿.工具即可。 这里需要注意，并不是啥都要找工具或者其他帮助来解决问题，比如把可乐放进冰箱这类简单的工程，直接放进去更简单，造轮子反而很麻烦，直接自己处理放进去就叫面向过程。 ⚠️综上：如果需要多人协助，比较复杂麻烦，那就找轮子，别人造好的轮子拿过来用，这就是工具类的好处，
类的继承 接口
Xue95111的博客
08-04 2736
类的继承与接口类的继承继承的概念继承的格式继承访问命令符方法的重写继承实例接口接口的概念接口的格式 类的继承 继承的概念 继承就是子类继承父类的属性和方法，使得子类对象可以拥有使用父类的属性和方法。 子类是父类的一个更具体更细化的实体，拥有父类特征和方法也可以拥有子类自己的特征和方法。 例:父类为动物，子类为狗（狗拥有哺乳动物的一些行为和特性但是也有自己的特性和行为） 继承的一个作用是减少代码量，可以将两段代码相同的地方提取出来组成一个父类，减少代码冗余，提升后期代码维护的效率。 继承的格式 class 父
java 接口 详解
热门推荐
Cyan_RA9的博客
02-24 2万+
java 接口 内容分享，本篇博文为java 面向对象三大特性——多态篇的补充。
详解 Java继承关系下的构造方法调用
08-29
Java继承关系下的构造方法调用详解 Java继承关系下的构造方法调用是Java语言中一个非常重要的概念，它关系到类的继承和对象的实例化。在Java中，创建一个类的对象时，如果该类存在父类，则先调用父类的构造方法，...
Java面向对象编程之类的继承详解
08-28
"Java面向对象编程之类的继承详解" Java面向对象编程之类的继承是Java编程语言中最基本也是最重要的概念之一。继承是类和类之间的一种关系，通过继承，可以使子类继承父类的所有属性和方法，从而提高代码的复用性和...
Java中自动生成构造方法详解
08-30
Java中自动生成构造方法详解 Java 中的构造方法是一种特殊的方法，用于初始化对象的状态。Java 中的构造方法有两种形式，一种是无参构造方法，另外一种是带参构造方法。在 Java 中，如果一个类没有声明构造方法，...
Java 抽象类定义与方法实例详解
08-30
Java 抽象类与接口的区别抽象类和接口都是用于实现多态性，但它们之间存在显著的区别： 1. **抽象方法**：抽象类可以包含抽象方法（没有具体实现的方法），而接口中的所有方法默认都是抽象的。 2. **非抽象方法**...
java中如何编写继承和接口程序
weixin_67933746的博客
05-12 623
本文介绍了java中如何编写继承和接口程序
Java中的继承与接口
qq_40167417的博客
09-03 2950
...
JAVA中方法的声明及使用（继承、多态、封装）
sgdadg的博客
05-21 1886
目录一、写在前面二、继承2.1 继承的注意事项2.2 继承的特点2.3 继承的使用2.4 重写和重载2.4.1 重写(override)2.4.2 重载（overload）2.4.3 this，super关键字2.4.4 补充概念三、多态3.1 定义和优点3.2 多态的体现形式3.3 向上转型四、封装4.1 封装的特性4.2 封装的实现4.3 成员的访问权限 一、写在前面 今天就来总结一下JAVA中方法的声明及使用，即继承、多态、封装。其实关于三大特性对于学习JAVA的同学来说都是基本的了，毕竟只要接触J
Java继承详解
最新发布
asdssadddd的博客
08-15 1175
那么有的人会问，如果成员的访问遵循就近原则，那么如果想访问父类中同名的成员应该怎么办？这就需要super关键字。
理解Java方法的调用(声明、返回值、参数、调用、继承、子构造器、理解方法的调用、多态)
qq_43303896的博客
08-18 522
声明： [修饰符1 修饰符2...]返回值类型 方法名(形式参数列表) { 程序代码; [return 返回值]; } 有无返回值 有void修饰，无返回值 int------------------>return int 类型的值 string-------------->return String类型的值 数据类型--------&...
8、学习 Java 中的方法（方法的定义、可变参数、参数的传递问题、方法重载、方法签名）通过官方教程
m0_54189068的博客
09-01 933
【Java 基础】7、学习 Java 中的方法（方法的定义、可变参数、参数的传递问题、方法重载、方法签名）
Java---继承详解
fly的博客
06-16 5771
就是子类继承父类的和，使得子类对象可以直接具有与父类相同的属性、相同的行为。子类可以直接访问父类中的的属性和行为。
Java学习（95）Java泛型——泛型作为方法参数和方法重载
weixin_43360025的博客
01-15 2705
Java学习（95）Java泛型——泛型作为方法参数和方法重载
java 参数继承_java篇 之 继承
weixin_34611130的博客
02-15 1235
this代表正在使用类的对象(的引用)java支持重载：允许在同一个类中使用相同的方法名(重载类型只区分参数列表，包括参数 顺序，参数个数，参数数据类型，与方法返回类型无关)匹配：方法名参数列表类型调用如果参数列表不匹配，系统如果能自动隐式转换为方法中对应的数据类型，则调用该方 法，只能唯一匹配构造器：对this的调用必须是第一个语句！(用this能调用同类的其它构造器，包括自己！ (避免调用本身...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值