2021-07-22

于 2021-07-22 21:26:50 发布
阅读量92 收藏
点赞数 1
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/JiaJiaAiChiYu/article/details/119009374
版权

封装

要义

该展示的展示，该隐藏的隐藏。

设计程序的时候要追求“高内聚，低耦合”。高内聚指的是：类的内部数据操作细节自己完成，不允许外部干涉；低耦合：仅暴露少量的方法给外部使用。

封装（数据的隐藏）

通常，应该禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏。

重点

属性私有，get/set

代码

package com.oop;
import com.oop.demo04.Student;
/*
1. 提高程序的安全性，保护数据
2. 隐藏代码的实现细节
3. 统一接口
4. 系统的可维护性
 */
public class Application {
    public static void main(String[] args) {
        Student s1 = new Student();

     s1.setName("jiajia");
     //判断一个类是不是相同：1.方法名是否相同 2. 参数列表是否相同
        System.out.println(s1.getName());
    }
}
/*
package com.oop.demo04;
//类   private:私有的
public class Student {
    //属性私有
    private String name; //名字
    private int id;//学号
    private char sex; //性别
    //提供一些可以操作这个属性的方法
    //提供一些public的get、set方法

    //get  获得这个数据
public String getName(){
    return this.name;
}
    //set  给这个数据设置值
    public void setName(String name){
       this.name = "jiajia";
    }
    //Alt + insert
    public int getId() { return id; }
    public void setId(int id) { this.id = id; }
    public char getSex() { return sex; }
    public void setSex(char sex) { this.sex = sex; }
}
 */

继承

继承的本质

继承的本质是堆某一批类的抽象，从而实现对现实世界更好的建模。

extends

extends的意思是“扩展”。子类是父类的扩展。

特点

JAVA中类只有单继承，没有多继承！
即：你只能有一个爸爸，但是你的爸爸可以有好多个儿子。

解释

  1. 继承是类和类之间的一种关系。除此之外，类和类之间的关系还有依赖、组合、聚合等。
  2. 继承关系的两个类，一个为子类(派生类)，一个为父类(基类)。子类继承父类，使用关键字extends来表示。
  3. 子类和父类之间，从意义上将应该具有“is a”的关系

代码

package com.oop;
import com.oop.demo05.Student;
public class Application {
    public static void main(String[] args) {
        Student student = new Student();
        student.say();
        student.setMoney(1000000000);
    }
}
/*
package com.oop.demo05;
//Person 人 :父类/基类
public class Person {
    //public
    //private  子类就用不了了
    //不写会默认的  default
    //protected  受保护的
    public void say(){
        System.out.println("说了一句话");
    }
    private int money = 1000000000;
    public int getMoney(){
        return money;
    }
    public void setMoney(int money){
        this.money = money;
        System.out.println(money);
    }
}
package com.oop.demo05;
//学生  is  人  子类/派生类
//子类继承了父类，就会拥有父类的全部方法！
public class Student extends Person {
    //Ctrl + H  出现继承树
}
 */

super

私有的无法被继承，用private无法继承

代码

package com.oop;

import com.oop.demo05.Person;
import com.oop.demo05.Student;

public class Application {

    public static void main(String[] args) {
       Student student = new Student();
       /*student.test("佳佳");*/
        student.test1();
    }
}
/*
public class Student extends Person {
    private String name = "aichiyu";

    public void test(String name){
        System.out.println(name);//佳佳
        System.out.println(super.name);//jiajia
        System.out.println(this.name);//aichiyu
    }
    public Student() {
        //有个隐藏代码：调用了父类的无参构造
        super();//调用父类的构造器，必须要在子类构造器的第一行
        System.out.println("Student无参执行了");
    }

    public void print(){
        System.out.println("Student");
    }
    public void test1(){
        print();//Student
        this.print();//Student
        super.print();//Person
    }
}
public class Person extends Object {
protected String name = "jiajia";

public Person() {
        System.out.println("Person无参执行了");
        }
public void print(){
        System.out.println("Person");
        }
}*/

