08_面向对象的三大特性

最新推荐文章于 2019-08-16 13:53:45 发布
最新推荐文章于 2019-08-16 13:53:45 发布
阅读量157 收藏
点赞数
分类专栏： Java 文章标签： Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_45044194/article/details/94734672
版权

百知教育 - 孙帅 - 08_面向对象的三大特性

01_封装

  • 概念：
    尽可能 隐藏 对象内部实现细节，控制 对象的修改及访问的 权限。
  • 访问修饰符：
    private（可将属性修饰为 私有 ，仅本类可见）
  • 公共访问方法：
    • 作用：
      提供公共访问方法，以保证数据的 正常录入。
    • 命名规范：
      赋值：setXXX() //使用方法返回值实现赋值
      取值：getXXX() //使用方法返回值实现取值
  • 注意：
    定义类时，应当将类的 属性 设置为 private ，然后 提供公共访问方法。

02_继承的概念

  • 继承的实现：

    语法： class 子类 extends 父类{} // 定义子类 时，显示继承父类

  • 继承的特点：

    java为 单继承 ，一个类只能有一个直接父类（因此，类之间才能形成简单的树状结构），但可以多级继承，属性和方法逐级叠加。

  • 代码：
    package day9;
public class TestInheritance{
	public static void main(String[] args){
		Dog dog = new Dog();
		dog.eat();
	}
}

class Animal{
	public void eat(){
		System.out.println("eat it");
	}
	public void sleep(){}
}

class Dog extends Animal{
	public void shout(){}
}
  • 运行结果：

    在这里插入图片描述

03_访问修饰符

  • 父类的哪些属性和方法能 继承 给子类？ <==> 子类能 访问 父类的哪些属性和方法？（难理解）

  • 访问修饰符 访问范围 继承性

    private 本类内部 不可继承
    public 公开 可以继承
    (default) 本类+同包 同包子类可以继承
    protected 本类+同包+子类 可以继承

  • 构造方法：

    不可继承

  • 代码：
    package pa;
public class A{
 private int m1 = 10;
 int m2 = 20;
 protected int m3 = 30;
 public int m4 = 40;
}
    package pa;
public class B extends A{
 public void print(){
  System.out.println(m1);
  System.out.println(m2);
  System.out.println(m3);
  System.out.println(m4);
 }
}
    package pb;
import pa.A;
public class C extends A{
 public void print(){
  System.out.println(m1);
  System.out.println(m2);
  System.out.println(m3);
  System.out.println(m4);
 }
}
  • 运行结果：

    编译B类
    编译C类

04_组合聚合复用原则

  • LSP (面向对象理论中的里氏代换原则)

    内容： 针对父类描述的一句话，将父类换成子类时也必须是成立的。

  • 组合/聚合复用原则

    内容： 对于违反里氏代换原则的两个类，由于不存在is a关系，所以不能定义继承，可以用 组合 的方式实现类的代码 复用。

  • (组合/聚合复用原则说明)代码：
    class TechThief{	
	public void studyTech(){  //10000
	}
	public void thief(){}
}

class YKY{	
	TechThief techThief = new TechThief();
	public void studyTech(){
		techThief.studyTech();
	}
}

05_方法覆盖（Override）

  • 概念：
    子类用特殊的 方法实现 ，替换 掉父类继承给它的方法实现。
  • 语法：
    方法名相同，参数表相同，返回值类型相同，访问修饰符相同或 更宽。【private, (default), protected, public(最宽)】
  • 注意：
    当父类中的方法为私有时，因为子类没有继承到，所以不叫方法覆盖，也就不遵循方法覆盖的语法要求。

06_对象构造过程

  • 具有继承关系的对象构造过程

    例:(父类)A ---- B ---- C(子类)
    1) 分配空间
    2) 初始化A属性
    3) 调用A构造方法
    4) 初始化B属性
    5) 调用B构造方法
    6) 初始化C属性
    7) 调用C构造方法

  • super
    • 语法： 用在构造方法中，指明 调用父类 哪个 构造方法 ，必须出现在构造方法的 第一行 。
    • 理解： 如果一个构造方法的第一行不是super(…), 也不是this(…)，默认 为 super();
  • 代码：
    package day9;
