Java程序设计（面向对象）- 三大支柱

曾经终败给现在 2022-01-27 13:43 304阅读 0赞

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NjUxMjY3_size_16_color_FFFFFF_t_70]面向对象的三个基本特征（三大支柱）是：封装、继承、多态。  
![在这里插入图片描述][20190526230352528.gif]

# 封装 #

## private关键字 ##

*  private的介绍：  
    a:是一个权限修饰符。  
    b:可以修饰成员(成员变量和成员方法)  
    c:被private修饰的成员只在本类中才能访问。
 *  private最常见应用：  
    A:把成员变量用private修饰  
    B:提供对应的getXxx()/setXxx()方法  
    例如：

package com.itxbj_05;
    /* * 学生类 * * 通过对象直接访问成员变量，会存在数据安全问题 * 这个时候，我们就想能不能不让外界的对象直接访问成员变量呢? * 能。 * 如何实现呢? * private关键字 * * private: * 是一个修饰符 * 可以修饰成员变量，也可以修饰成员方法 * 被private修饰的成员只能在本类中被访问 * * 针对private修饰的成员变量，我们会相应的提供getXxx()和setXxx()用于获取和设置成员变量的值,方法用public修饰 */
    public class Student { 
    	String name;
    	//int age;
    	private int age;
    	
    	public void setAge(int a) { 
    		if(a<0 || a>200) { 
    			System.out.println("你给的年龄有误");
    		}else { 
    			age = a;
    		}
    	}
    	
    	public int getAge() { 
    		return age;
    	}
    	
    	public void show() { 
    		System.out.println("姓名是："+name+",年龄是："+age);
    	}
    }
    
    
    package com.itlishan_05;
    /* * 学生类的测试类 */
    public class StudentDemo { 
    	public static void main(String[] args) { 
    		//创建学生对象
    		Student s = new Student();
    		s.show();
    		
    		s.name = "林青霞";
    		//s.age = 28;
    		//s.age = -28;
    		//s.setAge(-28);
    		s.setAge(28);
    		s.show();
    	}
    }

*  封装的概述和好处:
    
     *  封装概述  
        是面向对象三大特征之一，是面向对象编程语言对客观世界的模拟，客观世界里成员变量都是隐藏在对象内部的，外界无法直接操作和修改。就像刚才说的年龄。
     *  封装原则：  
        将不需要对外提供的内容都隐藏起来。  
        把属性隐藏，提供公共方法对其访问。  
        成员变量private，提供对应的getXxx()/setXxx()方法。
     *  好处：  
        通过方法来控制成员变量的操作，提高了代码的安全性。  
        把代码用方法进行封装，提高了代码的复用性。

## this关键字 ##

this关键字由来和使用:

*  this:代表所在类的对象引用。
 *  方法被哪个对象调用，this就代表那个对象。
 *  局部变量和成员变量重名的时候使用this。

# 继承 #

## 简介 ##

面向对象编程 (OOP) 语言的一个主要功能就是“继承”。继承是指这样一种能力：它可以使用现有类的所有功能，并在无需重新编写原来的类的情况下对这些功能进行扩展。  
介绍：

*  通过继承创建的新类称为“子类”或“派生类”。
 *  被继承的类称为“基类”、“父类”或“超类”。
 *  继承的过程，就是从一般到特殊的过程。
 *  要实现继承，可以通过“继承”（Inheritance）和“组合”（Composition）来实现。

在某些 OOP 语言中，一个子类可以继承多个基类。但是一般情况下，一个子类只能有一个基类，要实现多重继承，可以通过多级继承来实现。

继承概念的实现方式有三类：实现继承、接口继承和可视继承。

*  实现继承是指使用基类的属性和方法而无需额外编码的能力；
 *  接口继承是指仅使用属性和方法的名称、但是子类必须提供实现的能力；
 *  可视继承是指子窗体（类）使用基窗体（类）的外观和实现代码的能力。

在考虑使用继承时，有一点需要注意，那就是两个类之间的关系应该是“属于”关系。例如，Employee 是一个人，Manager 也是一个人，因此这两个类都可以继承 Person 类。但是 Leg 类却不能继承 Person 类，因为腿并不是一个人。

抽象类仅定义将由子类创建的一般属性和方法，创建抽象类时，请使用关键字 Interface 而不是 Class。

## 继承的格式&使用 ##

在程序中，如果想声明一个类继承另一个类，需要使用extends关键字。

格式：
    class 子类 extends 父类 {}