note

super注意点：
    1.super掉以哦那个父类的构造方法，必须在构造方法的第一个
    2.super 必须只能出现在子类的方法或者构造方法中！
    3.super 和 this 不能同时调用构造方法

Vs this:
    代表的对象不同
        this: 本身调用者这个对象
        super: 代表父类对象的应用
    前提
        this: 没有继承也可以使用
        super: 只能在继承条件下才可以使用
    构造方法
        this() ;本类的构造
        super(): 父类的构造！

重写

重写都是方法的重写，和属性无关
静态的方法和非静态的方法区别很大
静态是对类，非静态是对对象

代码

package com.oop;
import com.oop.demo05.A;
import com.oop.demo05.B;
public class Application {
    public static void main(String[] args) {
       //静态方法   //方法的调用只和左边，定义的数据类型有关
        //非静态： 可以重写
        A a = new A();
        a.test();//A
        //父类的引用指向了子类
        B b = new A();//子类重写了父类的方法
        b.test();//B
    }
}
/*
public class A extends B {
    public void test(){
        System.out.println("A=>test()");
    }
}
//重写都是方法的重写，和属性无关
public class B {
    public void test(){
        System.out.println("B=>test()");
    }
}
 */

note

重写：需要有继承关系，子类重写父类的方法！
    1. 方法名必须相同
    2. 参数列表必须相同
    3. 修饰符：范围可以扩大,但是不可以缩小：public > Protected > Default > private
    4. 抛出的异常：范围可以被缩小，但不能扩大： ClassNotFoundException--->Exception(大)

重写，子类的方法和父类必须要一致： 方法体不同

为什么需要重写：
    1. 父类的功能，子类不一定需要，或者不一定满足！
      ALT + insert override 重写

多态

解释

即同以方法可以根据发送对象的不同而采用多种不同的行为方式。

一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多。

存在的条件

  1. 有继承关系。
  2. 子类重写父类方法。
  3. 父类引用指向子类。

注意

多态是方法的多态，属性没有多态性。

代码

package com.oop;
import com.oop.demo06.Person;
import com.oop.demo06.Student;
public class Application {
    public static void main(String[] args) {
        //一个对象的实际类型是确定的
        //new Student();
        //new Person()'

        //可以指向的引用类型就不确定了：父类的引用指向子类
        //子类能调用的方法都是自己的或者继承父类的
        Student s1 = new Student();
        //父类型，可以指向子类，但是不能调用子类独有的方法
        Person s2 = new Student();//父类的引用指向子类
        Object s3 = new Student();
        s2.run();//子类重写了父类的方法，执行子类的方法
        s1.run();

        //对象能执行哪些方法，主要看对象左边的类型，和右边的关系不大
        s1.play();
        ((Student) s2).play();
    }
}
/*
package com.oop.demo06;
public class Person {
    public void run(){
        System.out.println("run");
    }
}
多态注意事项：
1. 多态是方法的多态，属性没有多态
2. 父类和子类，有联系  类型转换异常！ ClassCastException!
3. 存在条件：继承关系，方法需要重写，父类引用指向子类对象！
   不可以重写的:
     1. static 方法:属于类，它不属于实例
     2. final 常量;
     3. private 方法;
package com.oop.demo06;
public class Student extends Person{
    @Override
    public void run() {
        System.out.println("girl");
    }
    public void play(){
        System.out.println("play");
    }
}
 */

instanceof 和 类型转换

代码

package com.oop;