public class TestSuper{
 public static void main(String[] args){
  new B();
 }
}
class A{
 public A(){
  System.out.println("A()");
 }
 public A(int n){
  System.out.println("A(int)");
 }
}
class B extends A{
 public B(){
  super(20);
  System.out.println("B()");
 }
 public B(int n){
  super();
  System.out.println("B(int)");
 }
}
  • 运行结果：

    在这里插入图片描述

  • 思考：
    class X{	
	public X(int i){}
}
class Y extends X{}
/*
编译错误：
Y类的定义相当于：
class Y extends X{	
	public Y(){
		super();
	}
}
由于X类中没有无参构造方法，所以会编译错误。
*/

07_super引用

  • super.（引用）
    • 含义： 指向 父类 对象
    • 作用： 用于 访问父类 被遮盖的 属性 或者用于 调用父类 被覆盖的 方法。
  • 代码：
    package day9;
public class TestSuper{
 public static void main(String[] args){
  Sup sup = new Sup();
  sup.invoke();
 }
}
class Super{
 public void method(){
  System.out.println("Super method");
 } 
}
class Sup extends Super{
 public void method(){
  System.out.println("Sup method");
 }
 public void invoke(){
  method();  //Sup method
  super.method();  //Super method
 }
}
  • 运行结果：

    在这里插入图片描述

08_09_多态的语法

  • 子类对象可以赋值给父类引用

    1. 只能对引用调用其 引用类型 中声明的方法。
      1.1 代码解释：

      package day10;
public class TestPloymorphism{
 public static void main(String[] args){
  Animal a = new Dog();
  a.eat();
  a.sleep();
  a.shout();
 }
}
class Animal{
 public void eat(){
  System.out.println("Animal eat");
 }
 public void sleep(){
  System.out.println("sleep 8 hours");
 }
}
class Dog extends Animal{
 public void sleep(){
  System.out.println("sleep 6 hours");
 }
 public void shout(){
  System.out.println("WangWang");
 }
}
class Cat extends Animal{
}

      1.2 运行结果：【编译错误：因为Animal中没有shout()方法】 在这里插入图片描述

    2. 运行时，根据 对象实际类型 ，调用子类覆盖之后的方法。

    3. 对象类型不变，强制类型转换，用于父类引用赋值给子类引用，但无法改变对象类型。因此，虽然 编译 能够 通过 ，但是 运行 时会 报错 。
      3.1 代码解释：

      package day10;
public class TestPloymorphism{
 public static void main(String[] args){
  Animal a = new Cat();
  a.eat();
  a.sleep();
  //a.shout();  error!
  Dog d = (Dog)a;
  d.shout();
 }
}
class Animal{
 public void eat(){
  System.out.println("Animal eat");
 }
 public void sleep(){
  System.out.println("sleep 8 hours");
 }
}
class Dog extends Animal{
 public void sleep(){
  System.out.println("sleep 6 hours");
 }
 public void shout(){
  System.out.println("WangWang");
 }
}
class Cat extends Animal{
}

      3.2 运行结果： （编译通过，运行错误：猫的对象类型并没有改变） 在这里插入图片描述

    4. 引用 instanceof 类名<==>“判断引用中的 对象 是不是 类名”， 用作强制类型转换之前进行类型判断，避免类型转换异常。
      4.1 代码解释：

      package day10;
public class TestPloymorphism{
 public static void main(String[] args){
  Animal a = new Dog();
  a.eat();
  a.sleep();
  //a.shout();  error!
  
  if(a instanceof Dog){
   Dog d = (Dog)a;
   d.shout();
  }
 }
}
class Animal{
 public void eat(){
  System.out.println("Animal eat");
 }
 public void sleep(){
  System.out.println("sleep 8 hours");
 }
}
class Dog extends Animal{
 public void sleep(){
  System.out.println("sleep 6 hours");
 }
 public void shout(){
  System.out.println("WangWang");
 }
}
class Cat extends Animal{
}

      4.2 运行结果：
      在这里插入图片描述

10_多态的意义

  • 多态的作用：

    把不同子类的对象，统一 看作 是 父类对象 来处理，屏蔽 了不同子类的 差异 ，使得代码有更好的 通用性 。

  • 多态的用法：
    1. 多态用在 参数 上 m(A a): m方法允许A类或A的某个子类对象作为实参
    2. 多态用在 返回值 上 A m(): m方法返回的是A类或A的某个子类对象
  • 代码：
    package day10;