package com.itxbj_01;
    /* * 继承：多个类有共同的成员变量和成员方法，抽取到另外一个类中（父类），在让多个类去继承这个父类，我们的多个类就可以获取到父类中的成员了。 * extends * */
    public class ExtendsDemo { 
    	public static void main(String[] args) { 
    		DotA1 d = new DotA1();
    		d.start();
    		
    		LOL1 l = new LOL1();
    		l.start();
    	}
    }
    
    class Game1 { 
    	String name;
    	double version;//版本号
    	String agent;//代理商
    	
    	public void start() { 
    		System.out.println("游戏启动了");
    	}
    	
    	public void stop() { 
    		System.out.println("游戏关闭了");
    	}
    }
    
    class DotA1 extends Game1 { 
    	/*String name; double version;//版本号 String agent;//代理商 public void start() { System.out.println("游戏启动了"); } public void stop() { System.out.println("游戏关闭了"); }*/
    }
    
    class LOL1 extends Game1 { 
    	/*String name; double version;//版本号 String agent;//代理商 public void start() { System.out.println("游戏启动了"); } public void stop() { System.out.println("游戏关闭了"); }*/
    	
    }

## 特点 ##

在类的继承中，需要注意一些问题，具体如下：  
1、在Java中，类只支持单继承，不允许多继承，也就是说一个类只能有一个直接父类，例如下面这种情况是不合法的。

class A{} 
         class B{}
         class C extends A,B{}  // C类不可以同时继承A类和B类

2、多个类可以继承一个父类，例如下面这种情况是允许的。

class A{}
     class B extends A{}
     class C extends A{}   // 类B和类C都可以继承类A

3、在Java中，多层继承是可以的，即一个类的父类可以再去继承另外的父类，例如C类继承自B类，而B类又可以去继承A类，这时，C类也可称作A类的子类。下面这种情况是允许的。

class A{}
         class B extends A{}   // 类B继承类A，类B是类A的子类
         class C extends B{}   // 类C继承类B，类C是类B的子类，同时也是类A的子类

4、在Java中，子类和父类是一种相对概念，也就是说一个类是某个类父类的同时，也可以是另一个类的子类。例如上面的这种情况中，B类是A类的子类，同时又是C类的父类  
例如：

package com.itxbj_01;
    /* * Java中继承的特点： * Java语言只支持单一继承，只能继承一个父类（一个儿子只能有一个亲爹） * Java语言支持多层继承（一个儿子可以有一个亲爹，还可以有一个亲爷爷） * */
    public class ExtendsDemo2 { 
    	public static void main(String[] args) { 
    		LOL l = new LOL();
    		l.update();
    		l.start();
    	}
    }
    
    class Game { 
    	public void start() { 
    		System.out.println("游戏启动了");
    	}
    }
    
    class PCGame extends Game { 
    	public void update() { 
    		System.out.println("PCGame更新了");
    	}
    }
    
    class MobileGame extends Game { 
    	public void update() { 
    		System.out.println("MobileGame更新了");
    	}
    }
    
    class LOL extends PCGame { 
    	
    }

### 成员变量的特点 ###

A:子类只能获取父类非私有成员  
子父类中成员变量的名字不一样直接获取父类的成员变量  
子父类中成员变量名字是一样的获取的是子类的成员变量

B:就近原则：谁离我近我 就用谁  
如果有局部变量就使用局部变量  
如果没有局部变量，有子类的成员变量就使用子类的成员变量  
如果没有局部变量和子类的成员变量，有父类的成员变量就使用父类的成员变量  
C: super:可以获取父类的成员变量和成员方法,用法和this是相似的

例如：

package com.itxbj_01;
    /* * 继承中成员变量的特点 * 子类只能获取父类非私有成员 * 子父类中成员变量的名字不一样直接获取父类的成员变量 * 子父类中成员变量名字是一样的获取的是子类的成员变量 * * 就近原则：谁离我近我就用谁 * 如果有局部变量就使用局部变量 * 如果没有局部变量，有子类的成员变量就使用子类的成员变量 * 如果没有局部变量和子类的成员变量，有父类的成员变量就使用父类的成员变量 * 啥都没有，出错了！！！ * * super:可以获取父类的成员变量和成员方法,用法和this是相似的 */
    public class ExtendsDemo3 { 
    	public static void main(String[] args) { 
    		Kid3 k = new Kid3();
    		k.show();
    	}
    }
    
    class Dad3 { 
    	String name = "建霖";
    }
    
    class Kid3 extends Dad3 { 
    	String name = "四葱";
    	
    	public void show() { 
    		String name = "五葱";
    		
    		System.out.println(super.name);
    		System.out.println(this.name);
    		System.out.println(name);
    	}
    }