import com.oop.demo06.Person;
import com.oop.demo06.Student;
import com.oop.demo06.Teacher;

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

        //Object > Person > Student
        //Object > Person > Person
        //Object > String
        Object object = new Student();

        //System.out.println(X instanceof Y);  能不能编译通过！  有关系就可以通过

        System.out.println(object instanceof Student);//true
        System.out.println(object instanceof Person);//true
        System.out.println(object instanceof Object);//true
        System.out.println(object instanceof Teacher);//false
        System.out.println(object instanceof String);//false
        System.out.println("--------------------------------");
        Person person = new Student();
        System.out.println(person instanceof Student);//true
        System.out.println(person instanceof Person);//true
        System.out.println(person instanceof Object);//true
        System.out.println(person instanceof Teacher);//false
        //System.out.println(person instanceof String);编译报错!
        System.out.println("--------------------------------");
        Student student = new Student();
        System.out.println(student instanceof Student);//true
        System.out.println(student instanceof Person);//true
        System.out.println(student instanceof Object);//true
        //System.out.println(student instanceof Teacher);编译报错
        //System.out.println(student instanceof String);编译报错
    }
}
/*
public class Person {}
public class Teacher extends Person {}
public class Student extends Person{}
*/

package com.oop;
import com.oop.demo06.Person;
import com.oop.demo06.Student;
public class Application {
    public static void main(String[] args) {
        //类型之间的转化:  基本类型转化   高低64  32  16  8   父  子

        //高                   低
        Person obj = new Student();
        //student将这个对象转换为Student类型，就可以使用Student类型的方法了！
        Student student = (Student) obj;
        student.go();
        ((Student) obj).go();

        //子类转换为父类，可能丢失自己本来的一些方法
        Student student1 = new Student();
        student.go();
        Person pewson = student1;
    }
}
/*
1.父类引用指向子类的对象:  Person pewson 指向 student;
2.把子类转换为父类，向上转型;可以直接转，无需强制转型
3.吧父类转换为子类，想下转型;要强制转型， 可能会丢失子类一些独有的方法
4.方便方法的调用，减少重复的代码！ 更简洁

抽象的


package com.oop.demo06;
public class Student extends Person{
   public void go(){
       System.out.println();
   }
}
 */

小结

  1. 父类引用指向子类的对象: Person pewson 指向 student;
  2. 2.把子类转换为父类，向上转型;可以直接转，无需强制转型
  3. 吧父类转换为子类，想下转型;要强制转型， 可能会丢失子类一些独有的方法
  4. 方便方法的调用，减少重复的代码！ 更简洁
