JavaSE学习心得——面向对象编程

已于 2022-01-20 16:08:11 修改
阅读量1k 收藏 1
点赞数 2
文章标签： java idea 后端
于 2022-01-03 23:28:11 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43846056/article/details/122268834
版权

写在开头的话

结束了2021年的考研，感慨时光荏苒。考研带给我的不仅仅是基础知识的系统学习，更多的是教会了我如何去自我学习，去思考，也赋予了我今后面对任何事情，只要我想实现它，就不惧困难，一往无前的勇气和毅力。
感谢B站狂神！他算是我Java路上的导师，他的课幽默，但很实用，同时也教会了我很多生活和工作中的经验。我一直很喜欢这种老师（包括考研路上的张宇，刘晓燕，徐涛，腿姐等等），教会你的不仅仅知识，更多的是精神上的共鸣，能够感受到这些老师们的人格魅力，并且潜移默化影响着越来越多人。在寒假我打算再重新系统的学习Java,从JavaSE到分布式，并用博客来记录这一路的收获和心得。
分享很喜欢的一句话：只要满怀希望，就会所向披靡！
2022年1月1日

文章目录

基本Dos命令

打开CMD的方式

1.开始+系统+命令提示符
2.按Win+R 输入cmd（推荐）
在这里插入图片描述

3.在任意的文件夹下面，按住shift键+鼠标右键点击，在此处打开命令窗口
4.资源管理器的地址前面加上cmd路径
在这里插入图片描述

以管理员方式运行：获取最高权限
在这里插入图片描述

常用的Dos命令

1.E:(进入E盘)
2.dir 查看当前盘全部文件
在这里插入图片描述
3.在D盘去F盘下某个文件（QQLive）用/d操作： cd /d F:\QQLive
在这里插入图片描述
4.返回上一级cd…
回到根目录cd\
在这里插入图片描述
5.进去此盘下的某文件夹cd 文件夹名(QQLive)
在这里插入图片描述
6.清理屏幕cls
在这里插入图片描述
7.退出终端exit
在这里插入图片描述
8.查看电脑ip ipconfig
在这里插入图片描述
9.打开计算机calc
在这里插入图片描述
10.打卡画图工具mspaint
在这里插入图片描述
11.打卡记事本notepad
在这里插入图片描述
12.得到网站IP信息 ping （别Ctrl+v，鼠标右键为粘贴）
在这里插入图片描述
13.创建文件夹md
在这里插入图片描述
14.创建文本cd>a.txt
创建文档cd>a.docx
在这里插入图片描述
15.删除文本（文档）del a.docx
在这里插入图片描述
16.删除文件夹rd test
在这里插入图片描述
17.查看端口netstat -ano
在这里插入图片描述

生成JavaDoc

1.用IDEA工具
在这里插入图片描述
2.可以通过DOS命令
在这里插入图片描述

Java帝国的诞生

  • 1972年C诞生

    • 贴近硬件，运作极快，效率很高
    • 操作系统，编译器，数据库，网络系统等
    • 指针和内存管理

  • 1982年C++诞生

    • 面向对象
    • 兼容C
    • 图形领域，游戏等

    反抗

    • 我们需要建立一个新的语言：
      • 语法像C
      • 没有指针
      • 没有内存管理
      • 真正的可移植，编写一次，到处运行
      • 面向对象
      • 类型安全
      • 高质量的内库
      • 。。。。。。

    Java诞生

    • Java初始
      • 1995年的网页简单而粗糙，缺乏互动性
      • 图形界面的程序（Applet）
      • Bill Gates说：这是迄今为止设计的最好的语言！
      • Java 2 标准版（J2SE）：去占领桌面
      • Java 2 移动端（J2ME ：去占领手机
      • Java 2 企业版（J2EE）：去占领服务器
    • Java发展

      • 基于Java开发了巨多的平台，系统，工具

        • 构建工具：Ant，Maven，Jekins
        • 应用服务器：Tomcat，Jetty，weblogic
        • Web开发：Struts，Spring，Hibernate，Mybatis
        • 开发工具：Eclipse，IDEA

      • 2006年：Hadoop（大数据领域）``
        在这里插入图片描述

      • 2008年：Android（手机端）
        在这里插入图片描述

      • 现在：三高架构：在分布式，微服务经常用：高可用，高性能，高并发

