java面向对象以及三大特性的思想以及应用详解

最新推荐文章于 2023-06-15 13:00:00 发布

lisboy

最新推荐文章于 2023-06-15 13:00:00 发布

阅读量382

点赞数

分类专栏：笔记文章标签： java 多态封装类

本文链接：https://blog.csdn.net/MemoryLoss78/article/details/104982728

版权

笔记专栏收录该内容

9 篇文章 0 订阅

订阅专栏

对象+封装+继承+多态

前言

java是一门面向对象的语言，以class为基础单位，其中封装，继承以及多态是它的一个三大特性，那我们如何从思想上来理解它的含义呢？到底什么叫对象，什么叫封装，什么叫继承，什么又叫多态呢？又我们如何去运用他们呢？下面我来说说我的理解方法，请跟着我的思路走。

1.对象

java为什么被称作面向对象的一门语言呢？其实我们在写代码，主要是为了模拟现实世界解决现实世界中的问题，而程序就是用计算机语言编写的指令集合，在程序员眼中，程序里的世界就是由一个一个对象来组成的，对象就是一切客观存在的事物，所谓客观存在就是指他真真实实存在于世界中的一个事物，主观就是指我们对客观的一个反映，我们想他是什么他就是什么，但是我们却不能说通过我们的意念而转移他，因为他真实存在。

(1)属性以及方法

每一个对象都有属于自己的特征和行为，在我们程序中的叫法可以称为属性以及方法，什么意思呢？比如一个人，我们将其作为一个对象，那么他的发色，他的身高，就是他的属性，他能跑，能吃能睡这样的行为就是方法，也就是说他拥有的什么叫做属性，能做什么叫做其方法。

(2)类与类的对象

我们说java是以类为基础单位的，那么类是指什么？类其实就是一个模板的概念，比如说犬类，犬就是一个模板，将其称为Dog.class，那属于真实存在的犬就是他的一个对象比如一只二哈，那么如何定义这个类呢，那我们就要说到类的抽取了，类的抽取是取其对象共性的属性以及方法完成一个类的创建，比如说犬的属性有很多种，我们抽取共同的属性（毛色，年龄，品种）和他们共同的方法（吃，睡，跑），组成一个犬类，我们来看代码。

package com.demo.controller;

public class Dog {
//三种为类的共性，是这个类的属性
	String breed;//品种
	int age;//年龄
	String sex;//性别
	
	
	//这两种叫类的方法，一起拥有的共性和方法组成了一个类
	public void eat() {//吃
		
	}
	
public void run() {//跑
		
	}
}

2.封装

首先我们要明白什么叫封装，从字面上意思代表这封起来装起来，那为什么要封起来呢？那肯定是因为不想给别人看别人乱动嘛，隐藏其内部实现的细节，所以封装就是给外部控制和修改的权限，那么我们就得提到private修饰符了

(1)修饰符

java中有四种修饰符，他的修饰范围为：public > protected > Default > private。
private:仅仅在同一类内可见。只有创建者和本类中其他的方法可以使用使用对象：变量、方法。注意：不能修饰类（外部类）。
Default：默认的修饰符，我们创建属性时如果不给他一个修饰符如 int a；那么系统自动会用default来进行修饰，一般不显示，他的范围为这个包里的所有可见。
protected:这个修饰符是本包以及其他包都可见，但是有前提，其他包中的类必须继承这个包里的类。//什么叫继承下面再说
public：修饰范围最广，上面三个的范围全都可以应用，还特别可以应用与其他的范围，就是说对任何人可用。

(2)私有制

我们将其封装就是将其变成一个私有的东西，不给其他的人调用以及修改，那么我们如何与外面沟通呢，就会用到set和get方法了，set方法就是给别人通过这个方法将参数存入我们的属性中，那么get就是给他人读取，因为其set是要存入数据的，所以会给他设置一个形参，只能接收这个类型的数据，看代码。

package com.demo.entity;

public class Client {
    private Integer id;

    private Integer number;

    private String name;

    private String mail;

    private String address;

    /**
     * @return id
     */
    public Integer getId() {
        return id;
    }
    /**
     * @param id
     */
    public void setId(Integer id) {
        this.id = id;
    }