### 成员方法的特点&方法重写 ###

A:子类中没有这个方法,调用父类的

例如：

package com.itxbj_01;
    /* * 继承中成员方法的特点 * 子类中没有这个方法，调用父类的 */
    public class ExtendsDemo4 { 
    	public static void main(String[] args) { 
    		Kid4 k = new Kid4();
    		k.eat();
    	}
    }
    
    class Dad4 { 
    	public void eat() { 
    		System.out.println("小酌两口");
    		System.out.println("去睡觉了");
    	}
    }
    
    class Kid4 extends Dad4 { 
       
    }

B: 子类中重写了这个方法，调用子类的  
方法的重写：在子父类当中，子类的方法和父类的完全一样，子类重写了父类的方法（覆盖），当子类重写了父类的方法之后，使用子类对象调用的就是子类的方法  
例如：

package com.itxbj_01;
    /* * 继承中成员方法的特点 * 子类中没有这个方法，调用父类的 * 子类中重写了这个方法，调用子类的 * 方法的重写：在子父类当中，子类的方法和父类的完全一样，子类重写了父类的方法（覆盖），当子类重写了父类的方法之后，使用子类对象调用的就是子类的方法 方法的重载：在一个类中，有多个重名的方法，但是其参数不一样（参数的个数，参数的类型，参数的顺序），和返回值无关 */
    public class ExtendsDemo4 { 
    	public static void main(String[] args) { 
    		Kid4 k = new Kid4();
    		k.eat();
    	}
    }
    
    class Dad4 { 
    	public void eat() { 
    		System.out.println("小酌两口");
    		System.out.println("去睡觉了");
    	}
    }
    
    class Kid4 extends Dad4 { 
    	public void eat() { 
    		System.out.println("好好吃饭");
    	}
    }

### 7.6 方法重写的应用场景&注意事项 ###

*  方法重写的应用场景：  
    当父类的方法不能完全满足子类使用的时候，既可以保留父类的功能（沿袭、传承），还可以有自己特有的功能
 *  方法重写的注意事项：  
    不可以重写父类私有的成员方法，压根就看不到父类的私有成员  
    子类重写父类方法，权限必须大于等于父类方法的权限
 *  注解:  
    @Override：方法重写，说明下面的方法是重写父类的方法

例如：

package com.itxbj_03;
    /* * 方法重写的应用场景：当父类的方法不能完全满足子类使用，这个时候子类重写父类的方法， * 并可以在方法中使用关键字super调用父类的方法，这样做即可以保有父类的功能，也可以拥有子类特有的功能 * 方法重写的注意事项： * 不能重写父类私有的方法 * 权限必须大于等于父类方法的权限 * * 注解：@ * */
    public class ExtendsDemo5 { 
       public static void main(String[] args) { 
       	NewPhone np = new NewPhone();
       	np.call();
       }
    }
    
    class Phone { 
       void call() { 
       	System.out.println("打电话");
       }
    }
    
    class NewPhone extends Phone { 
       
       @Override
       public void call() { 
       	System.out.println("录音");
       	//System.out.println("打电话");
       	
       	//super.call();
       }
    }

### 构造方法的执行顺序 ###

*  super(实参列表);语句 在子类的构造方法中使用,用来调用父类中的构造方法(具体哪一个由传递的参数决定),并且只能在构造方法第一行使用
 *  this(实参列表); 语句 在类的构造方法中使用,用来调用本类中的其它构造方法(具体哪一个由传递的参数决定),并且只能在构造方法的第一行使用

例如：

package com.itxbj_01;
    /* * 继承中构造方法的执行顺序 * 在子父类中，创建子类对象，调用子类的构造方法， * 在子类的构造方法的第一行代码如果没有调用父类的构造或者没有调用子类的其他构造，则默认调用父类无参构造 * 为什么要调用父类构造？ * 因为需要给父类的成员变量初始化 * 肯定会先把父类的构造执行完毕，在去执行子类构造中的其他代码 * * 我是父类无参构造 --- 我是子类有参构造 --- 我是子类无参构造 */
    public class ExtendsDemo6 { 
       public static void main(String[] args) { 
       	//Die d = new Die();
       	Zi6 z = new Zi6();
       }
    }
    
    class Die6 { 
       public Die6() { 
       	System.out.println("我是父类无参构造");
       }
       
       public Die6(int num) { 
       	System.out.println("我是父类有参构造");
       }
    }
    
    class Zi6 extends Die6 { 
       public Zi6() { 
       	//super(1);
       	//super();
       	
       	this(1);//不会再调用父类的无参构造了
       	
       	System.out.println("我是子类无参构造");
       }
       
       public Zi6(int num) { 
       	//会默认调用父类无参构造
       	System.out.println("我是子类有参构造");
       }
    }

