Java三大特性，封装、继承、多态

最新推荐文章于 2022-11-12 17:09:40 发布
最新推荐文章于 2022-11-12 17:09:40 发布
阅读量116 收藏
点赞数
分类专栏： Java基础
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42847094/article/details/105416380
版权

1.封装

文章目录

  • 该露的露，该藏的藏
    • 我们程序设计要追求 ”高内聚，低耦合“。高内聚就是类的内部数据操作细节自己完成，不允许外部干涉；低耦合：公暴露少量的方法给外部使用。
  • 封装（数据的隐藏）
    • 通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏。

属性私有，get/set.

关键字：private (私有的)

快捷键：Alt + Insert

/*
    1. 提高程序的安全性，保护数据
    2. 隐藏代码的实现细节
    3. 统一接口
    4. 系统可维护增加了
 */
public class Application {
    public static void main(String[] args) {
        Student s1 = new Student();
        s1.setName("小蓝"); //传
        System.out.println(s1.getName());

        s1.setAge(333);
        System.out.println(s1.getAge());

    }
}


//类  private: 私有
//快捷键 ：Alt + Insert
public class Student {

    //属性私有
    private String name; //名字
    private int id; //学号
    private char sex; //性别
    private int age; //年龄

    public Student() {
    }

    //提供一些可以操作这个属性的方法
    // 提供一些public 的 get、set 方法

    //get 获得这个数据
    public String getName(){
        return this.name;
    }

    //set 给这个数据设置值
    public void setName(String name){
        this.name = name;
    }

    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;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if(age  > 120 || age < 0) {//不合法
            this.age = 3;
        }else{
            this.age = age;
        }

    }
}

2.继承

  • 继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模。
  • extends 的意思是 ”扩展" 。子类是父类的扩展。
  • JAVA中类只有单继承，没有多继承！
  • 继承是类和类之间的一种关系。除此之外，类和类之间的关系还有依赖、组合、聚合等。
  • 继承关系的俩个类，一个为子类（派生类），一个为父类（基类）。子类继承父类，使用关键字***extends***来表示。
  • 子类和父类之间，从意义上讲应该具有“is a"的关系。

说白了就是继承父亲的全部。（私有无法被继承）

Ctrl + H 可以查看当前继承关系

1.Main主类

// Ctrl + H 可以查看当前继承关系
public class Application   {
    public static void main(String[] args) {

        Student student = new Student();
        student.say();
        System.out.println(student.getMoney());
    }
}
  1. Person 父类
package com.oop.Demo04;

//Person 人
//在 Java中，所有的类，都默认直接或者间接继承Object
public class Person {

    private int money = 10_0000_0000;

    public void say() {
        System.out.println("说了一句话！");
    }

    public int getMoney() {
        return money;
    }

    public void setMoney(int money) {
        this.money = money;
    }
}
  1. Teacher 子类
package com.oop.Demo04;

//Teacher is 人:  派生类，子类
public class Teacher extends Person{
}
  1. Student 子类
package com.oop.Demo04;
//学生 is 人:  派生类，子类
// 子类继承了父类，就会拥有父类的全部方法
public class Student extends Person {
}

2.1继承 super

// 1.Main 主类
package com.oop;
import com.oop.Demo04.Person;
import com.oop.Demo04.Student;

// Ctrl + H 可以查看当前继承关系
public class Application   {
    public static void main(String[] args) {
        Student student = new Student();
       // student.text("小蓝");

        //student.text1();

    }
}
  1. Student 子类
package com.oop.Demo04;

//学生 is 人:  派生类，子类
// 子类继承了父类，就会拥有父类的全部方法
public class Student extends Person {

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

    private  String name = "笨蛋";

    public void print(){
        System.out.println("Student");
    }

    public void text1(){
        print();//Student
        this.print();//Student
        super.print();//Person
    }

    public void text(String name){
        System.out.println(name);//小蓝
        System.out.println(this.name);//笨蛋
        System.out.println(super.name);//xiaolan
    }
}
  1. Person 父类
package com.oop.Demo04;

//Person 人
//在 Java中，所有的类，都默认直接或者间接继承Object
public class Person {
   public Person(){
      System.out.println("Person无参执行了");
   }
   protected String name = "xiaolan";

   public void print(){
      System.out.println("Person");
   }
}

2.2 super 和 this 的注意点

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

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

