Java三大特性(详细知识点+练习+扩展)

最新推荐文章于 2024-07-20 23:55:03 发布

嘟嘟嘟的小火车

最新推荐文章于 2024-07-20 23:55:03 发布

阅读量577

点赞数 38

分类专栏： # 《javaSE从0到1》文章标签： java eclipse intellij-idea 后端

本文链接：https://blog.csdn.net/weixin_51140943/article/details/124240439

版权

《javaSE从0到1》专栏收录该内容

8 篇文章 5 订阅

订阅专栏

👨‍💻作者简介: 大家好,我是小火车~~,在校大二学生一枚
🛳️个人主页: 嘟嘟嘟的小火车的博客
📗系列专栏: 本文写在《java从0到1》专栏
✉️如果文章知识点有错误的地方,请指正! 和大家一起学习一起进步🎈
🔥如果觉得博主的文章还不错的话,请👍三连支持👍一下博主哦

java三大特性

一.🥪类的封装

1.1🍞定义：

类的封装，是指将对象的状态信息隐藏在对象内部，不允许外部程序直接访问对象的内部信息，而是通过该类所提供的方法来实现对内部信息的操作访问。

1.2🥖为什么需要封装

public static void main(String[] args) {
          Person p = new Person();
          p.name = "张三";
          p.age = -18;
          p.speak();
    }

示例分析：

上述示例将年龄赋值为一个负数-18，在语法上不会有任何问题，因此程序可以正常运行，但在现实生活中明显是不合理的。

解决方案：

为了避免出现上述不合理的问题，在设计一个Java类时，应该对成员变量的访问作出一些限定，不允许外界随意访问，这就需要实现类的封装

1.3🥟如何实现封装

在定义一个类时，将类中的属性私有化，即使用private关键字来修饰，私有属性只能在它所在类中被访问.

如果外界想要访问私有属性，需要提供一些使用public修饰的公有方法，其中包括用于获取属性值的getXxx()方法和设置属性值的setXxx()方法。

package oop.demo04;

public class Application {
    public static void main(String[] args) {
        Student s1 = new Student();
        s1.setAge(130);
        System.out.println(s1.getAge());
    }

}

package oop.demo04;

public class Student {

    private String name;
    private int id;
    private char sex;
    private int age;

    public String getName(){
        return this.name;
    }
    public void setName(String name){
        this.name = name;
    }
    public void setAge(int age){
        if(age<120&&age>0){
            this.age=age;
        }else {
            this.age=0;
        }
    }
    public int getAge(){
        return this.age;
    }

}

我们程序追求"高内聚,低耦合".高内聚就是类的内部数据操作细节自己完成,不容许外部干涉;低耦合就是仅暴露很少的方法给外部使用.

封装(数据的隐藏):通常,应禁止直接访问一个对象中数据的实际表示.,而应操作接口来访问,这称为信息隐藏.

二.🥯类的继承

2.1🥮定义：

在Java中，类的继承是指在一个现有类的基础上去构建一个新的类，构建出来的新类被称作子类，现有类被称作父类或基类，子类会自动拥有父类所有可继承的属性和方法。

2.2🫕什么是继承？

在程序中，继承描述的是事物之间的所属关系，通过继承可以使多种事物之间形成一种关联体系。

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

继承是一种类与类的关系.子类继承了父类的公共属性和方法.除此之外,类与类之间的关系还有依赖,组合,聚合等.

类继承的语法格式：

[修饰符] class 子类名 extends 父类名 {
// 程序核心代码
}

//Person类
package oop.demo05;

public class Person {
    private String name;
    private int age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public void say(String xq){
        System.out.println("我最喜欢的爱好是"+xq);
    }
}
//Student类继承Person类
package oop.demo05;

public class Student extends Person{
    
}

//创建student对象,调用继承自父类里的方法
package oop.demo05;

public class Application {

    public static void main(String[] args) {
        Student student = new Student();
        student.setName("小火车");
        System.out.println(student.getName());
    }
}

2.3🍡继承的规则

在Java中，类只支持单继承，不允许多重继承，也就是说一个类只能有一个直接父类。

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

在Java中，多个类可以继承同一个父类

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

在Java中，多层继承是可以的，即一个类的父类可以再去继承另外的父类。

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

在Java中，子类和父类是一种相对概念，也就是说，一个类是某个类父类的同时，也可以是另一个类的子类.

在Java中,所有类都默认继承Object类.

