IDEA+包+封装+继承

已于 2025-04-12 20:36:31 修改
阅读量802 收藏 26
点赞数 23
文章标签： intellij-idea java ide
于 2025-04-12 20:36:02 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_51718998/article/details/147111011
版权

IDEA除了可以开发java还支持HMIL、CSS、PHP、MySQL、Python等

Elipse是目前最好的java开发工具之一

IDEA官网地址

https://www.jetbrains.com/

用IDEA写一个冒泡排序

public class Hello {
    public static void main(String[] args){
       MyTools a = new MyTools();
       int[] b ={1,2,5,8,2,1,0,3};
       int[] c = a.bummle(b);
       for(int i=0;i<b.length;i++){
           System.out.println(c[i]);
       }
    }
}
class MyTools{
    public int[] bummle(int a[]){
        for(int i=0;i<a.length-1;i++){
            for(int j=0;j<a.length-i-1;j++){
                if(a[j]>a[j+1]){
                    int index = a[j];
                    a[j] = a[j+1];
                    a[j+1] = index;
                }
            }
        }
        return a;
    }
}

在IDEA中run会先编译成.class文件再运行

ctr+alt+L可以实现自动排版。如果要修改快捷键可以点击Settings

再Keymap里找Editor Actions

这里我演示一下修改run的快捷方式

系统自动默认的快捷键是Ctrl+R如果想修改的话可以右键点击Remove ctrl+R

然后再右键点击Add Keyboard Shortcut

在弹出来的窗口中输入你想创建的快捷方式，点击OK就行了，添加的快捷方式就可以在IDEA中使用了。

ctrl+B可以直接定义到方法上

输入快捷键

//sout+回车
        System.out.println();
        //fori+回车
        for (int i = 0; i < ; i++) {
            
        }

包的三大作用

  1. 区分相同名字的类
  2. 当类很多时，可以很好的管理类
  3. 控制访问范围

包基本语法

package com.hello;package表示打包，com.hello表示包名

import java.util.Arrays;
Arrays.sort(arr);可以实现数组的从小到大排序

import指令位置放在Package的下面，在类定义前面，且可以有多句无顺序要求

修饰符的访问范围
访问级别访问控制修饰符同类同包子类不同包
公开public√√√√
受保护protected√√√×
默认没有修饰符√√××
私有private√×××

修饰符可以修饰成员，方法和类

面向对象的三大特征！！！

封装，继承和多态

封装（encapsulation）:

把抽象出的数据（属性）和对数据的操作（方法）封装在一起，数据被保护在内部，程序的其他部分只有通过被授权的操作[方法]，才能对数据进行操作。

封装的实现步骤（1）将属性进行私有化private（2）提供一个公共的set方法，用于获取属性判断并赋值

public void setxxx(类型 参数名){

属性 = 参数名；

}

（3）提供一个公共的get方法，用于获取属性的值

public XX getXxx(){

return xx;

}

eg: 请大家看一个小程序，不能随便查看人的年龄，工资等隐私，并对设置的年龄进行合理验证，年龄合理就设置，否则给默认，年龄必须在1-120，年龄工资不能直接查看，name的长度在2-6之间。

package com.edu.encap;

public class Encapsulation {
    public static void main(String[] args){
        Person person = new Person();
        person.setName("jack");
        person.setAge(20);
        person.setSalary(3000,20001);
        System.out.println(person.info());
    }
}



class Person {
    public String name; //名字公开
    private int age; //年龄私有
    private double salary;
    private int code;//查看薪水需要密码
    public String getName() {
        return name;
    }
    public void setName(String name) {
        //加入对数据的校验
        if(name.length()>=2&&name.length()<=6){
            this.name = name;
        }else{
            System.out.println("名字的长度不对，需要2-6个字符，给你一个默认名字");
            this.name = "无名人";
        }

    }

    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        if(age>=1&&age<=120) {
            this.age = age;
        }else{
            System.out.println("你设置的年龄不对，需要在（1-120），给你默认年龄18");
            this.age = 18;//给一个默认年龄
        }
    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary ,int code) {
        if(code == 200301){
            this.salary = salary;
        }else{
            System.out.println("密码输入错误");
        }

    }

    //写一个方法返回
    public String info(){
        return "信息为name="+name+" age="+age+" 薪水"+salary;
    }
}

如果发现运行不了，可能是因为没有配置类，在运行的时候要配置一下类

点击Edit Configurations，再点击Main class的三个小圆点，选择你要导入的包类

再点击OK就行

继承

继承可以解决代码复用，让我们的编程更加接近人类思维，当多个类存在相同的属性和方法时，可以从这些类中抽象出父类，在父类中定义这些相同的属性和方法，所有的子类不需要重新定义这些属性和方法，只需要通过extends来声明继承父类即可。

基本语法

class 子类 extends 父类{

}

（1）子类就会自动拥有父类定义的属性和方法

（2）父类又叫做超类，基类。

（3）子类又叫派生类。

子类继承了所有的属性和方法，非私有的属性和方法可以在子类直接访问，但是私有属性和方法不能在子类直接访问，要通过公共的方法去访问。子类必须调用父类的构造器，完成父类的初始化。当创建子类对象时，不管使用子类的哪个构造器，默认情况下总会去调用父类的无参构造器，如果父类没有提供无参构造器，则必须在子类的构造器中用super去指定使用父类（默认使用无参构造器）的哪个构造器完成对父类的初始化工作，否则，编译不会通过。super和this都只能在构造器的第一行，这两种方法不能共存在一个构造器。this访问本类构造器，super访问父类构造器。