Java特性和优势

  • 简单性
  • 面向对象
  • 可移植性
  • 高性能
  • 分布式
  • 动态性：反射
  • 多线程
  • 安全性
  • 健壮性

JDK，JRE，JVM

在这里插入图片描述

Java基础

方法

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

面向过程和面向对象

在这里插入图片描述
在这里插入图片描述

类和对象的创建

类和对象关系

在这里插入图片描述

创建对象内存分析

在这里插入图片描述

总结

  1. 类与对象
    类是一个模板：抽象；对象是一个具体的实例
  2. 方法
    定义，调用
  3. 对应的引用
    引用类型：基本类型（8）
    对象是通过引用来操作的：栈——>堆
  4. 属性：字段Field 成员变量
    默认初始化：
    数字:0 0.0
    char : u0o00
    booLean:false
    引用: null
    修饰符 属性类型 属性名=属性值!
  5. 对象的创建和使用
    必须使用new关键字创造对象，构造器
    （Person kuangshen = new Person()；）
    对象的属性kuangshen.name
    对象的方法kuangshen.sleep()
  6. 类
    静态的属性：属性
    动态的行为：方法

构造器

构造器一般用来赋初值
在这里插入图片描述

无参构造器

package learn;
//定义一个Person类
public class Person {
   String name;
}


package learn;

public class way {
    public static void main(String[] args) {
        Person zs = new Person();//new一个张三对象后，默认调用无参构造器，无参构造器初始让name值为NULL
        System.out.println(zs.name);
    }

}

在这里插入图片描述
有参构造器

小技巧，快捷键生成构造器：alt+inset
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

封装

  1. 该露的露，该藏的藏
    我们程序设计要追==“高内聚，低耦合”==，高内聚就是类的内部数据操作细节自己完成，不允许外部干涉；低耦合：仅暴露少量的方法给外部使用。
  2. 封装（数据的隐藏）
    通常，应该禁止直接访问一个对象中的数据的实际表示，而应该通过操作接口来访问，这称为信息隐藏。
  3. 记住这句话：属性私有， get/set
  4. 小技巧：alt+insert
    在这里插入图片描述
package learn;

public class Student {
    //属性私有,只能通过get/set方法进行调用
    private String name;
    private int id;
    private char sex;
    private int age;

    //提供Public的get，set方法
    //get 获得这个数据,set给这个数据设置
    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 char getSex() {
        return sex;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if (age>0&&age<120){
            this.age=age;
        }else
          this.age=3;//三岁小孩
    }
}


package learn;

public class way {
    public static void main(String[] args) {
       Student LiMing=new Student();
       LiMing.setAge(-1);
        System.out.println(LiMing.getAge());
    }

}

在这里插入图片描述
封装的意义

  1. 提高程序的安全性，保护数据
  2. 隐藏代码的实现细节
  3. 统一接口
  4. 系统可维护性增加了

继承

在这里插入图片描述

package learn;
//定义一个父类
public class Father {

    //public
    //protected
    //default
    //private，子类不能直接继承
    public String house="别墅";
    private int monkey=10_0000_0000;
    public void say(){
        System.out.println("说了一句话");
    }
}


package learn;


//子类继承父类，就继承了父类全部的方法和除private的属性
public class Son extends Father{

}


package learn;

public class way {
    public static void main(String[] args) {
        Son son = new Son();
        son.say();
        System.out.println(son.house);
        System.out.println(son.monkey);//爆红，不能继承
    }

}

那private怎么用？——那，就封装的思想！回见封装
小技巧，按Ctrl+H，可以看见继承树
在这里插入图片描述

super——父类，this——自己

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述在这里插入图片描述
重难点来了
前面说了，在子类里的无参构造器会默认先执行隐藏代码super();,但是如果父类没有无参构造器，只有有参构造器时，会怎么样？——爆红
在这里插入图片描述
在这里插入图片描述
那怎么解决？
手动调用父类有参
在这里插入图片描述
综上总结

  • super注意点：

    • super调用父类的构造方法，必须在构造方法的第一个
    • super必须只能出现在子类的方法或者构造方法中！
    • super和this不能同时调用构造方法！

  • this注意点：

    • 代表的对象不同
      • this：本身调用这个对象
      • super代表父类对象的应用
    • 前提
      • this：没有继承也可以使用
      • super：只能在继承条件下才可以使用
    • 构造方法
      • this（）；本类的构造
      • super（ ）；父类的构造；

    方法的重写

    先看两个小栗子

    • 方法加了static