3.重写

    重写：需要有继承关系，子类重写父类的方法！
        1. 方法名必须相同
        2. 参数列表必须相同
        3. 修饰符：范围可以扩大但不能缩小： public > Protected > Default > private
        4. 抛出的异常：范围，可以被缩小，但不能扩大： ClassNotFoundException --> Exception(大）
    
    重写，子类的方法和父类必须一致：方法体不同！
    
    为什么需要重写：
        1. 父类的功能，子类不一定需要，或者不一定满足！
        Alt + Insert : override;  重写的快键

//测试类
package com.oop;

import com.oop.Demo04.A;
import com.oop.Demo04.B;
import com.oop.Demo04.Person;
import com.oop.Demo04.Student;

public class Application   {
    public static void main(String[] args) {
        //静态的方法和非静态的方法区别很大！
        //静态方法：方法的调用只和左边，定义的数据类型有关
        //非静态：重写
        A a = new A();
        a.test();

        //父类的引用指向了子类
        B b = new A();
        b.test();
    }
}


//父类
package com.oop.Demo04;

//重写都是方法的重写，和属性无关
public class B  {
    //static 静态方法
    /*public static void test(){
        System.out.println("B->text()");
    }*/
    
    public  void test(){
        System.out.println("B->text()");
    }

}


//子类
package com.oop.Demo04;
//继承
public class A extends B {

    /*public static void text(){
        System.out.println("A->text()");
    }*/

    //非静态
    //Override 重写
    @Override //注解：有功能的注解！
    public void test() {
        System.out.println("A->text()");
    }
}

4.多态

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

  • 一个对象的实际类型是确定的，但可以指向对象的引用类型有很多（父类，有关系的类）

  • 多态存在的条件

    • 有继承关系
    • 子类重写父类方法
    • 父类引用指向子类对象

  • 注意：多态是方法的多态，属性没有多态。

有这种修饰符不能重写方法

1. static 方法，属于类，它不属于实例
2. final 常量：
3. private  私有方法：

多态注意事项：
1. 多态是方法的多态，属性没有多态
2. 父类和子类，有联系 类型转换异常！ ClassCastException!
3. 存在条件： 继承关系，方法需要重写，父类引用指向子类对象！ Father f1 = new Son();    



//测试类
package com.oop;
import com.oop.demo05.Person;
import com.oop.demo05.Student;
public class Application {
    public static void main(String[] args) {

        //一个对象的实际类型是确定的
        //new Student();
        //  new Person();

        //可以指向的引用类型就不确定了：父类的引用指向子类

        //Student 能调用的方法都是自己的或者继承父类的！
        Student s1 = new Student();
        // Person 父类型，可以指向子类，但不能调用子类独有的方法
        Person s2 = new Student();
        Object s3 = new Student();

        //输出son
        s2.run(); //子类重写了父类的方法，执行子类的方法
        s1.run();

        //对象能执行哪些方法，主要看对象左边的类型，和右边关系不大！
        ((Student) s2).eat();
        s1.eat();
    }
}

//Person 父类
package com.oop.demo05;

public class Person {
    public void run(){
        System.out.println("run");
    }
}

//Student 子类

package com.oop.demo05;

public class Student extends Person {
    @Override //重写父类
    public void run() {
        System.out.println("son");
    }

    public void eat(){
        System.out.println("eat");
    }
}

5.instanceof

(类型转换) 引用类型，判断一个对象的什么类型~

1. 父类引用指向子类的对象
2. 把子类转换为父类，向下转型
3. 把父类转换为子类，向下转型； 强制转换
4. 方便方法的调用，减少重复的代码！

//测试类
package com.oop;
import com.oop.demo05.Person;
import com.oop.demo05.Student;
import com.oop.demo05.Teacher;

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

        //类型之间的转化： 父 子

        //高                 低
        Person obj = new Student();

        //student将这个对象转换为student类型，我闪就可以使用studnet类的方法了！
        ((Student)obj).go(); //强转换

        Student student = new Student();
        student.go();
        Person person = student;

		//下面是测试  instanceof      
        //object > Person > Student  等级
        //object > Person > Teacher
        //Object > String
        Object object = new Student();

        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(person instanceof String);//编译报错


    }
}

//父类 Person
package com.oop.demo05;

public class Person {
    public void run(){
        System.out.println("run");
    }
}

//子类  Student
package com.oop.demo05;

public class Student extends Person {
    public  void go(){
        System.out.println("go");
    }
}


//子类 Teacher
package com.oop.demo05;

public class Teacher extends Person{

}

6.Static (静态方法)