    /**
     * @return number
     */
    public Integer getNumber() {
        return number;
    }

    /**
     * @param number
     */
    public void setNumber(Integer number) {
        this.number = number;
    }

    /**
     * @return name
     */
    public String getName() {
        return name;
    }

    /**
     * @param name
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * @return mail
     */
    public String getMail() {
        return mail;
    }

    /**
     * @param mail
     */
    public void setMail(String mail) {
        this.mail = mail;
    }

    /**
     * @return address
     */
    public String getAddress() {
        return address;
    }

    /**
     * @param address
     */
    public void setAddress(String address) {
        this.address = address;
    }
}

(3)this关键字

并不是说封装一定要用this，但是this却能给我们带来方便
this是一个当前对象的引用，他指向的是本类中的实例属性或者实例方法
this.属性名就是用来区分实例属性，或者说实例变量（同一个意思）和局部变量（同名状况）

public class Client {
private Integer id;
   public void setId(Integer id) {
        this.id = id;//this指向实例变量
    }
}

this.方法名就是引用这个类中的方法，不过一般我们写不写意义不大因为写不写this. 都可以调用

this()就是有参构造调用本类中的无参构造函数
在程序中产生二义性之处，应使用this来指明当前对象;普通方法中，this总是指向调用该方法的对象。构造方法中，this总是指向正要初始化的对象。
使用this关键字调用重载的构造方法，避免相同的初始化代码。但只能在构造方法中用，并且必须位于构造方法的第一句且this不能用于static方法中。

3.继承

继承在现实生活中有很经典的例子，继承上一代人的财产，继承之间必须拥有“ is a”的这样一个关系，比如动物，犬是一种动物，所以满足了is a关系
小明是一个人，也是一种继承。我们将这种继承关系称为父类与子类，那么如何定义父类呢，就是抽取子类所共有的功能，拥有的相同点更多，越能精确定位，如鸟，有眼睛，有翅膀，有嘴巴，会飞，会吃；而鱼有眼睛，有嘴巴，有鱼鳍，会游，会吃。那么眼睛，嘴巴就是父类的属性，吃就是父类的方法，子类继承父类要用extends修饰，子类自动拥有父类的属性和方法，从而提高了代码的复用性和可扩展性下面看代码。

package com.demo.controller;

public class Animal {
	String mouth;//嘴
	String eye;//眼睛
	public void eat() {//吃
		
	}
	
}
class Bird extends Animal {

	String wing;//翅膀
	
	public void fly() {//飞
		
	}
	
}
class Fish extends Animal {

		String fins;//鱼鳍
		
		
		public void swim() {//游
			
		}
		

	}

(1)重写(覆盖)

当我们子类与父类方法重名时，那么意味着覆盖了父类的方法，或者说重写了父类的方法，为什么要重写？因为父类继承的方法不可变，而我们其中一个子类要拥有相同的方法却又有不同的操作时，就可以进行重写，这样其他子类依然能调用父类的方法，而需要特殊操作的子类拥有同种方法名却不同的操作，当调用子类时默认优先调用子类的方法。重写的原则是：
1.方法名称，参数列表，返回值类型与父类相同
2.访问修饰符要大于等于父类

package com.demo.controller;

public class Animal {
	String mouth;//嘴
	String eye;//眼睛
	public void eat() {//吃
		System.out.print("咽下吃");
	}
	
}
class Bird extends Animal {

	String wing;//翅膀
	
	public void fly() {//飞
		
	}
	
}
class Fish extends Animal {

		String fins;//鱼鳍
		
		public void eat() {//吃
			System.out.print("嚼着吃");
		}
		public void swim() {//游
			
		}
		

	}

当我们调用鱼的eat方法和鸟的eat方法，你一定会看到鱼的输出结果为：“嚼着吃”而鸟为：”咽下吃“，这样我们重写就能更灵活运用到我们子类与父类的方法。

(2)super关键字

如果父类和子类方法重名，也就是我们重写了，但是我们又想调用父类的方法我们怎么办，那么super就能帮我们实现。
super()：调用父类的无参构造方法，而且必须是在方法的首行。当我们差创建子类时自动会创建子类的构造方法，但要执行方法时，必须是先有super()的调用，就算自己不写，系统也会自动调用，先调用再执行自己子类的构造方法。另外super()与this()不可能同时存在。