### this与super区别 ###

例如：

package com.itxbj_01;
    /* * this和super的区别 this:当前对象的引用 调用子类的成员变量 调用子类的成员方法 在子类的构造方法第一行调用子类其他构造方法 super:子类对象的父类引用 调用父类的成员变量 调用父类的成员方法 在子类的构造方法第一行调用父类的构造方法 */
    public class ExtendsDemo7 { 
    	public static void main(String[] args) { 
    		Zi z = new Zi();
    		z.function();
    	}
    }
    
    class Die { 
    	int num = 10;
    	
    	public Die() { 
    		System.out.println("我是父类无参构造");
    	}
    	
    	public Die(int num) { 
    		System.out.println("我是父类有参构造");
    	}
    	
    	public void method() { 
    		System.out.println("我是父类的方法");
    	}
    }
    
    
    class Zi extends Die { 
    	//int num = 30;
    	
    	public Zi() { 
    		//this(1);//第一行不调用子类其他构造或者是父类构造，默认调用父类无参构造
    		super();
    		System.out.println("我是子类无参构造");
    	}
    	
    	public Zi(int num) { 
    		System.out.println("我是子类有参构造");
    	}
    	
    	public void method() { 
    		System.out.println("我是子类的方法");
    	}
    	
    	public void function() { 
    		//this.num = 50;
    		//System.out.println(num);
    		//this.method();
    		
    		//super.num = 40;
    		//super.method();
    		
    		System.out.println(this.num);
    	}
    }

## 继承优缺点 ##

优点:

*  提高了代码的复用性
 *  提高了代码的可维护性

缺点：

*  类的耦合性增强了
 *  开发的原则：高内聚低耦合
 *  内聚：就是自己完成某件事情的能力
 *  耦合：类与类的关系

# 多态 #

多态是继封装、继承之后，面向对象的第三大特性。  
现实事物经常会体现出多种形态，如学生，学生是人的一种，则一个具体的同学张三既是学生也是人，即出现两种形态。  
Java作为面向对象的语言，同样可以描述一个事物的多种形态。如Student类继承了Person类，一个Student的对象便既是Student，又是Person。

## 多态的定义与使用格式 ##

多态的定义格式：就是父类的引用变量指向子类对象  
父类类型 变量名 = new 子类类型();  
变量名.方法名();

*  普通类多态定义的格式  
    父类 变量名 = new 子类();

如：

class Fu {}
    	class Zi extends Fu {}
    	//类的多态使用
    Fu f = new Zi();

*  抽象类多态定义的格式  
    抽象类 变量名 = new 抽象类子类();

如：

abstract class Fu {
             public abstract void method();
    	     }
    class Zi extends Fu {
    public void method(){
    		      System.out.println(“重写父类抽象方法”);
    }
    }
    //类的多态使用
    Fu fu= new Zi();

*  接口多态定义的格式  
    接口 变量名 = new 接口实现类();

如：

interface Fu {
    		     public abstract void method();
    }
    class Zi implements Fu {
    		     public void method(){
                  System.out.println(“重写接口抽象方法”);
    }
    }
    //接口的多态使用
    Fu fu = new Zi();

案例:

package com.itxbj_01;
    /*
     * 多态的前提：
     * 	子父类的继承关系
     * 	方法的重写
     * 	父类引用指向子类对象
     * 
     * 动态绑定：运行期间调用的方法，是根据其具体的类型
     * 
     * 
     * 
     * 
     */
    public class PoymorphicDemo {
    	public static void main(String[] args) {
    		/*Cat c = new Cat();
    		c.eat();*/
    		
    		//父类引用 Animal a
    		//指向	 =
    		//子类对象 new Cat()
    		
    		Animal a = new Cat();
    		a.eat();
    		
    	}
    }
    
    class Animal {
    	public void eat() {
    		System.out.println("吃东西");
    	}
    }
    
    
    class Cat extends Animal {
    	public void eat() {
    		System.out.println("猫吃鱼");
    	}
    }

## 多态成员的特点 ##