6.1调用静态方法

  • ​ 非静态能直接调用静态方法
  • 静态不能直接调用非静态方法
package com.oop.demo06;

//static 和类一起加载
public  class Student {

    private static int age; //静态的变量
    private  double score; //非静态的变量

    //非静态能调用静态方法
    public void run(){
        go();
    }

    //但静态不能调用非静态方法
    public static void go(){
      //  run();
    }
    public static void main(String[] args) {

        //new Student().run();

       /* Student.go();
        go();*/
       /* Student s1 = new Student();

        System.out.println(Student.age);
        System.out.println(s1.age);
        System.out.println(s1.score);*/
    }
}

6.2执行代码块

  1. 静态代码块(只会加载一次)
  2. 匿名代码块(赋初值~)
  3. 构造方法
package com.oop.demo06;

public class Person {

    //2: 赋初值~
    {
        System.out.println("匿名代码块");
    }

    //1：只会加载一次
    static {
        System.out.println("静态代码块");
    }

    //3
    public Person(){
        System.out.println("构造方法");
    }

    public static void main(String[] args) {
        Person person1 = new Person();
        System.out.println("===========");
        Person person2 = new Person();
    }
}

6.3静态导入包

package com.oop.demo06;
//静态导入包~
import static java.lang.Math.random;
import static java.lang.Math.PI;

public class Test {
    public static void main(String[] args) {
        //System.out.println(Math.random());
        System.out.println(random());
        System.out.println(PI);
    }
}

7.抽象类(abstract)

  • abstract 修饰符可以用来修饰方法也可以修饰类，如果修饰方法，那么该方法就是抽象方法；如果 修饰类，那么类就是抽象类。

  • 抽象类中可以没有抽象方法，但是有抽象方法的类一定要声明抽象类。

  • 抽象类，不能使用new 关键字来创建对象，它是用来让子类继承的。

  • 抽象方法，只有方法的声明没有方法的实现，它是用来让子类实现的。

  • 子类继承抽象类，那么就必须实现抽象类没有实现的抽象方法，否则该子类也要声明为抽象类。

  1. 不能new这个抽象类，只能靠子类去实现它：约束！

  2. 抽象类中可以写普通的方法；

  3. 抽象方法必须在抽象类中；

  4. 抽象的抽象：约束~

package com.oop.demo07;

//abstract 抽象类 ： 类 extends : 单继承
public abstract class Action {

    //约束~有人帮我们实现
    //abstract ， 抽象方法，只有方法名字，没有方法的实现！
    public abstract void doSomething();
}
  • **( Alt + insert )**快键
package com.oop.demo07;

//继承要写抽象的方法，不然会报错  (Alt + insert)
public class A extends Action {
    @Override
    public void doSomething() {

    }
}

8.接口（interface)

声明类的关键字是class ， 声明接口的关键字是interface.

  • 接口：只有只有规范！自己无法写方法~专业的约束！ 约束和实现分享：面向接口编程。
  • 接口的本质是契约。

作用：

1.约束

2.定义一些方法，让不同的人实现。（如10个人实现1个接口）

3.public abstract 方法默认有

4.public static final 常量默认有

5.接口不能被实例化，接口中没有构造方法

6.implements 关键字可以实现多个接口

7.必须要重写接口中的方法

  1. UserService 接口1
package com.oop.demo08;

//interface 定义接口的关键字，接口都需要有实现类
public interface UserService {
    //常量 public static final 默认有
     int AGE=99;

    //接口中的所有定义，都是抽象的 public abstract
    //public abstract 在接口中是默认有的
    void add(String name);
    void delete(String name);
    void update(String name);
    void query(String name);
}
  1. TimeService 接口2
package com.oop.demo08;

public interface TimeService {
    void timer();
}
  1. 实现以上两个接口，要用多个接口用关键字 implements
package com.oop.demo08;

//抽象类： extends
//类 可以实现接口 implements 接口
//实现了接口的类，就需要重写接口中的方法(Alt + insert)
public class UserServiceImpl implements UserService , TimeService{
    @Override
    public void add(String name) {

    }

    @Override
    public void delete(String name) {

    }

    @Override
    public void update(String name) {

    }

    @Override
    public void query(String name) {

    }

    @Override
    public void timer() {

    }
}

9.内部类

  • 内部类就是在一个类的内部定义一个类，比如，A类中定义一个B类，那么B类相对A类来说就称为内部类，而A类相对B类来说就是外部类。
  1. 成员内部类
  2. 静态内部类
  3. 局部内部类
  4. 匿名内部类