佳佳爱吃鱼诶
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java:多态 之 向下转型+Instanceof关键字
Geek宝宝的努力！
10-21 2321
Animal.java: package com.imooc.animal; public class Animal { private String name; private int month; public Animal(){ } public Animal(String name,in
2021-07-22 markdown学习笔记
li520_fei的博客
07-22 3507
markdown学习笔记 Markdown标题 使用 # 号可表示 1-6 级标题，一级标题对应一个 # 号，二级标题对应两个 # 号，以此类推 = 和 - 标记 例： # 一级标题 ## 二级标题 一级标题 === 二级标题 ------- 效果： 一级标题 二级标题 一级标题 二级标题 Markdown段落 直接编辑文字 换行前加两个空格 也可以直接用一个空行隔开 Markdown字体 _斜体文本_ **粗体文本** __粗体文本__ ***粗斜体文本*** ___粗斜体文本___ ```
04Java面向对象_回顾----构造器、封装继承多态、instanceof、this、Super、接口、内部类等
从头再来的博客
03-25 136
04Java面向对象_回顾----构造器、封装继承多态、instanceof、this、Super、接口、内部类等面向对象编程概述类的方法引用传递创建和初始化对象构造器创建对象内存分析this封装继承Super重写多态instanceofStaticAbstract 类接口内部类IDEA 技巧Tips 面向对象编程概述 面向对象编程（Object-Oriented Programming，OOP） 面向对象编程的本质就是：以类的方式组织代码，以对象的方式组织（封装）数据 抽象 三大特性： 封装是指属性私有
JAVA 十九 内部类，Object类，instanceof判断方式
aibx的博客
02-28 3409
JAVA 十九 内部类，Object类，instanceof判断方式 标签（空格分隔）： JAVA 1.内部类 概念：将一个类定义在另一个类的里面，对里面那个类就称为内部类（内置类，嵌套类）。 内部类可以用public private protected等修饰符修饰 特点：内部类可以直接访问外部类中的成员，包括私有成员。而外部类要访问内部类中的成员必须要建立内部类的对象。然后通过对...
2021-07-18 Debug
Choulongx的博客
07-18 465
今天发现了一个低级错误 [Error] ld returned 1 exit status 回去查发现是写错了主函数名称 我是sb
2021-07-22 网络安全 sqlmap命令思维导图
热门推荐
时光隧道
07-22 5万+
2021-03-19
weixin_42564545的博客
03-19 454
aultium designer 中在原理图选择器件映射到 pcb，如下： 选择原理图的器件，然后依次 tool— Select PCB Compoments 。或者用快捷键，依次按t s，接下来会从原理图跳到pcb器件。
2021-07-09
u011385544的博客
07-09 2399
标题 doris FE安装部署后启动报错wait catalog to be ready. FE type: UNKNOWN. is ready: false 2021-07-09 11:41:53,586 INFO (main|1) [Catalog.loadImage():1468] image does not exist: /data/lib/doris/doris-meta/image/image.0 2021-07-09 11:41:54,055 INFO (UNKNOWN 172.17.0.1
2021-07-20
bananaAppen的博客
07-20 1万+
Markdown学习 标题： 二级标题 三级标题 字体 hello world! hello world! hello world! hello world! 引用 当一个牛逼的大佬 分割线 图片 [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0QBYDjzR-1626793548647)(C:\Users\Public\Pictures\Sample Pictures\de1d0155b209eb8677402e5bb7c217f31c21675b.png@880
log-aggregated-2021-07-28-080657.ips
07-28
log-aggregated-2021-07-28-080657.ips
cutepig123#cutepig123.github.io#2021-07-22-如何写好代码1
07-25
const item1 = new DataItem(1, 'name1', 100);const item2 = new DataItem(2, 'name2
5G时代下的数据智能化[2021-07-22]（44页）.pdf
05-18
在5G时代，数据智能化成为了科技进步的关键驱动力。这一概念主要涵盖了数据智能的发展趋势、5G技术如何影响数据智能以及由此带来的产业变革和机遇。以下是关于这些知识点的详细阐述： 1. 数据智能发展及趋势： ...
Demo-2021-07-04-22-00
04-07
GithubDemo 项目更新Github演示。 如果您想了解更多信息，请查看GitHub培训我的GitHub培训课程列表（第6小时） （16小时）
log-aggregated-2021-07-20-080015.ips
07-20
log-aggregated-2021-07-20-080015.ips
ZX02计算结果2021-07-011
08-08
文档"ZX02计算结果2021-07-011"涉及的是金融投资领域中的量化交易策略，特别是基于成交量择时的算法。在金融市场上，成交量是衡量市场活跃度的重要指标，通过分析成交量数据，投资者可以预测未来价格走势，制定相应...
集合框架2021-07-02.docx
07-02
例如，初始容量为10，第一次扩容后变为15，第二次扩容后变为22，以此类推。 在Java中，异常处理是必不可少的一部分。例如，`NoSuchFieldException`表示尝试访问的字段不存在，`NullPointerException`表示空指针引用...
数据库系统概论(2021-09-07-22-05-14).mmap
09-07
数据库系统概论(2021-09-07-22-05-14).mmap
建筑施工组织2021-回复-新连续梁图纸审核07-6-22.doc
05-19
建筑施工组织2021-回复-新连续梁图纸审核07-6-22.doc
java.lang.NumberFormatException: For input string: "2021-07-22T19:15:30"
最新发布
03-31
In this specific case, the string "2021-07-22T19:15:30" cannot be converted into a number because it contains characters that are not numeric. This error can occur in various situations, depending on...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值