package com.demo.controller;
public class kjh  {

	public static void main(String[] args){
		
		
		
		Fish fish=new Fish();
		fish.eat();
		
		}
	
}
 class Animal {
	String mouth;//嘴
	String eye;//眼睛
	public void eat() {//吃
		System.out.print("咽下吃");
	}
	
}

class Fish extends Animal {

		String fins;//鱼鳍
		
		public void eat() {//吃
			
			super.eat();
			
			System.out.print("嚼着吃");
		}
		public void swim() {//游
			
		}
		

	}

这样一调用我们就肯定会看到先输出了一次父类的方法，然后再看到子类的输出，那我们什么时候非常需要super呢，当我们调用系统工具时，工具的方法可能有上几百行的代码，如果让我们直接继承，我们又觉得它不满足我要实现的功能时，这时候就可以使用了，因为你要使用要不你就重写，几百行先不说看不看得懂，写也慢发了，我们先super调用父类的方法，然后再增加我们需要的功能，合二为一的时候就是我们想得到的方法。

(3)单继承与多重继承

单继承：继承父类时只有且只能有一个父类
多重继承：在继承父类时父类还有自己的父类称为多重继承，前提条件要满足单继承原则，举个例子：

 class Animal {
	String mouth;//嘴
	String eye;//眼睛
	public void eat() {//吃
	}
	
}

class Fish extends Animal {

		String fins;//鱼鳍
		
		public void swim() {//游
			
		}
		

	}
class RedFish extends Fish {

	String redfins;//红色鱼鳍
	
}

鱼的父类是动物，那么红鱼的父类就是鱼，拥有动物的属性，有鱼的属性，但是却有属于自己的红色鱼鳍这样一个属性，这种连续关系，称为多重继承。

多态

(1)多态的概念

多态是什么概念呢？多态在我们生活中也很常见，比如一瓶水，我们主观意识上将其认为成水，然后也可以认为是一种液体，也可以认为是水分子的组成，对于客观事物，主观的看法不同，并且客观事物与主观意识必须具有“is a”这样的一个关系，所以形成了多态。程序中，我们把有继承的父子类关系用父类引用指向子类对象产生多态，上文中的关系，以引用方式表现出来：Animal animal =new Fish(); 父类的引用指向了子类new Fish(),也可以说把鱼当成动物看，如果我们实行的是Fish() fish=new Fish(),是指将鱼对象当成鱼来看，鱼是一种动物。两者之间要有直接或者间接继承关系，也可以说是爷孙关系这样一个概念来理解。
注意：父类引用仅仅可以调用父类所声明的属性和方法，不可以调用子类独有的属性方法，子类的方法覆盖父类方法时，都会优先执行子类的方法。

(2)多态的应用1

那多态我们拿来干什么呢，来看代码

package com.demo.controller;
public class kjh  {

	public static void main(String[] args){

		Animal animal=new Animal();
		animal.eat();//输出结果一定为用嘴吃，但是我们想给他输出结果为用嘴吃用“ wing”飞呢？父类又不能调用子类属性
		
		Bird bird=new Bird();
		bird.eat();//所以我们需要重写一遍子类，即能调用父类属性又能有自己独有属性
		  /*同理要对其他子类进行操作也要重写，那么我们给他再增加一个类
		
		我们想通过Lovely这个类来输出“可爱的小家伙用嘴吃用翅膀飞”或者“可爱的小家伙用嘴吃用鱼鳍游呢”?
		如果像下两个方法一样难道我们要一次次的定义或者说一次次的调用吗？换其他子类时又得重新写个方法？
		所以这个时候我们可以用这个
		Animal animal2=new Bird();//父类指向子类，调用里面的方法然后传给Lovely 这样的话不管你子类多增加多少个
		    只要父类的引用指向对应的子类new Bird()或者new Fish()，都能用其中的方法，这就是多态上的引用，大大降低耦合性*/
	    Animal animal2=new Bird();
		Lovely lovely2=new Lovely();
		lovely2.love( animal2);
		}
	
}