public class TestPloy2{
 public static void main(String[] args){
  /*
  Dog a0 = new Dog();
  Cat a1 = new Cat();
  Monkey a2 = new Monkey();
  Tiger a3 = new Tiger();
  Sheep a4 = new Sheep();
  Cock a5 = new Cock();
  
  a0.eat();
  a1.eat();
  a2.eat();
  a3.eat();
  a4.eat();
  a5.eat();
  */
  
  Animal[] as = {new Dog(), new Cat(), new Monkey(), new Tiger(), new Sheep(), new Cock()};
  for(int i = 0; i < as.length; i++){
   as[i].eat();
  }
  
  Animal a = buyAnimal(2);
  Animal b = buyAnimal(3000);
 }
 /*
 static void feed(Dog d){
  d.eat();
 }
 static void feed(Cat c){
  c.eat();
 }
 ...
 */
 static void feed(Animal a){
  a.eat();
 }
 
 static Animal buyAnimal(int money){
  if(money<5) return new Cock();
  else if(money<50) return new Cat();
  else if(money<200) return new Dog();
  else if(money<500) return new Sheep();
  else if(money<1000) return new Monkey();
  else return new Tiger();
 }
}
class Animal{
 public void eat(){}
}
class Dog extends Animal{
 public void eat(){
  System.out.println("Dog eats bone");
 }
}
class Cat extends Animal{
 public void eat(){
  System.out.println("Cat eats fish");
 }
}
class Monkey extends Animal{
 public void eat(){
  System.out.println("Monkey eats banana");
 }
}
class Tiger extends Animal{
 public void eat(){
  System.out.println("Tiger eats human");
 }
}
class Sheep extends Animal{
 public void eat(){
  System.out.println("Sheep eats grass");
 }
}
class Cock extends Animal{
 public void eat(){
  System.out.println("Cock eats rice");
 }
}
  • 运行结果：

    在这里插入图片描述