package learn;
//定义一个父类类
public class Father {

    public static void test(){
        System.out.println("B=>>");
    }

}


package learn;


//子类继承父类，就继承了父类全部的方法
public class Son extends Father{

    public static void test(){
        System.out.println("A==>");
    }

}


package learn;

public class way {
    public static void main(String[] args) {
        Son son = new Son();

        //子类可以指向父类，或者说父类的引用指向了子类
        Father father=new Son();
        son.test();
        father.test();
    }

}

在这里插入图片描述

  1. 不加static ，可以明显看到父类多了向下的图标，子类多了向上的图标，这就是重写的标识
    在这里插入图片描述
    小技巧，alt+insert可以快速生成重写，有@override注解
    在这里插入图片描述
    总结
  • 重写:需要有继承关系，子类重写父类的方法!
    1.方法名必须相同
    2.参数列表列表必须相同
    3．修饰符:范围可以扩大但不能缩小:public>Protected>Default>private
    4．抛出的异常:范围，可以被缩小，但不能扩大; ClassNotFoundException --> Exception(大)
  • 重写，子类的方法和父类必要一致;方法体不同!
  • 为什么需要重写：父类的功能，子类不一定需要，或者不一定满足!

多态

在这里插入图片描述

先看小栗子

  • son继承了全部父类的方法
    在这里插入图片描述
  • 子类进行了重写，father和son对象的test方法就都按子类重写的方法了
    在这里插入图片描述
  • 父类不能调用子类独有的，除非强制转换
package learn;
//定义一个父类类
public class Father {

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

}


package learn;


//子类继承父类，就继承了父类全部的方法
public class Son extends Father{

    @Override
    public void test() {
        System.out.println("Son");
    }

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


package learn;

public class way {
    public static void main(String[] args) {
       //一个对象的实际类型是确定的
        //new Son();
        //new Father();

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

        //Son能调用的方法都是自己的或者是继承的父类的
        Son son = new Son();
        //Father父类，可以指向子类，但是不能调用子类独有的方法
        Father father=new Son();
        Object object=new Son();

        son.test();
        father.test();
        father.eat();//((Son) father).eat();强制转换


    }

}

总结
多态注意事项:

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

不能重写的情况

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

instanceof和类型转换

instanceof

画继承走向，只能父转子

package learn;
//定义一个父类类
public class Father {

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

}


package learn;


//子类继承父类，就继承了父类全部的方法
public class Son extends Father{

    @Override
    public void test() {
        System.out.println("Son");
    }

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


package learn;

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

        //Object>String
        //Object>Father>Son
        //Object>Father>Daughter

        Object object=new Son();
        System.out.println(object instanceof Son);//true
        System.out.println(object instanceof daughter);//false
        System.out.println(object instanceof Father);//true
        System.out.println(object instanceof String);//false
        System.out.println(object instanceof Object);//true
        System.out.println("==========================================");
        Father father=new Son();
        System.out.println(father instanceof Son);//true
        System.out.println(father instanceof daughter);//false
        //System.out.println(father instanceof String);直接而编译失败，因为Father类可以String没有关系
        //System.out.println(false instanceof Object);编译失败，不能子类转父类
        System.out.println("==========================================");
        Son son=new Son();
        //System.out.println(son instanceof daughter);两个子类之间没有关系，编译失败




    }

}

在这里插入图片描述

类型转换

在这里插入图片描述

Static详解（必看）

static跟类一起加载

属性

在这里插入图片描述
在这里插入图片描述

方法

  • 在这里插入图片描述
    在这里插入图片描述

代码块

package learn;

//static
public class Application {

    //赋值用，跟对象同时产生
    {
        System.out.println("匿名代码块");
    }

    //同类一起，只执行一次
    static {
        System.out.println("静态代码块");
    }

    public Application() {
        System.out.println("无参构造器");
    }

    public static void main(String[] args) {
        Application application=new Application();
    }
}