2.3🍬重写父类方法

定义：

在继承关系中，子类会自动继承父类中公共的方法，但有时在子类中需要对继承的方法进行一些修改，即对父类的方法进行重写。

如果有一个类从它的父类继承了一个方法,如果这个方法没有被标记为final或static,就可以对这个方法进行重写.

注意：

子类中重写的方法需要和父类被重写的方法具有相同的方法名、参数列表以及返回值类型。
子类重写父类方法时，不能使用比父类中被重写的方法更严格的访问权限。

范围可以扩大不能缩小:public>protected>Default>private
方法是static修饰不是重写

扩展:静态方法–非重写

方法的调用只和左边定义的数据类型有关

package oop.demo07;

public class Application {
    public static void main(String[] args) {
        A a = new B();
        a.print();
        B b = new B();
        b.print();
    }
}
//A是父类
package oop.demo07;

public class A {
    public static void print(){
        System.out.println("A");
    }
}
//B是子类
package oop.demo07;

public class B extends A{

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

非静态方法–重写

package oop.demo07;

public class Application {
    public static void main(String[] args) {
        //子类重写了父类的方法 父类的引用指向了子类
        A a = new B();
        a.print();

        
        B b = new B();
        b.print();
    }
}
package oop.demo07;

public class A {
    public void print(){
        System.out.println("A");
    }
}
package oop.demo07;

public class B extends A{


    @Override//注解: 有功能的注释
    public void print() {
        System.out.println("B");
    }
}

2.4🍨 super关键字

在继承关系中，当子类重写父类的方法后，子类对象将无法直接访问父类被重写的方法。

所以在Java中专门提供了一个super关键字来访问父类的成员，例如访问父类的成员变量、成员方法和构造方法。

使用super关键字调用父类的成员变量和成员方法。

super.成员变量
super.成员方法([参数1,参数2…])

package oop.demo06;

public class Application {

    public static void main(String[] args) {
        Student student = new Student();
        student.test("小火车");
        student.test1();
    }
}
//Student类
package oop.demo06;

public class Student extends Person{


    public String name = "学生";


    public void print(){
        System.out.println("student");
    }
    public void test(String name){
        System.out.println(name);
        System.out.println(this.name);
        System.out.println(super.name);
    }

    public void test1(){
        print();
        this.print();
        super.print();
    }
}
//Person类
package oop.demo06;

public class Person {
    public String name = "person";

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

使用super关键字调用父类的构造方法。

super([参数1,参数2…])

package oop.demo06;

public class Application {

    public static void main(String[] args) {
        Student student = new Student();
        student.test("小火车");
        student.test1();
    }
}
package oop.demo06;

public class Student extends Person{


    public String name = "学生";

    public Student() {
        //隐藏代码:调用了父类的无参构造
        //调用父类的构造器,必须要在子类构造器的第一行
        super(); //只能调用一个构造器
        //this("小火车");必须要第一行
        //所以只能调用一个构造器
        System.out.println("Student无参执行了");
    }

    public Student(String name) {
        this.name = name;
    }

    public void print(){
        System.out.println("student");
    }
    public void test(String name){
        System.out.println(name);
        System.out.println(this.name);
        System.out.println(super.name);
    }


    public void test1(){
        print();
        this.print();
        super.print();
    }
}
package oop.demo06;

public class Person {
    public String name = "person";

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

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

super关键字注意点:

1. super调用父类的构造方法,必须在构造方法的第一个

2. super 必须只能出现在子类的方法或者构造方法中

3.super和this不能同时调用构造方法!

和this对比:

1.代表对象不同:

this:本身调用者这个对象

super:代表父类对象的应用

2.前提:

this:没有继承也可以使用

super:只能在继承条件下才可以使用

3.构造方法:

this:本类的构造

super:父类的构造

2.5 🍝Object类

在Java中提供了一个Object类，它是所有类的父类，即每个类都直接或间接继承自该类。

Object类通常被称之为超类、基类或根类。

当定义一个类时，如果没有使用extends关键字为这个类显示地指定父类，那么该类会默认继承Object类。

Object类——常用方法

方法声明	功能描述
boolean equals(Object obj)	判断某个对象与此对象是否相等
final Class<?> getClass()	返回此Object的运行时类
int hashCode()	返回该对象的哈希码值
String toString()	返回该对象的字符串表示
void finalize()	垃圾回收器调用此方法来清理没有被任何引用变量所引用对象的资源

Object类的toString()方法中输出信息格式及说明：