*  多态成员变量  
    当子父类中出现同名的成员变量时，多态调用该变量时：  
    编译时期：参考的是引用型变量所属的类中是否有被调用的成员变量。没有，编译失败。  
    运行时期：也是调用引用型变量所属的类中的成员变量。  
    简单记：编译和运行都参考等号的左边。编译运行看左边。
 *  多态成员方法  
    编译时期：参考引用变量所属的类，如果没有类中没有调用的方法，编译失败。  
    运行时期：参考引用变量所指的对象所属的类，并运行对象所属类中的成员方法。  
    简而言之：编译看左边，运行看右边  
    案例:

package com.itxbj_01;
        /* * * 多态的成员特点: * 成员变量 编译时看的是左边，运行时看的左边 * 成员方法 编译时看的是左边，运行时看右边 * 静态方法 编译时看的是左边，运行时看的也是左边 * * * 编译时看的都是左边，运行时成员方法看的是右边，其他（成员变量和静态的方法）看的都是左边 * */
        public class PoymorphicDemo2 { 
        	public static void main(String[] args) { 
        		Dad d = new Kid();
        		//System.out.println(d.num);
        		
        		//d.method();
        		d.function();//使用变量去调用静态方法，其实相当于用变量类型的类名去调用
        	}
        }
        
        class Dad { 
        	int num = 20;
        	
        	public void method() { 
        		System.out.println("我是父类方法");
        	}
        	
        	public static void function() { 
        		System.out.println("我是父类静态方法");
        	}
        	 }
         class Kid extends Dad { 
        	int num = 10;
        	
        	public void method() { 
        		System.out.println("我是子类方法");
        	}
        	
        	public static void function() { 
        		System.out.println("我是子类静态方法");
        	}
        }

## 多态中向上转型与向下转型 ##

多态的转型分为向上转型与向下转型两种：

*  向上转型：当有子类对象赋值给一个父类引用时，便是向上转型，多态本身就是向上转型的过程。

使用格式：

父类类型  变量名 = new 子类类型();
    如：Person p = new Student();

*  向下转型：一个已经向上转型的子类对象可以使用强制类型转换的格式，将父类引用转为子类引用，这个过程是向下转型。如果是直接创建父类对象，是无法向下转型的

使用格式：

子类类型 变量名 = (子类类型) 父类类型的变量;
    如:Student stu = (Student) p;  //变量p 实际上指向Student对象

案例:

package com.itxbj_01;
    /* * * 多态中的向上转型和向下转型: * * 引用类型之间的转换 * 向上转型 * 由小到大(子类型转换成父类型) * 向下转型 * 由大到小 * 基本数据类型的转换 * 自动类型转换 * 由小到大 * byte short char --- int --- long --- float --- double * 强制类型转换 * 由大到小 * * * */
    public class PoymorphicDemo3 { 
    	public static void main(String[] args) { 
    		Animal2 a = new Dog();//向上转型
    		//a.eat();
    		
    		Dog d = (Dog)a;//向下转型
    		d.swim();
    		
    	}
    }
    
    class Animal2 { 
    	public void eat() { 
    		System.out.println("吃东西");
    	}
    }
    
    
    class Dog extends Animal2 { 
    	public void eat() { 
    		System.out.println("啃骨头");
    	}
    	
    	public void swim() { 
    		System.out.println("狗刨");
    	}
    }

## 多态的优缺点 ##

案例:

package com.itxbj_01;
    /* * * 多态的优缺点 * 优点：可以提高可维护性（多态前提所保证的），提高代码的可扩展性 缺点：无法直接访问子类特有的成员 */
    public class PoymorphicDemo4 { 
    	public static void main(String[] args) { 
    		MiFactory factory = new MiFactory();
    		factory.createPhone(new MiNote());
    		
    		factory.createPhone(new RedMi());
    	}
    
    	
    }
    
    class MiFactory { 
    	/*public void createPhone(MiNote mi) { mi.call(); } public void createPhone(RedMi mi) { mi.call(); }*/
    	
    	public void createPhone(Phone p) { 
    		p.call();
    	}
    	
    }
    
    interface Phone { 
    	public void call();
    }
    
    //小米Note
    class MiNote implements Phone{ 
    	public void call() { 
    		System.out.println("小米Note打电话");
    	}
    }
    
    //红米
    class RedMi implements Phone { 
    	public void call() { 
    		System.out.println("红米打电话");
    	}
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NjUxMjY3_size_16_color_FFFFFF_t_70]: /images/20220127/fcbdf1b3a2564870968633ebf0779df0.png
[20190526230352528.gif]: /images/20220127/bf73f74c87c3428ba56f695f9667183b.png