Java核心技术类

最新推荐文章于 2024-07-08 00:01:13 发布

小葳宝贝最爱吃饭

最新推荐文章于 2024-07-08 00:01:13 发布

阅读量106

点赞数

分类专栏： Java 文章标签： java 抽象类多态编程语言

本文链接：https://blog.csdn.net/weixin_45182641/article/details/115327568

版权

Java 专栏收录该内容

7 篇文章 0 订阅

订阅专栏

Java核心技术类

类与对象
封装
继承
多态
内部类
抽象类和接口
类的常见关键字和方法技巧
总结

类与对象

对象：

世间万物皆可称之为对象，每个对象都是独立的个体，拥有自己的属性和行为。多个对象相互联系、交流、影响构成世界。

类：

Java世界中对象的映射，可以想象类就是对象在游戏世界的角色。

Java面向对象编程：

用Java类描述真实的对象，赋予类各种属性和方法，描述对象之间的关系，最终完成对真实世界的映射！

三大特性：封装、继承、多态。

JavaBean类标准形式

package CsdnPackage;

public class JavaClass {
    //私有的字段变量
    private String name;
    private int id;

    //重载的构造器
    public JavaClass() {

    }

    public JavaClass(String name, int id) {
        this.name = name;
        this.id = id;
    }

    //Getter和Setter
    public String getName() {
        return name;
    }

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

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    //我们自己的方法
    public void ok() {
        System.out.println("Our Method");
    }
}

封装

概念：

将类的内部细节隐藏起来，对外只提供某些接口，以完成功能任务。

可以联想真实世界中的每个人，都具有自己的个性、能力、特点，但第一次见面无法知道其特征，随着慢慢交流，其特征慢慢展现。我们就可以一起合作完成任务，例如，我叫他帮我买瓶水，我只需要给他钱和水的名称就好，不需要多余的指令，他自己就会完成该任务。

为什么要进行封装：

封装可以保证我们想存留的属性数据不会被胡乱修改，如果某类的属性数据没有封装，那么其他类就可以在其不知情的情况下对他的属性数据进行操作，这种感觉是及其不安全的！

Java以权限体现：

权限	范围
private	当前类可访问
default	同包可访问
protected	同包和子类可访问
public	都可访问

package CsdnPackage;

import java.util.Date;

/*
 * private 修饰的属性是我们想隐藏的内心
 * public 修饰的方法是我们对外开放的接口，外界可以通过public的接口让我们完成某些任务
 * */
public class PrivateClass {
    //字段属性定义基础形式: 权限  类型  字段名
    private String name;
    private int age;
    private Date birthday;

    /*
     * 构造器：犹如创造一个机器人，并赋予其天生的某些属性
     * 形式： 权限 类名(接收参数可有可无){
     *   ...
     * }
     * */

    public PrivateClass() {
    }

    public PrivateClass(String name, int age, Date birthday) {
        this.name = name;
        this.age = age;
        this.birthday = birthday;
    }

    /*
     * 方法定义基础形式：权限 返回值类型 方法名(接收参数可有可无){
     *    ...
     * }
     * getXXX和setXXX方法：犹如后天对属性进行更改设置，以及外界对我们的内心进行了解
     * */

    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 Date getBirthday() {
        return birthday;
    }

    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }
}

继承

概念：

在现有类的基础上构建一个新类。新类称为子类，现有类成为父类，子类会拥有父类中可以继承的属性和方法。

真实世界中继承很常见，像我们和父母的关系一样，我们可以继承父母的财产、事业。

好处：

可以利用现有类快速构建新类，并且新类可以有独特的方法以完成特别的任务。

Java以关键字extends体现：

package CsdnPackage;

//内部类的定义之后会说
class Father {
    private String name;
    private int age;

    public Father() {
    }

    public void fatherSay() {
        System.out.println("Father Say Hello");
    }

}

class Son extends Father {
    private String name;
    private int age;

    public Son() {
    }

    public void sonSay() {
        System.out.println("Son Say Hi");
    }
}

public class ExtendsClass {
    public static void main(String[] args) {
//新建类的实例，new 类的构造器;
        Son son = new Son();
//Son类型中并未定义fatherSay()方法，但却可以调用，这便是继承的意义，父类可继承的属性和方法都隐式的存在于子类中！
        son.fatherSay();
//子类也会有自己独立的特性。
        son.sonSay();
    }
}

多态

概念：

一个类型的某些对象对于共同的动作会有不同的反应形式，而Java为把这种现象描述出来创建了多态这一概念。

好处：

消除了类之间的耦合关系，可以提高性能和维护性。