 getClass().getName() + "@" + Integer.toHexString(hashCode());

getClass().getName()：代表返回对象所属类的类名，即包名+类名的全限定名称。
hashCode()：代表返回该对象的哈希值。
Integer.toHexString(hashCode())：代表将对象的哈希值用16进制表示。

其中, hashCode()是Object类中定义的一个方法，这个方法将对象的内存地址进行哈希运算，返回一个int类型的哈希值。

2.6🍦 final关键字

final关键字可用于修饰类、变量和方法，它有“不可更改”或者“最终”的含义。

因此被final修饰的类、变量和方法将具有以下特性:

1. final修饰的类不能被继承；

2. final修饰的方法不能被子类重写；

3. final修饰的变量（成员变量和局部变量）是常量，只能赋值一次

三.🧀多态

3.1🥖定义：

在Java中，多态是指不同类的对象在调用同一个方法时所呈现出的多种不同行为。

3.2🍭什么是多态?

通常来说，在一个类中定义的属性和方法被其他类继承或重写后，当把子类对象直接赋值给父类引用变量时，相同引用类型的变量调用同一个方法所呈现出的多种不同形态。

多态的体现方式

Java的多态性是由类的继承、方法重写以及父类引用指向子类对象体现的。

由于一个父类可以有多个子类，多个子类都可以重写父类方法，并且多个不同的子类对象也可以指向同一个父类。

这样，程序只有在运行时程序才能知道具体代表的是哪个子类对象，这就体现了多态性。

作用：

通过多态，消除了类之间的耦合关系，大大提高了程序的可扩展性和可维护性。

package oop.demo08;

public class Application {


    public static void main(String[] args) {
        //一个对象的实际类型是确定的
        //new Person()
        //new Student()

        //可以指向的引用类型就不确定了
        //student 能调用的方法都是自己的或者继承父类的
        Student s1 = new Student();
        s1.print();
        //Person 父类型,可以指向子类,但是不能调用子类独有的方法
        Person s2 = new Student();
        Object s3 = new Student();
        s2.print();
        //对象能执行哪些方法,主要看对象左边的类型,和右边关系不大
        //s2.eat();  不能调用
        ((Student) s2).eat();
        //类型转换

    }
}
package oop.demo08;

public class Person {
    public void print(){
        System.out.println("person");
    }
}
package oop.demo08;

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

多态的注意事项

1.多态是方法的多态,属性没有多态

2.类型转换需要有父子关系,否者会报错. 类型转换异常 ClassCastException

3.存在条件:继承关系,方法需要重写,父类引用指向子类对象! Father f1 = new Son();

4.一些方法不可以:

static 方法属于类,它不属于实例
final 常量
private 方法

3.3🍔 instanceof 关键字

用来判断对象类型是不是其他类型的子类

package oop.demo09;

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

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

        System.out.println(object instanceof Student);
        System.out.println(object instanceof Person);
        System.out.println(object instanceof Object);
        System.out.println(object instanceof Teacher);
        System.out.println(object instanceof String);

        Person person = new Person();
        System.out.println(person instanceof Student);
        System.out.println(person instanceof Person);
        System.out.println(person instanceof Object);
        System.out.println(person instanceof Teacher);
        //System.out.println(person instanceof String);

        Student student = new Student();
        System.out.println(student instanceof Student);
        System.out.println(student instanceof Person);
        System.out.println(student instanceof Object);
        //System.out.println(student instanceof Teacher);
        //System.out.println(student instanceof String);

    }
}

编译是否通过取决于该对象的引用类型是不是对比类型的父类

结果是否为ture取决于该对象的实际类型是不是对比类型的子类

3.4🍟类型转换

向上转型：在多态的学习中，涉及到将子类对象当做父类类型使用的情况，此种情况在Java的语言环境中称为“向上转型”。

package oop.demo10;

public class Application {

    public static void main(String[] args) {
        //低转高 自动转  可能会丢失一些子类的方法
        Student student = new Student();
        Person person = student;
        //Person person1 = new Student(); //向上转型
        //高转低  强制转  就可以用子类里的方法了
        Person person1 = new Person();
        Student student1 = (Student) person1;
        //Student student2 = (Student) new Person();
        student1.print();
        //((Student) person1).print();
        
    }
}
package oop.demo10;

public class Person {
}
package oop.demo10;

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