//测试类
package com.oop;
import com.oop.demo05.Person;
import com.oop.demo05.Student;
import com.oop.demo05.Teacher;
import com.oop.demo09.Outer;

public class Application {
    public static void main(String[] args) {
        Outer outer = new Outer();
        //通过这个外部类来实体化内部类~
        Outer.Inner inner = outer.new Inner();
        inner.in(); //输出内部类的方法
        inner.getID();//输出内部类的id
    }
}

//内部类的使用
package com.oop.demo09;
public class Outer {

    private int id = 10;
    public void out(){
        System.out.println("这是外部类的方法");
    }

    public class Inner{
        public void in(){
            System.out.println("这是内部类的方法");
        }

        //获得外部类的私有属性
        public void getID(){
            System.out.println(id);
        }
    }
}

9.1局部内部类

package com.oop.demo09;

public class Outer {

    //局部内部类
    public void method(){

        class Inner{
            public void in(){

            }
        }
    }

}

9.2匿名类

匿名类{}括号的最后都有个 ; 分号

package com.oop.demo09;

public class Test {
    public static void main(String[] args) {
        //没有名字初始化类，不用实例保存到变量中
        new Apple().eat();

        //匿名类
        UserService userService = new UserService(){

            @Override
            public void hello() {

            }
        };

    }
}

class Apple{
    public void eat(){
        System.out.println("1");
    }
}

interface UserService{
    void hello();
}

感谢狂神说：https://www.bilibili.com/video/BV12J41137hu?t=94&p=73