以下为案列，分析代码的输出情况

package com.edu.extend.exercise;

public class ExtendsExercise01 {
    public static void main(String[] args){
        B b = new B();
    }
}
class A {
    A() {
        System.out.println("a");
    }

    A(String name) {
        System.out.println("a name");
    }
}
class B extends A{

    B(){
        this("abc");//执行本类的带name的构造器
        System.out.println("b");
    }

    B(String name){
        //此处默认super，默认调用父类的无参构造器
        System.out.println("b name");}
    }
package com.edu.extend.exercise;

public class ExtendsExercise02 {
    public static void main(String[] args){
        E e = new E();
    }
}
class C {
    public C() {
        System.out.println("我是A类");//①
    }
}
class D extends C {
    public D() {
        System.out.println("我是B类的无参构造");
    }
    public D(String name) {
        //这里有一个默认的super，去找父类的无参构造器
        System.out.println(name + "我是B类的有参构造");//②
    }
}

class E extends D{
    public E() {
        this("hello");//去找本构造器的同名构造器
        System.out.println("我是c类的无参构造");//④
    }
    public E(String name) {
        super("hahah");//去找父类的构造器
        System.out.println("我是c类的有参构造");//③
    }
}

继承的本质，查找的时候首先看子类是否有该属性，如果子类有该属性并且可以访问，则返回信息。如果子类没有该类属性，就看父类有无，如果有并可以访问就返回信息，如果父类没有就继续找上一级父类，直到object。

若把属性改为private，可通过继承来访问即在private属性里加入一个get即可。如果父类有该属性不管是否private，都会停止访问父类以上的。

主方法

package com.edu.extend.exercise;

import sun.plugin2.gluegen.runtime.CPU;

public class ExtendsExercise03 {
    public static void main(String[] args){
        NotePad pc = new NotePad("华硕",16,500,"IBM","白色");
        pc.printInfo();
    }
}

Computer类 

package com.edu.extend.exercise;

public class Computer {
    public Computer(){

    }
    private String cpu;
    private int memory;
    private int disk;

    public Computer(String cpu, int memory, int disk) {
        this.cpu = cpu;
        this.memory = memory;
        this.disk = disk;
    }

    public String getDetials(){
        return "cpu="+cpu+" memory="+memory+" disk="+disk;
    }

    public String getCpu() {
        return cpu;
    }

    public void setCpu(String cpu) {
        this.cpu = cpu;
    }

    public int getMemory() {
        return memory;
    }

    public void setMemory(int memory) {
        this.memory = memory;
    }

    public int getDisk() {
        return disk;
    }

    public void setDisk(int disk) {
        this.disk = disk;
    }
}

PC子类

package com.edu.extend.exercise;

public class PC extends Computer{
    public PC(){

    }
    private String brand;
    //父类的构造器完成父类属性初始化，子类的完成子类的属性初始化
    public PC(String cpu, int memory, int disk, String brand) {
        super(cpu, memory, disk);
        this.brand = brand;
    }

    public String getbrand(){
        return "brand="+brand;
    }

    public String getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }


}

NotePad子类

package com.edu.extend.exercise;

public class NotePad extends PC{
        private String color;

    public NotePad(String cpu, int memory, int disk, String brand, String color) {
        super(cpu, memory, disk, brand);
        this.color = color;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public void printInfo() {
        System.out.println("PC信息=");
        System.out.println(getDetials()+" " + getbrand() + " color="+color);
    }
}

Super关键字

super代表父类的引用，用于访问父类的属性，方法，构造器。但不能访问父类的private，遵循就近原则。

方法重写/覆盖：子类有一个方法，和父类的某个方法的名称、返回类型、参数一样，我们就说这个子类的方法覆盖了父类的那个方法。子类的方法的返回类型和父类方法返回类型一样，或者是父类返回类型的子类，比如父类返回类型是Object 子类返回类型是String。子类方法不能缩小父类方法的访问权限就是public跟private。

package com.edu.extend.exercise;

public class OverrideExercise {
    public static void main(String[] args){
        Person xiaoming = new Person("小明",18);
        Student xiaoqiang = new Student("小强",20,20030101,596);
        System.out.println(xiaoming.say());
        System.out.println(xiaoqiang.say());
    }
}



package com.edu.extend.exercise;

public class Person {
//    public Person(){
//
//    }
        private String name;
        private int age;

        public Person(String name, int age) {
            this.name = name;
            this.age = age;
        }

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

        public String getName() {
            return name;
        }

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

        public int getAge() {
            return age;
        }

        public String say(){
            return "姓名："+name+" 年龄="+age;
        }
}

package com.edu.extend.exercise;

public class Student extends Person{
    private int id;
    private double score;

    public Student(String name, int age, int id, double score) {
        super(name, age);
        this.id = id;
        this.score = score;
    }

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

    public int getId() {
        return id;
    }

    public void setScore(double score) {
        this.score = score;
    }

    public double getScore() {
        return score;
    }

    public String say(){
        return super.say() + " 身份证="+id+" 分数="+score;
    }
}

多态

多态就是封装和继承的组合应用，难度也是最大的，放到下一篇去讲吧。

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值