Java以创建对象时左父右子体现

package CsdnPackage;

class Animal {
    String name = "animal";
    int age = 19;

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

class Dog extends Animal {
    String name = "dog";
    int age = 17;

    @Override
    public void song() {
        System.out.println("wang wang wang");
    }
}

class Cat extends Animal {
    String name = "cat";
    int age = 20;

    @Override
    public void song() {
        System.out.println("miao miao miao");
    }
}

public class PolymorphismClass {
    public static void main(String[] args) {
//创建对象时左边类型是父类型，右边类型是子类型，以此来体现多态
        Animal animalDog = new Dog();
        System.out.println("Animal name:" + animalDog.name + " age:" + animalDog.age);
        animalDog.song();
//从输出可以看出多态的成员变量都是父类型的值，而方法都是子类型的。因此多态是描述同类型不同对象对同一事件的不同反应
        Animal animalCat = new Cat();
        System.out.println("Animal name:" + animalCat.name + " age:" + animalCat.age);
        animalCat.song();
    }

}

内部类

概念：

在类中的类，可以看成一个盒子类装了许多其他的类。

形式：

静态内部类、匿名内部类、局部内部类、成员内部类。

Java体现

成员内部类

package CsdnPackage;


public class InnerClass {

    //成员内部类，就是可以当作成员变量使用的内部类
    class Circle {

        double radius = 0;

        public Circle(double radius) {
            this.radius = radius;
        }

        //可以一直嵌套成员内部类
        class Draw {
            double radius = 0;
        }


    }

    public static void main(String[] args) {

        //创建时首先建最外部的类，然后一步步往下建
        
        InnerClass first = new InnerClass();

        //内部类的命名是外部类.内部类。new的时候是已存在的外部类.new 内部类()
        InnerClass.Circle second = first.new Circle(2);

        InnerClass.Circle.Draw third = second.new Draw();
        System.out.println(second.radius + " " + third.radius);

    }
}

局部内部类

package CsdnPackage;

public class InnerClass {

    public void ok() {
        System.out.println("Hello");
//局部内部类，就是类放在方法体里，其作用域也仅限于方法体内
        class Home {
            private int a = 11;

            public void write() {
                System.out.println(a);
            }
        }
        Home home = new Home();
        home.write();
    }

    public static void main(String[] args) {
        InnerClass inClass = new InnerClass();
//    InnerClass.Home home=inClass.new Home();会报错，因为inClass对象无法直接访问到内部类
        inClass.ok();

    }
}

静态内部类

package CsdnPackage;

public class InnerClass {
    //静态内部类，可以突破先外类后子类的创建方式
    static class N {
        private int i = 0;

        public void write() {
            System.out.println(i);
        }
    }

    public static void main(String[] args) {
//创建时类型外类.子类 = new 外类.子类()
        InnerClass.N in = new InnerClass.N();
        in.write();
    }
}

匿名内部类

package CsdnPackage;

interface A {
    void shout();
}

public class InnerClass {
    public static void aShout(A a) {
        a.shout();
    }

    public static void main(String[] args) {
        String name = "XX";
//匿名内部类，直接通过new创建并使用，并不用命名，一般用于接口的实现
        aShout(new A() {
            public void shout() {
                System.out.println(name);
            }
        });
    }
}

抽象类和接口

概念：

抽象类

在现实生活中有很多东西是抽象的，他可以代表某类具有相同特性的群体，在某个特定的时刻他可以是该出现在那个位置的物件。

Java利用抽象进行描述，抽象的东西不需要写出具体的过程，只需要定义基本信息即可。

package CsdnPackage;

class A1 extends AbstractClass{

    @Override
    public void abstractWrite() {
        System.out.println("A1方式输出");
    }
}

class A2 extends AbstractClass{

    @Override
    public void abstractWrite() {
        System.out.println("A2方式输出");
    }
}

//抽象类无法进行实例化，抽象类是为了描述某些对象的共同特性而存在
public abstract class AbstractClass {

    private String name;
    private int id;

    public void write() {
        System.out.println("普通方法输出");
    }
//抽象方法必须放在抽象类中，该方法适应性极强，谁用他谁重写就行
    public abstract void abstractWrite();

    public static void main(String[] args) {
        A1 a1 = new A1();
        A2 a2 = new A2();
        a1.abstractWrite();
        a2.abstractWrite();
    }
}

接口

内部的行为都是抽象的类称为接口，接口与类之间的继承称为实现，用implements关键字完成该操作，接口之间同样用extends来继承。接口出现的原因很大一部分是为了补足Java单继承的缺陷。

package CsdnPackage;

//纯粹的抽象，所有东西都是为了描述共同特性，不夹带一点私货
interface Action1 {