cherishIntention
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
14_集合框架
m0_45044194的博客
08-01 230
百知教育 - 孙帅 - 14_集合框架 01_集合的概念 集合： 是一种工具类，是对象的容器，可以用于存储数量不等的多个对象的对象，代替数组 所有集合的接口和相关实现类都在java.util包中 底层结构： 数组 代码： package day15; import java.util.Arrays; public class TestMyList{ public static voi...
17_IO 编程
m0_45044194的博客
08-08 199
百知教育 - 孙帅 - 17_IO 编程 01_IO流的概念和分类 流 流就是内存与存储设备之间 传输数据 的通道、管道。 IO流的分类 按方向（以JVM虚拟机为参照物）【重点】 输入流： 将<存储设备>中的内容 读入 到<内存>中。 输出流： 将<内存>中的内容 写入 到<存储设备>中。 按单位 字节流： 以字节为单位，可以操作 所...
14_集合框架(续)
m0_45044194的博客
08-02 212
百知教育 - 孙帅 - 14_集合框架(续) 13_List的排序 代码： 在这里插入代码片
11_内部类
m0_45044194的博客
07-28 148
百知教育 - 孙帅 - 11_内部类 01_内部类概述 概念： 在一个类的内部再定义一个完整类 特点（编译时类型：运行时，用到哪个类就加载哪个类，不分内外）： 编译之后分别生成独立的字节码文件。 内部类可直接访问外部类的私有成员，而不破坏封装。 可为外部类提供必要的内部功能组件。 分类： 成员内部类、静态内部类、局部内部类、匿名内部类 代码（编译通过）： package day13...
16_多线程
m0_45044194的博客
08-06 194
百知教育 - 孙帅 - 16_多线程 01_线程的概念和实现线程的方式 什么是进程 程序是静止的，只有真正运行时的程序，才被称为进程。 单核CPU在任何时间点上，只能运行一个进程；宏观并行、微观串行。 什么是线程 线程，又称为 轻量级进程（Light Weight Process）。 是程序中的 一个顺序控制流程，同时也是 CPU的基本调度单位。进程由多个线程组成，彼此间完成不同的工...
chapter 01习题
m0_45044194的博客
05-20 1719
百知教育学习 - 胡鑫喆 - chapter 01习题 1. （标识符命名）下面几个变量中，哪些是对的？哪些是错的？错的请说明理由 A.ILoveJava B.$20 C.learn@java D.antony.lee E.Hello_World F.2tigers 代码/* * A right * B right * C wrong --> @ 不能出...
chapter 03函数习题
m0_45044194的博客
05-20 426
百知教育学习 - 胡鑫喆 - chapter 03函数习题 题目链接 提取码：nxo0 1.代码 package chapter_03; import java.util.*; public class Practice_03_01{ public static void main(String[] args) { Scanner s = new Scanner(System.in); ...
chapter 02循环结构习题
m0_45044194的博客
05-20 412
百知教育学习 - 胡鑫喆 - chapter 02循环结构习题 题目链接 提取码：a53a 1.代码 package chapter_02; public class Practice_02_01{ public static void main(String[] args) { int sum = 0; for(int i = 1; i < 101; i++) { su...
chapter 04 数组
m0_45044194的博客
06-05 292
百知教育学习 - 胡鑫喆 - chapter 04 数组 题目链接 提取码：h008 1、代码 package chapter_04; public class Practice_04_01{ public static void main(String[] args) { /* A 正确 * B 正确 * C 错误 --> int[] a = {1,2,3,4,5};...
循环与分支结构
m0_45044194的博客
05-19 279
百知教育学习 - 胡鑫喆 - 循环与分支结构 一、if选择结构与分支结构 if 语法 if（布尔表达式） { 代码块 } 在java中if的条件中只能写布尔表达 式，不能写整数表达式。 代码package day3; import java.util.Scanner; public class TestIf{ public static void main(String[] args){ ...
16_多线程（续）
m0_45044194的博客
08-07 253
百知教育 - 孙帅 - 16_多线程（续） 14_深入比较ArrayList和Vector Collections工具类中提供了多个可以获得线程安全集合的方法(均以synchronized实现)： public static < T > Collection synchronizedCollection(Collection c) public static < T &g...
18_网络编程
m0_45044194的博客
08-16 236
百知教育 - 孙帅 - 18_网络编程 01_网络基础 网络： 若干主机(host) 形成的有机整体； 按提供的服务不同，可以分为客户端、服务器 IP地址 标识网络主机的逻辑地址（192.168.0.1 四分十进制） 端口号 用来标识主机中的进程。 进程会预先绑定唯一的端口号，用来对外部 监听。 端口号范围：0-65535，其中0-1024为 预留端口。 四层协议 应...
数组
m0_45044194的博客
06-05 194
百知教育学习 - 胡鑫喆 - 数组 一、数组的认识 概念： 一组连续的存储空间，存储多个相同数据类型的值。 数组的遍历 二、数组创建语法 先声明、再分配空间： 数组类型[] 数组名； 数组名 = new 数据类型[长度] 声明并分配空间： 数据类型[] 数组名 = new 数据类型[长度] 声明并赋值（繁） 数据类型[] 数组名 = new 数据类型[]{ value 1, valu...
10_接口
m0_45044194的博客
07-20 167
百知教育 - 孙帅 - 10_接口 01_接口的基础语法 接口（特殊的抽象类）语法： 属性都是 公开静态常量 public static final 方法都是 公开抽象方法 public abstract 没有构造方法 实现接口语法： class 类名 implements 接口名 一个类实现接口，如果这个类不希望称为抽象类，就必须实现接口中的所有抽象方法 02_接口和类的关系 ...
Java概述与环境搭建
m0_45044194的博客
05-18 165
百知教育学习 - 胡鑫喆 - Java概述与环境搭建 一、编程语言 分类： 自然语言（和人交流） 机器语言（和计算机交流） 编程语言 编程语言： c c++ --> 面向对象 Java -->纯面向对象 二、Java的历史 Java是由Sun公司开发的，Sun公司已被Oracle公司收购 基于跨平台的需求，Oak项目组开发的Java 1995.5.23 发布了J...
基于NSGA-II的智能车辆换道轨迹规划与优化_查云飞.caj
最新发布
07-31
基于NSGA-II的智能车辆换道轨迹规划与优化_查云飞
chromedriver-mac-x64_122.0.6261.111.zip
07-31
chromedriver-mac-x64_122.0.6261.111.zip
chromedriver-mac-arm64_127.0.6485.0.zip
07-31
chromedriver-mac-arm64_127.0.6485.0.zip
c++面向对象三大特性
09-12
面向对象编程具有三大特性：封装、继承和多态。 1. 封装（Encapsulation）：封装是将数据和对数据的操作封装在一个类中，通过提供公共方法来控制对数据的访问。封装可以隐藏实现细节，使得代码更加模块化和可维护，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值