java基础之面向对象(封装,继承,多态)

   

万物皆对象,在面向对象思想里,封装,继承,多态我。我们真的理解吗?理解完,我们应该怎么用它?什么是面向对象?什么是封装,什么是继承?什么是多态?什么接口?什么是抽象?接口与抽象之间的关系?

  java面向对象的三大特征:封装,继承,多态

1、封装:java中的封装是指一个类把自己内部的实现细节进行隐藏,,只暴露对外的接口(getter和setter)方法,封装又分为属性的封装和方法的封装。封装又分为属性的封装和方法的封装,把属性定义为私有地,他们通过setter和getter方法来对属性的值进行设定和获取。

 1 public class Person{
 2 
 3 private int id;
 4 private String name;
 5 private persion;
 6 
 7 
 8 public int getId(){
 9 return id;}
10 
11 public String getName(){
12 return name;}
13 
14 public String getPerson(){
15 return person;
16 }
17 
18 public void setId(int id){
19 this.id=id; 
20 
21 }
22 public void setName(String name){
23 this.name= name;
24 }
25 public void setPerson(Person person){
26 this.person= person;
27 }
28 
29 }

在Person类中,定义类三个成员变量,分别为id,name,perosn,他们的访问修饰都是private私有的,通过setter和getter方法对这些变量进行设值以及取值。封装的意义就是增强类的信息隐藏与模块化。封装的主要作用是对外部隐藏具体的实现细节,增加程序的安全性。

2、继承

java中的继承是指在一个现有类(父类)的基础上在构建一个新类(子类),子类可以集成父类的成员以及成员方法(但是不一定能访问或调用,例如private的私有地成员变量以及方法不能访问和调用)。继承的作用是能提高代码的复用性。子类拥有父类中的一切(拥有不一定能使用),它可以访问和使用父类中的非私有成员变量,以及重写父类中的非私有成员方法。

父类:

public class Person{
  private int a= 1;父类的私有属性
  private int id;
  private String name;
  private int age;
  public int getID(){
            return id; 
}
  public void setId(){
            this.id=id;  
}
  public String getName(){
             return name;
}
   public String setName(String name){
              this.name=name;
}
   public int Age(){
               return age();
}
   public void setAge(int age){
                this.age=age;  
}
    @Override
public String toString(){
return "Person [id="+id+",name="+name+",age="+age+"]";}

}
public void say(){
          System.out.println("person say");
}
public void run(){
           System.out.println("person run..");
}
//父类的私有方法
private void show(){
System.out.println(“persion show...”);
}
}

子类:

public class Student extends Person{

@Override

public void say(){

super.say();

}

@Override

public void run(){

super.run();

}

public static void main(String[] args){

Student st = new Student();

//st.show();//子类对象调用父类的私有方法,报错!!!

st.say();

st.run();

           }

}

继承的好处是实现代码的复用以及扩展,子类通过对父类代码的复用,可以不用再定义父类中已经定义好多的成员变量,方法上直接对父类的方法进行重写实现了扩展。

3、多态:

多态就是指多种状态,就是说当一个操作在不同的对象时,有产生不同的结果。

在Java中,实现多态的方式有两种,一种是编译时的多态,另一种是运行时多态,编译时的多态是通过方法的重载实现的,而运行时多态是通过方法的重写实现的。

方法的重载是指在同一个类中,有多个方法名相同的方法,但是这些方法有着不同的参数列表,在编译期我们就可以确定 到底调用 了那个方法。

方法的重写,子类重写父类中的方法(包括接口的实现),父类的引用不仅可以指向父类的对象,而且还可以指向子类的对象。当父类的引用指向子类的引用时,只有在运行时才能确定调用那个方法。

在运行时的多态需要满足三个条件:1、继承(包括接口的实现);2、方法的重写;3、父类的引用指向子类;

运行时的多态:

接口:(作用:声明方法和常量,不做实现,如果你跟我一样是上面的理解就错了,接口远没有我们想得那么简单,具体请看https://blog.csdn.net/hack_bug/article/details/7634737

public inteface  Animal{

      void shout();   
  

实现类:

public class Dog implements Animal{

@Override
public void shout(){

System.out.println("wangwang");
}
}

实现类:

public class Cat implement Animal{

@Override
public void shout(){
System.out.println("喵喵");
}

}

  测试:

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

//父类的引用指向子类对象
Animal d = new Dog();
animalShot(d);

//父类的引用指向子类对象
Animal c = new Cat();
animalShout(c);
}

public static void animalShout(Animal animal){
animal.shout();
}

}

父类引用子类的对象:什么是父类引用子类的对象?

Animal a1 =new Dog();父类的引用a1指向了子类的对象new Dog();

就是说Animal是一个接口,或者抽象类,那么是不可以创建对象的,这样写就可以也能后它的引用去指向他子类或者实现类的对象。

假如有一个类,这个类需要实现各种吃水果,有香蕉,苹果,李子等。

public void eat(Banana banana){////}

public void eat(Apple apple){}

这样写明显会很麻烦,但是如果这样写

public void eat(Fruit fruit){//////}

这样只继承Fruit或者实现Fruit接口,就都可以作为eat的参数,大大简化了编程

 

面向对象的核心虽然是这短短的六个字,但想把这六个字用活,用好,需要我们不断地学习和认识它。

(在面试的时候,遇到一个优秀面试官,能让菜鸡不断地成长。。。) ,下一节在写写接口啊,抽象啊,再重新认识下。总之,面向对象的开发,是以对象为中心的,额额,我好像还没有对象,自己创建一个把

接口的作用,意义和用途:https://www.cnblogs.com/zhaoyanjun/archive/2016/03/25/5320034.html

posted @ 2020-08-27 16:49  pickGo  阅读(142)  评论(0编辑  收藏  举报