在这里插入图片描述
总结

  • 静态代码块（static）跟类一起，只执行一次
  • 匿名代码块同创建的对象一起执行
  • 代码块比构造器优先级高

静态导入

在这里插入图片描述

抽象类

在这里插入图片描述
在这里插入图片描述

接口

抽象MAx——只写需要进行的操作就行了

package learn;

//interface 定义关键字
public interface MyAction {
    //接口中的所有的定义其实都是抽象的 public abstract
    void add(String name);
    void delete(String name);
    void update(String name);
    void query(String name);

}


package learn;

public interface YourAction {
    void eat();
}

去实现多个接口

package learn;

public class MyActionImpl implements MyAction,YourAction{
    @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 eat() {

    }
}

N种内部类

局部内部类/内部类

package learn;

public class Outer {
    private int id=10;
    public void out(){
        System.out.println("这是外部类的方法");
        //局部内部类
         class Inner3{
             public void in(){
                 System.out.println("这是内部类的方法3");
             }
        }
    }

    //内部类
    public class Inner1{
        public void in(){
            System.out.println("这是内部类的方法1");
        }
        public void getId() {
            System.out.println(id);
        }
        public void getout() {
          out();
        }

    }
}
//一个Java类中可以有多个Class类，但是只能有一个public class
//内部类
class Inner2{
    public void in(){
        System.out.println("这是内部类的方法2");
    }

}



package learn;

//静态导入包

public class Application {
    public static void main(String[] args) {
      Outer outer= new Outer();
      outer.out();
      Outer.Inner1 inner1=outer.new Inner1();
      inner1.getId();//获得到了外部类的私有属性
      inner1.in();
      inner1.getout();

    }

}

在这里插入图片描述

匿名内部类

package learn;

//静态导入包

public class Application {
    public static void main(String[] args) {
        //没有名字初始化类，不用将实例保存到变量中~
        new Apple().eat();//匿名内部类，直接调用方法
        new UserService() {//可以直接new一个接口

            @Override
            public void add() {

            }
        };
    }

}

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

interface UserService {
    void add();
}

异常机制

常见异常

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

捕获和抛出异常

在这里插入图片描述
小技巧，Ctrl+alt+T，生成环绕代码块
Ctrl+D，直接复制当前光标所在行
在这里插入图片描述
当去捕获和处理异常后，代码可以继续运行，区别于不加，代码直接终止

package learn;

public class test {
    public static void main(String[] args) {
        int a = 1;
        int b = 0;
        try {
            System.out.println(a / b);
        } catch (Exception e) {
            System.out.println("Exception");
        } catch (Error e) {
            System.out.println("Error");
        } catch (Throwable e) {
            System.out.println("Throwable");
        } finally {
            System.out.println("finally");
        }

        try {
            new test().a();
        } catch (Exception e) {
            System.out.println("Exception");
        } catch (Error e) {
            System.out.println("Error");
        } catch (Throwable e) {
            System.out.println("Throwable");
        } finally {
            System.out.println("finally");
        }


    }


    public void a() {
        b();
    }

    public void b() {
        a();
    }
}

在这里插入图片描述

主动去抛出

在这里插入图片描述

自定义异常，用于处理问题的的解决方法

在这里插入图片描述
在这里插入图片描述

package learn;

//自定义异常类
public class MyException extends Exception{

    //若传递参数>10
    private int detail;

    public MyException(int detail) {
        this.detail = detail;
    }

    //toString,打印出来

    @Override
    public String toString() {
        return "MyException{" +
                "detail=" + detail +
                '}';
    }
}


package learn;

public class test {

    //可能会存在异常的方法
    public static void test(int a) throws MyException {//抛出异常
        System.out.println("传递的参数为"+a);
        if (a>10){
            throw new MyException(a);
        }
    }


    public static void main(String[] args) {
        try {
            test(11);
        } catch (MyException e) {//捕获异常
            System.out.println("MyException=>"+e);
            e.printStackTrace();

        }
    }

}

思维导图

在这里插入图片描述