    public String name = "我是接口的变量，我是final+static修饰的，所以我必须在出生的同时拥有值  ";

    //接口的方法是抽象的
    public void interfaceWrite();

}

interface Action2 {
    public int id = 1;
}

//可以利用接口同时拥有多个类型的特征
public class InterfaceClass implements Action1, Action2 {

    @Override
    public void interfaceWrite() {
        System.out.println("重写接口中的抽象方法");
    }

    public static void main(String[] args) {
        InterfaceClass interfaceClass = new InterfaceClass();
        interfaceClass.interfaceWrite();
        System.out.println(interfaceClass.name + interfaceClass.id);
    }
}

类的常见关键字和方法技巧

重载和递归

方法的重载就是接收参数的类型、类型个数和顺序不同，方法名参数等都相同时都被允许存在，其目的就是更好的处理从外界接收到的复杂信息。

package CsdnPackage;

public class MethodsClass {
//方法的重载是指只有接收参数和权限可以不同，其他相同的同名方法。
    public void add(int i,int j){
        System.out.println(i+j);
    }
    public void add(int i,double j){
        System.out.println(i+j);
    }
    public void add(double j,int i){
        System.out.println(i+j);
    }
    public void add(int i,int j,int k){
        System.out.println(i+j+k);
    }
    public void add(int i,int j,String a){
        System.out.println(i+j+a);
    }

    public static void main(String[] args) {
        int i=10;
        int j=20;
        int k=30;
        double l=30.5;
        String a="Hi";

        MethodsClass methodsClass = new MethodsClass();
        methodsClass.add(i,j);
        methodsClass.add(i,j,k);
        methodsClass.add(i,j,a);
        methodsClass.add(i,l);

    }
}

方法的递归就是利用某个可以停下来的条件，然后不停的调用自己。

package CsdnPackage;

public class MethodsClass {
    public static int sumAdd(int n) {
//判断条件，当最后一次时返回0
        if (n < 0)
            return 0;
//每次都调用自身,实际上的运作顺序就是sumAdd(9)+10,sumAdd(9)内部就是sumAdd(8)+9,依次深入知道小于0递归结束        
        return sumAdd(n - 1) + n;

    }

    public static void main(String[] args) {

        System.out.println(sumAdd(10));
    }
}

关键字

Name	Value
代指本类	this
静态	static
代指父类	super
最终	final

package CsdnPackage;

class FatherClass{
//final最终修饰的变量不可以重新赋值,static修饰的变量可以直接利用类名.变量名使用
    public static final int id=99;
    public void fatherWrite(){
        System.out.println("父类输出");
    }
//final修饰的方法不可以重写
    public final void finalMethod(){
        System.out.println("final方法不可重写");
    }
}
public class KeywordsClass extends FatherClass{
//当类第一次执行时自动执行,但也执行一次
    static {
        System.out.println("静态代码块执行");
    }
    public void sonWrite(){
        System.out.println("子类输出");
    }
//静态修饰的方法和变量可以利用类名和方法名直接调用,无需创建实例对象
    public static void hello(){
        System.out.println("静态方法调用类名.方法名");
    }

    public void useWrite(){
//super代表父类,可以利用super调用父类的方法变量等
        super.fatherWrite();
        System.out.println(super.id);
//this代表本类,可以利用this调用本类的方法变量等
        this.sonWrite();
    }

    public static void main(String[] args) {
        KeywordsClass.hello();
        System.out.println(FatherClass.id);
        KeywordsClass keywordsClass = new KeywordsClass();
        keywordsClass.useWrite();
    }
}

总结

类是Java核心中的核心，本文只是粗略对基础进行介绍，还有很多类的知识要进行学习，读者可以自行寻找，但一定要打好基础，把类学好学明白！

Author

小葳宝贝最爱吃饭

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
1
评论
Java核心技术类

Java核心技术类类与对象封装继承多态内部类抽象类和接口类的常见关键字和方法技巧类与对象对象：世间万物皆可称之为对象，每个对象都是独立的个体，拥有自己的属性和行为。多个对象相互联系、交流、影响构成世界。类：Java世界中对象的映射，可以想象类就是对象在游戏世界的角色。Java面向对象编程：用Java类描述真实的对象，赋予类各种属性和方法，描述对象之间的关系，最终完成对真实世界的映射！三大特性：封装、继承、多态。封装概念：将类的内部细节隐藏起来，对外只提供某些接口，以完成功能任务。
复制链接

扫一扫