CodeCode!
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java基础—继承题目：编写一个Animal类，具有属性：种类；具有功能：吃、睡。定义其子类Fish...
weixin_30617695的博客
09-22 1万+
编写一个Animal类，具有属性：种类；具有功能：吃、睡。定义其子类Fish package zhongqiuzuoye; public class Animal { //属性 private String type; public String getType() { return type; } ...
【面试题】Java三大特性封装继承多态总结
qq_43679627的博客
01-10 1192
【面试题】Java三大特性封装继承多态总结
js对象总结（2）
gufudhn的博客
08-13 579
五、原型： 　　1、原型的定义： 原型是function对象的一个属性，它定义了构造函数制造出的对象的公共祖先。通过改构造函数产生的对象，可以继承该原型的属性和方法。原型也是对象。 　　2、利用原型特点和概念，可以提取共有属性。将一类对象的共有属性提取出来，放到该类对象的原型中，从而不需要每次用new操作符时都重新定义一遍该共有属性。 　　如下，定义一个Person构造函数，而属于Perso...
学生管理系统(简单版)
k_korol的博客
09-12 308
先创建Student类： package demo_学生管理系统练习; public class Student { private int stuNo;//学号 private String stuName;//姓名 private String stuSex;//性别 private int stuAge;//年龄 public Student...
Java抽象类的使用
qq_46547993的博客
10-02 326
Java抽象类，抽象方法使用 1.在学习完类的继承之后，抽象类与方法是必不可少的。 2.抽象方法：在普通类中加上abstract关键字，之后去掉类的大括号{}，然后分号结束。 //抽象类 public abstract class Animal{ //抽象方法 public abstract void eat(); //普通方法 public void normalMethod(){ } } 如何使用抽象类和抽象方法： 1.不能直接创建抽象类的对象 2.必须用一个子类继承抽象父类 3.子类必须覆盖重写抽象
Java面向对象三大特性(封装继承多态)解释及案例
coderge's CSDN Blog.
11-12 1608
继承可以解决代码复用,让我们的编程更加靠近人类思维.当多个类存在相同的属性(变量)和方法时，可以从这些类中抽象出父类，在父类中定义这些相同的属性和方法，所有的子类不需要重新定义这些属性和方法，只需要通过。测试类中添加一个方法showEmpAnnual(Employee e),实现获取任何员工对象的年工资，并在main方法中调用该方法[e.getAnnual()]简单的说:方法覆盖(重写)就是子类有一个方法，和父类的某个方法的名称、返回类型、参数一样那么我们就说子类的这个方法覆盖了父类的那个方法。
java 三大特性 封装 继承 多态
r_286636693_r的专栏
05-16 534
众所周知，java的三大特性：封装、继承、多态，那具体指的是什么？请往下看 封装是指实现隐藏细节，对用户提供访问接口。通俗来讲就是当我们定义一个类的成员时，使用private这个关键字来说明这个变量的权限，然后通过public的方法进行对这个变量的调用。对于一个变量，一般都有读取和赋值操作，即getXxx()（Xxx代表要访问的变量名称）进行读取和setXxx()进行赋值。 所谓继承就是通过已
Java三大特性：封装，继承与多态
冷血之心的博客
11-28 6575
（尊重劳动成果，转载请注明出处：https://blog.csdn.net/qq_25827845/article/details/84592274冷血之心的博客） 目录 （一）封装 封装的定义 封装的好处 （二）继承 继承的概念 子类的特点 构造函数 覆盖/重写的概念 （三）多态 多态的概念 向上转型 向下转型 总结 结束语         面向对象的语言有三大特...
Java三大特性、封装、继承，多态
qq_51008173的博客
09-24 311
简单描述Java的三大特性与重载和重写的区别
Java三大特性之封装继承多态
Ashes
06-29 784
一、 封装 封装是什么？ 访问权限的控制常常被称为是具体实现的隐藏。把数据和方法包装进类中，以及具体实现的隐藏，常共同被称为“封装”。 通常人们也单独只将具体实现的隐藏称为封装隐藏对象的属性和实现细节，仅对外公开接口，控制在程序中属性的读取和修改的访问级别（POJO） （我只给你看我希望你看到的东西，不该给你的东西你不需要知道） 为什么封装？ 封装的意义在于，这一点并不重要，重要的是类对外提
详解java封装继承多态
08-26
主要介绍了java封装继承多态，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
Java面向对象三大特性，即封装、继承、多态
12-23
Java面向对象三大特性思维导图 一、封装 封装的必要性：在对象的外部为对象的属性赋值，可能存在非法数据的录入，存在不安全隐患。就目前的技术而言，并没有办法对属性的赋值加以控制。所以要实现属性的封装非常重要...
Java面向对象编程（封装/继承/多态）实例解析
08-29
主要介绍了Java面向对象编程（封装/继承/多态）实例解析的相关内容，具有一定参考价值，需要的朋友可以了解下。
Java封装、继承、多态三大特征的理解
08-27
封装、继承、多态三大特征是java中比较常用的，务必要掌握，下面给大家介绍Java封装、继承、多态三大特征的理解，有不清楚的朋友可以一起学习下
java面向对象三要素封装继承和多态源码
10-28
java面向对象三要素封装继承和多态源码java面向对象三要素封装继承和多态源码java面向对象三要素封装继承和多态源码java面向对象三要素封装继承和多态源码java面向对象三要素封装继承和多态源码java面向对象三要素...
node-v0.10.9-sunos-x86.tar.gz
05-16
Node.js，简称Node，是一个开源且跨平台的JavaScript运行时环境，它允许在浏览器外运行JavaScript代码。Node.js于2009年由Ryan Dahl创立，旨在创建高性能的Web服务器和网络应用程序。它基于Google Chrome的V8 JavaScript引擎，可以在Windows、Linux、Unix、Mac OS X等操作系统上运行。 Node.js的特点之一是事件驱动和非阻塞I/O模型，这使得它非常适合处理大量并发连接，从而在构建实时应用程序如在线游戏、聊天应用以及实时通讯服务时表现卓越。此外，Node.js使用了模块化的架构，通过npm（Node package manager，Node包管理器）,社区成员可以共享和复用代码，极大地促进了Node.js生态系统的发展和扩张。 Node.js不仅用于服务器端开发。随着技术的发展，它也被用于构建工具链、开发桌面应用程序、物联网设备等。Node.js能够处理文件系统、操作数据库、处理网络请求等，因此，开发者可以用JavaScript编写全栈应用程序，这一点大大提高了开发效率和便捷性。 在实践中，许多大型企业和组织已经采用Node.js作为其Web应用程序的开发平台，如Netflix、PayPal和Walmart等。它们利用Node.js提高了应用性能，简化了开发流程，并且能更快地响应市场需求。
ARL-master-wade.zip
05-16
ARL-master-wade.zip
paralleled FLUS_V2.4.zip
05-16
paralleled FLUS_V2.4.zip
2121212111111111111111111
最新发布
05-17
212111111111111
Java面向对象封装继承多态
03-19
Java是一种面向对象的编程语言，它支持封装、继承和多态这三个重要的面向对象特性。 1. 封装（Encapsulation）：封装是将数据和对数据的操作封装在一个类中，通过访问修饰符来控制对数据的访问权限。封装可以隐藏...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值