class Animal {
	String mouth="嘴";//嘴
	String eye;//眼睛
	public void eat() {//吃
		System.out.println("用"+mouth+"吃");
	}
	
}
class Bird extends Animal {
	
	String wing="翅膀";//翅膀
	
	public void eat() {//吃
		System.out.println("用"+mouth+"吃用"+wing+"飞");
	}
	

	
}
class Fish extends Animal {

		String fins="鱼鳍";//鱼鳍
		public void eat() {//吃
			System.out.println("用"+mouth+"吃用"+fins+"游");
		}
		

}
class Lovely{
	String lovely="可爱的小家伙";
	public void love( Animal animal) {//将父类作为参数引用
		System.out.print(lovely);
		animal.eat();
	}
	
/*	//试例
	public void love( Fish fish) {
		System.out.print(lovely);
		fish.eat();
		
	}
		//试例
	public void love( Bird  bird ) {
		System.out.print(lovely);
		bird.eat();
		
	}*/
}

当我们应用时就不需要写那么多的同样的方法传不同参数来调用，耦合性自然更低，这种创建同样的方法传不同的参数这是叫重载，因为不传不同的参数你不能创建同名的方法，后面我再简单介绍下重载吧。

(3)多态的应用2

通过父类做返回值来调用不同的子类对象

package com.demo.controller;
public class kjh  {

	public static void main(String[] args){

		Lovely lovely=new Lovely();
		
		Animal animal= lovely.lovely("小鸟");//获取返回值传入love方法
		lovely.love( animal);
		
		}
	
}

class Animal {
	String mouth="嘴";//嘴
	String eye;//眼睛
	String name;
	public void eat() {//吃
		System.out.println("用"+mouth+"吃");
	}
	
}
class Bird extends Animal {
	
	String wing="翅膀";//翅膀
	
	public void eat() {//吃
		System.out.println("用"+mouth+"吃用"+wing+"飞");
	}
	

	
}
class Fish extends Animal {

		String fins="鱼鳍";//鱼鳍
		public void eat() {//吃
			System.out.println("用"+mouth+"吃用"+fins+"游");
		}
		

}
class Lovely{
	String lovely="可爱的小家伙";
	public void love( Animal animal) {//将父类作为参数引用
		System.out.print(lovely);
		animal.eat();
	}
	public Animal lovely( String a) {//通过输入name来判断是指向哪个对象
		
		Animal animal2=null;
		if("小鱼".equals(a)) {
			 animal2=new Fish();
	}
		if("小鸟".equals(a)) {
			 animal2=new Bird();
	}
        return animal2;
}
}

(4)重载

说一下重载吧，重载这个呢就是想创建多个同名的方法时，我们需要进行重载
(1)重载的成立需要的是方法名相同，形参类型，或者形参的个数、顺序不同
(2)重载不关乎返回值和返回修饰符
看例子，当我们调用时根据你输入的实参类型，实参个数来决定调用了哪个方法

package com.demo.controller;
public class kjh  {
	public static void main(String[] args) {
		
		is();
		is(1);
		is("6");
		is("6",1);
	}

public static void is(int jk) {
	
	System.out.println("int jk");
}
public static void is(String jk) {
	
	System.out.println("String jk");
}
public static void is(String jk,int ll) {
	System.out.println("String jk,int ll");
}
public  static int is() {
	System.out.println("0");
	return 0;
}

}

好了，本次的对象，以及三大特性大概就是这些了，先理解再应用，理解很重要。多态不要光想这单单这个例子，多想想以后什么情况下我们可以方便的使用它。
学习学习学习~~~

lisboy

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
java面向对象以及三大特性的思想以及应用详解

前言java是一门面向对象的语言，以class为基础单位，其中封装，继承以及多态是它的一个三大特性，那我们如何从思想上来理解它的含义呢？到底什么叫对象，什么叫封装，什么叫继承，什么又叫多态呢？下面我来说说我的理解方法，请跟着我的思路走。1.对象java为什么被称作面向对象的一门语言呢？其实我们在写代码，主要是为了模拟现实世界解决现实世界中的问题，而程序就是用计算机语言编写的指令集合，在程序员...
复制链接

扫一扫