至南岸
关注
编程精华资源（ITeye优秀专栏）大汇总
一万年太久 - 只争朝夕
06-12 2051
博客是记录学习历程、分享经验的最佳平台，多年以来，各路技术大牛在ITeye网站上产生了大量优质的技术文章，并将系列文章集结成专栏，以便读者能够更便捷、更系统地浏览学习，这些可称之为“编程精华资源”。 为了便于读者更好地查阅，本文将ITeye中的这些精华资源进行了整理分类，你可以通过文中链接跳转到相应的专栏，希望技术大牛们的这些不可多得的经验分享，能够为你的技术学习、开发之路带来一些帮助。
java 聊天室系统实训总结_关于JAVA聊天室编写的总结
weixin_31954813的博客
02-24 2341
在编写JAVA聊天室的过程中，让我学到了很多东西，有知识方面的，而更多的是经验。从以前学习C，到现学习JAVA，有很多的地方不习惯。主要的就是思想不会转变。但是还是有很多相似的地方，比如，如何实现心中所想的东西时，很多函数的编写的方法是类似的，而不同的是JAVA多了继承、多态、封装等等面向对象的东西。所以在整体构思方面差异比较大，但是细节方面还是类似的。编写聊天室让我对面向对象的了解算是更进一步了...
完成Java面向对象程序设计实验课的心得体会
07-02
经过这几周对Java面向对象程序设计的学习，让我更加了解到Java学习的重要性，以及Java对我们专业的发展发挥的作用。在上个学期我们也学习了Java语言程序设计基础，在此基础之上学习起来就方便了一些，做其实验来也会比较适应，能很快的进入状态
面向对象编程及开发经验
weixin_54572521的博客
03-02 152
面向对象编程及开发经验面向对象编程及开发经验 面向对象编程及开发经验 什么是面向对象？ 说起面向对象，很多人一开始便使用大象 ， 人等方式去介绍什么是面向对象。我们先不要搞清楚什么是面向对象，先学会什么是面向对象编程。 先建造一制造完成功能的工厂-》工厂在批量生产这种类型的工具，完成相应功能 ES5 和ES6 的两种方式 // ES5 -->模块 ;(function () { // 创建一个独立空间 -》工厂 var Calculator = function() {
面向对象编程心得
极品小肥羊的博客
07-15 849
1、类之间的关系可以分为：关联、聚集、包容、继承。它们都是用来模拟现实生活中各个对象之间的关系的。 2、包容：即一个对象由另一个对象所专有。前者我们可以用内部类来模拟。 3、对于某些可能发生的运行时异常，比如：因找不到url所对应的文件而不知道返回什么等等情况，我们应该对 涉及到的方法（可能抛出异常） 或者是 用到的可能导致异常抛出的数据域   通过方法形式的封装来进行封装，并try-
Java面向对象思想
a706653042038694的博客
11-30 150
1、面向对象思想： (1)概述：面向对象是相对于面向过程而言的，面向过程强调的是功能，面向对象强调的是将功能封装进对象， 强调具备功能的对象； (2)思想特点： A:是符合人们思考习惯的一种思想； B:将复杂的事情简单化了； C:将程序员从执行者变成了指挥者； 2、类和对象： 类：对现实世界中某类事物的描述,是抽象的，概念上的定义。 对象：事物具体存在的...
面对对象编程的学习心得1：包
wah369的博客
10-25 130
先了解一下基本知识： 1，包（package）：包是组织类的一种方式，使用包的目的是保证类的唯一性。 简单举例：使用包就可以创建多个TestDemo 怎么创建呢？ src -> new ->Package 此时输入包名，然后右键包名，新建一个类，输入类名就行了。 2，导入包中的类： 在IDEA中，有时候在写代码的时候可以直接调用系统包，调用后可以鼠标放在调用的包上，按住Ctrl鼠标左键点击，可以进去看源代码，按住Alt+7，左侧会出现源码所有的方法。 常见的系统包： 1. j.
普通大一学生的自我反思（csdn）————程序.pdf
12-05
这个学生的经历展示了自我驱动和毅力在编程学习中的重要性，他通过不断实践和反思来提升技能，这为其他初学者提供了宝贵的启示，即学习编程需要耐心和持续的努力，而不仅仅是掌握语言本身，还需要广泛了解计算机科学...
怎样正确的度过JavaSE阶段真的很重要！（详细知识内容+资料）
热门推荐
奈何的人生
03-22 2万+
不要小看JavaSE的这些基础章节，打好基础很重要！巧了，我这里涵盖了所有Java基础！
100天进阶Java架构师：全网最强学习路线
一、JavaSE部分涵盖了Java的基础知识，包括环境变量配置、面向对象编程、数据类型、运算符、字符串、输入输出等。这部分是Java编程的基础，对于初学者至关重要。Java基础的学习应注重理解语法特性，掌握基本的编程...
JAVA面向对象学习心得
a18786923310的博客
07-25 1892
java面向对象的知识归纳，包括（继承、封装、多态）等面向对象的特性的总结。
java面向对象程序设计总结
New_gamer9的博客
04-17 2425
系统学习面向对象语言设计，java是一门完全面向对象设计性语言，就连最基本的基本类型java自身也都包装了相应的类型与方法，那么什么是类，什么是对象，通俗点说 类就是对象的模板，就像工厂里面的模子，机器比对一种模板制作了一件物品，那么那件物品就是这个模子(类)，对应的一个对象，它有自己的属性以及自己的方法。说到一个类不可不说的就是他的方法，与属性，所谓属性就是类里面的一些变量或常量，而方法就是对
面向对象编程，自我总结(二)
weixin_45389051的博客
04-12 150
这一篇就说一下类中添加方法 首先说一下两个注意点: - 类里面所有的函数不需要写function - 类里面函数，不能逗号分隔 下面举例子 class Person{ constructor(user,age){ this.user = user this.age = age } person(one){ console.log(...
面向对象编程总结
hertioy的博客
10-05 276
1.面向对象编程的三大特性 a.封装（代码模块化）：将对象的属性和方法隐藏起来，仅对外公开接口部分。其中函数和数据都是类的成员。 b.继承（代码复用性）：继承是类与类的关系，同现实世界的继承一样。被继承的类称为父类或基类，继承的类称为子类或派生类。派生类可以拥有基类的成员函数和成员数据，也可以自己定义新的数据成员。 继承的特性为：派生类可以赋值给基类；基类不可以赋值给派生类 基类的指针引用可以指向...
【JAVA】面向对象编程总结
qq_45239139的博客
10-20 330
1.面向对象程序设计的概述 要了解面向对象编程（Object-oriented Programming，OOP），那我们也要大概了解一下面向过程（Process-oriented Programming） 面向过程： 面向过程的结构化开发语言适合早期的“作坊式”开发，但是随着软件规模的扩大，这种开发方式的弊端也逐渐显示出来，对于一些规模较小的问题，将其分解为过程的开发方式比较理想和简单的能完成程序...
JavaSE总结——Java面向对象程序设计
剑来
01-11 1164
参考资料 Java开发实战经典_百度百科 知识梳理： 1、基础语句 三个方向——运行机制——命名——选择与循环——数组——方法递归 2、面向对象 面向对象——string——this、static、final与super——代码块——单例模式——内部类——继承、覆写、重载、覆盖 3.面向对象高级 抽象类与接口——多态——异常处理机制——exception与err—...
JavaSE个人学习心得(六)
liuxians的博客
12-09 338
JavaSE个人学习心得(六) 数组 一维数组 数组是一种容器,可以存储多个,同种类型的元素 定义格式： 1. 数据类型[] 数组名; 2. 数据类型 数组名[]; 注意: 这种定义格式, 只是定义出了数组类型的变量, 容器还没有创建出来, 数据也没有存进去 格式化 静态格式化 完整格式: 数据类型[] 数组名 = new 数据类型[]{元素1, 元素2, 元素3...}; 简化格式: 数据类型[] 数组名 = {元素1, 元素2, 元素3...}; 动态格式化 在初始化的时候,
JavaSE个人学习心得(七)
liuxians的博客
12-09 83
JavaSE个人学习心得(七) 方法 一段具有独立功能的代码块, 不调用就不执行. 提高了代码的可阅读性以及复用性 方法的定义和调用格式 定义格式: public static 返回值类型 方法名(参数列表){ 方法体; return 返回值; } public static : 修饰符, 目前来说暂时记住 返回值类型: 跟return返回的结果有关 方法名: 自己给方法起的名字, 小驼峰命名法 参数列表: 方法运行之前所需要的材料 方法体: 方法中所维护的逻辑代码 return : 1. 用于结束方法
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

至南岸

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值