java基础阶段总结

最新推荐文章于 2022-07-25 23:57:10 发布
原创 最新推荐文章于 2022-07-25 23:57:10 发布 · 656 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java基础 #对象 #函数

本文详细介绍了Java面向对象编程的基本概念，包括类与对象、继承、抽象类、接口、权限修饰符、重载与重写等核心知识点。通过实例讲解了参数传递、五子棋游戏设计以及权限修饰符的应用。同时，展示了Java在图形用户界面设计、鼠标监听、事件监听、二维数组、队列使用等方面的实践。

1、类与对象基本认识

一类具有共同特征的物体，将其抽象，封装起来就是一个类；对象则是类的具体实例，能具体到某一事物或者个体。eg：创建了一个学生类并通过构造函数（每个类中都将会默认一个无参的构造函数，在创建对象的时候执行该方法，返回该对象在内存中的地址）new了一个中学生对象

public class Student extends Person{
    public static void main(String[] args) {
        Student middleStu = new Student();
    }

2、几个基本概念：

继承（extends）：对于一类事物，eg:定义一个学生类，其所含有的姓名、性别、年龄、学习等属性和方法可以为大学生、中学生、小学生所继承拥有;使用extends关键字可以提高代码的复用率(java中只支持单继承但支持多重继承)
抽象类（abstract）：一个类中又一个方法为抽象方法，那么这个类必须为抽象类;继承抽象类的类在类中必须实现抽象类中的抽象方法；抽象类是不能再创建对象的
接口（interface）：通过implements关键字来实现接口，接口一般不允许有数据成员，但如果真的有，明确默认即为public final static, 严格保证对于所有实现者来说只有一份最为原始的数据。

this关键字:代表当前类的对象，如何寻找该对象？（逆行跟踪：根据this所在的函数去寻找调用该函数的对象）stu被局部申明在main()方法中，study()方法想要修改当前对象其属性则用this关键字

public class Student{
    private String name = "aa";

    public class Student{
        private String name = "aa";
        public static void main(String[] args) {
            Student stu =  new Student();
            stu.study();
        }
        public void study(){
            this.name = "AA";
            System.out.println(name);
        }
    }

3、权限修饰符：public protected default private 访问修饰符作用范围由小到大是：private –> default(本包中) –> protected（本包还有它的子类） –> public

4、Java中的重载（Overloading）是一个类中多态性的表现，具体为一个类中可以创建多个方法，有着相同的方法名，不同的参数类型、个数及返回值类型；使用时通过传递不同的参数值来判断具体所调用的哪个方法。
Java中的重写（Overriding）表现在子类对父类的方法重新定义，与父类中的某一方法具有相同的方法名、参数表及返回值类型，如需调用父类的方法，该使用super关键字（并置于第一行）

public class Person {
     public void life(){
        System.out.println("life");
    }
}
public class Student extends Person{
    public void life(){
        System.out.println("study");
    }
    发生在继承关系中的重写方法是一种多态性的体现

final关键字的应用：若父类Person的life()方法被final关键字所修饰时，子类所重写的life()方法将会出现编译报错， final: 可以修饰类（最终的，不可以被继承；当在设计定义类时，如果该类不需要有子类，类的实现不允许被改变，那么就设计成final类），方法（修饰的方法不可以再被覆盖重写），变量（由final关键字修饰的变量是一个常量，只能被赋值一次）

5、参数传递的两种应用：（①设置构造函数实现参数的传递 ②重建一个方法，传递参数，通过对象调用该类方法来实现）

基本类型和对象作为参数传递都是值传递，对象作为参数传递时，传递的是栈内存中的值，然而栈内存中存放的是堆内存中的地址，即传递的是堆内存中的地址。特别的，String是对char[]的包装，即使String为引用类型，传递的方式同基本类型值传递一样

public class Teacher {
    public void teach(String str){
        System.out.println(str);
        str = "cc";
    }
}
public class Test {
    public static void main(String[] args) {
        Teacher t1 =  new Teacher();
        String str = "aa";
        t1.teach(str);
        System.out.println(str);
    }
输出结果为：
aa
aa
public class Test {
    public static void add(A a){
        a.i++;
    }
    public static void main(String[] args) {
        A a = new A();
        add(a);
        System.out.println(a.i);
    }
}

class A {
    int i = 0;
}

输出结果为：
1
public class Test {
    public static void add(A a){
        a = new A();
        a.i++;
    }
    public static void main(String[] args) {
        A a = new A();
        add(a);
        System.out.println(a.i);
    }
}

class A {
    int i = 0;
}

输出结果为：
0
a = new A();//指向了一个新的object对其进行操作，两个不同的对象，接下来a.i++并不能改变main()方法中的a.i的属性

6、五子棋阶段小结：

用到的知识点：
          图形用户界面的设计   
          参数传递
          鼠标监听、事件监听监听器的添加
          二维数组
          队列中数据的存储
          再一些简单算法的设计

流程设计图

代码实现：（Five_Chess类、Chess_Listener类）

package com.huaxin.five_chess;

import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.ArrayList;

import javax.swing.ImageIcon;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JOptionPane;
import javax.swing.JPanel;

public class Five_Chess extends JFrame {
    public int[][] save_chess = new int[11][11];// 定义一个二维数组记录棋子

    public void initFrame() {
        // 设置窗体标题 大小 默认关闭方式 默认打开位置
        this.setTitle("五子棋");
        this.setSize(600, 500);
        this.setDefaultCloseOperation(3);
        this.setLocationRelativeTo(null);

        // 定义右边面板组件 来承载五子棋所要实现的各个功能分区
        JPanel jp_right = new JPanel();
        jp_right.setPreferredSize(new Dimension(100, 500));// 封装画板功能模块的宽高
        jp_right.setBackground(Color.gray);// 设置画板的背景颜色
        // 将功能画板添加到窗体上
        this.add(jp_right, "East");
        // 放置组件

        JButton jb1 = new JButton("重新开始");
        jb1.setFont(new java.awt.Font("华文行楷", 1, 15));
        jb1.setBackground(Color.LIGHT_GRAY);
        JButton jb2 = new JButton("悔   棋");
        jb2.setPreferredSize(new Dimension(95, 30));
        jb2.setFont(new java.awt.Font("华文行楷", 1, 15));
        jb2.setBackground(Color.LIGHT_GRAY);
        final JButton jb3 = new JButton("退   出");
        jb3.setPreferredSize(new Dimension(95, 30));
        jb3.setFont(new java.awt.Font("华文行楷", 1, 15));
        jb3.setBackground(Color.LIGHT_GRAY);
        final JButton jb4 = new JButton("关   于");
        jb4.setPreferredSize(new Dimension(95, 30));
        jb4.setFont(new java.awt.Font("华文行楷", 1, 15));
        jb4.setBackground(Color.LIGHT_GRAY);
        jp_right.add(jb1);
        jp_right.add(jb2);
        jp_right.add(jb3);
        jp_right.add(jb4);

        // 定义中间面板组件 来承载棋盘，
        final JPanel jp_center = new JPanel() {
            // 通过匿名内部类的方式来实现背景图片以及棋盘的绘制
            @Override
            public void paint(Graphics g) {
                super.paint(g);
                // 首先来绘制背景图片
                ImageIcon image = new ImageIcon("Image/background.jpg");
                g.drawImage(image.getImage(), 0, 0, 485, 480, null);
                g.setColor(Color.black);// 设置画笔的颜色为黑色
                // 下面便开始绘制棋盘(横向，纵向画网格 分别通过for循环来实现)
                for (int i = 0; i < 11; i++) {
                    g.drawLine(40, 40 + 40 * i, 440, 40 + 40 * i);
                }
                for (int i = 0; i < 11; i++) {
                    g.drawLine(40 + 40 * i, 40, 40 + 40 * i, 440);
                }

                // 避免最小化后窗体重置时棋子会消失 将进行棋子的重置
                for (int i = 0; i < save_chess.length; i++) {
                    for (int j = 0; j < save_chess[i].length; j++) {
                        int value = save_chess[i][j];
                        int x2 = 40 + j * 40;
                        int y2 = 40 + i * 40;
                        if (value == 1) {
                            // 绘制白子
                            g.setColor(Color.white);
                            g.fillOval(x2 - 10, y2 - 10, 20, 20);
                        } else if (value == 2) {
                            // 绘制黑子
                            // 绘制白子
                            g.setColor(Color.black);
                            g.fillOval(x2 - 10, y2 - 10, 20, 20);
                        }
                    }
                }
            }
        };
        // jp_center.setBackground(Color.gray);//设置中间画板的背景颜色
        this.add(jp_center, "Center");

        // 必须设置窗体显示可见
        this.setVisible(true);

        // 窗体可见后，通过设置鼠标监听事件来绘制棋子
        // 首先从所要绘制的组件上获得一支画笔
        Graphics g = jp_center.getGraphics();
        // 给画笔设置监听事件 来绘制棋子 并添加监听事件到中间组件上
        final Chess_Listener cl = new Chess_Listener(g, save_chess,jp_center);
        jp_center.addMouseListener(cl);

        // 通过定义事件监听来实现对右边功能按钮的实现
        ActionListener action = new ActionListener() {

            @Override
            public void actionPerformed(ActionEvent e) {
                //得到对应触发当前事件的对象命令
                String command = e.getActionCommand();
                if("重新开始".equals(command)){
                    //把数组的值全部重置为0
                    for(int i=0;i<save_chess.length;i++){
                        for(int j=0;j<save_chess[i].length;j++){
                            save_chess[i][j] = 0;
                        }
                    }
                    //重新把数据棋子重绘到界面上
                    jp_center.repaint();
                }else if("悔   棋".equals(command)){

                    //还原下子颜色到上一步的颜色
                    cl.flag = !cl.flag;
                    //修改最后下子的位置的二维数组值
                    //访问队列，取出最后一次加入的棋子
                    //获取队列大小
                    ArrayList arraLis = cl.list;
                    int size = arraLis.size();
                    Integer inter_j = (Integer)arraLis.remove(size-1);
                    size = arraLis.size();
                    Integer inter_i = (Integer)arraLis.remove(size-1);
                    //解包装，把Integer类型还原成int类型
                    int i = inter_i.intValue();
                    int j = inter_j.intValue();
                    save_chess[i][j] = 0;

                    //重新把数据棋子重绘到界面上
                    jp_center.repaint();

                }else if("退   出".equals(command)){
                    //退出提示  根据用户选择再确定是否退出
                    int ifadd = JOptionPane.showConfirmDialog(null, "确认退出？", "温馨提示", JOptionPane.YES_NO_OPTION);
                    if(ifadd ==  JOptionPane.YES_OPTION){
                        //退出程序
                        System.exit(0);
                    }else if(ifadd == JOptionPane.NO_OPTION){

                    }

                }else if("关   于".equals(command)){
                    JOptionPane.showMessageDialog(jb4, "这是一款休闲游戏\n后续精彩请见下节揭晓");
                }
            }
        };
        jb1.addActionListener(action);
        jb2.addActionListener(action);
        jb3.addActionListener(action);
        jb4.addActionListener(action);

    }
    public static void main(String[] args) {
        // 对象调用显示窗体方法 显示程序
        Five_Chess fc = new Five_Chess();
        fc.initFrame();
    }
}

package com.huaxin.five_chess;

import java.awt.Color;
import java.awt.Graphics;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.util.ArrayList;

import javax.swing.JOptionPane;
import javax.swing.JPanel;

public class Chess_Listener implements MouseListener{
    public Graphics g;
    public int[][] save_chess;
    public boolean flag = true;//true,绘制白字，false绘制黑子
    public JPanel jp_center;
    ArrayList list = new ArrayList();

    public Chess_Listener(Graphics g,int[][] save_chess,JPanel jp_center) {
        this.g = g;
        this.save_chess = save_chess;
        this.jp_center = jp_center;
    }


    @Override
    public void mouseClicked(MouseEvent e) {
        //得到当前鼠标点击的坐标点
        int x1 = e.getX();
        int y1 = e.getY();
        //首先通过对棋盘行和列的遍历来得到坐标点
        for(int i = 0; i < 11;i ++){//遍历行
            for(int j = 0; j < 11; j ++){//遍历列
                int x2 = 40 + j * 40;
                int y2 = 40 + i * 40;
                //下面来判断当前点的坐标是否在遍历点的坐标的范围内  再来绘画棋子
                if(x1 > x2-20 && x1 < x2+20 && y1 > y2-20 && y1 < y2+20){
                    //画下棋子   并考虑棋子的存储问题以及所绘下的棋子黑棋、白棋？  那么就应该有存储
                    if(save_chess[i][j] == 0){//说明该坐标点位置没有棋子绘下，可以进行下子  还得定义一个变量来改变画笔的颜色
                        if(flag){//已经声明为true,则改变画笔颜色来绘制白子
                            g.setColor(Color.white);
                            //所绘下的棋子需要用二维数组来记录  那么 如果是白子则用1来存储,如果是黑子,则用2来存储
                            save_chess[i][j] = 1;
                            flag = false;
                        }else{
                            g.setColor(Color.black);
                            save_chess[i][j] = 2;
                            flag = true;
                        }
                    }
                    g.fillOval(x2-10, y2-10, 20, 20);

                    //存储下点的坐标，并且添加到list队列中
                    Integer inter1 = new Integer(i);
                    Integer inter2 = new Integer(j);
                    list.add(inter1);
                    list.add(inter2);


                    //棋子下完后立马判断其输赢(在鼠标点击事件外边定义横、纵、左斜、右斜方法来判断)
                    boolean result1 = checkRow(i,j);
                    boolean result2 = checkColumn(i,j);
                    boolean result3 = checkLeftXie(i,j);
                    boolean result4 = checkRightXie(i,j);
                    if(result1||result2||result3||result4){
                        //显示一个提示框，是否赢了
                        if(save_chess[i][j]==1){
                            int value = JOptionPane.showConfirmDialog(null, "白子赢了", "输赢提示", 1);
                        }else if(save_chess[i][j]==2){
                            int value = JOptionPane.showConfirmDialog(null, "黑子赢了", "输赢提示", 1);
                        }
                        //玩家赢完棋局后将会立马清空(将数组的值通过全部重置为0)
                        for(int a = 0; a < save_chess.length;a ++){
                            for(int b=0;b<save_chess[a].length;b++){
                                save_chess[a][b] = 0;
                            }
                        }
                        jp_center.repaint();
                    }
                    return;
                }
            }
        }   
    }

    public boolean checkRow(int i,int j){
        int value = save_chess[i][j];
        //先定义一个计数器
        int count = 1;
        //先从左边寻找相同连子个数
        for(int a=j-1;a>=0;a--){
            int left_value = save_chess[i][a];
            if(value==left_value){
                count++;
            }else{
                break;
            }
        }

        //从右边寻找相同连子个数
        for(int a=j+1;a<save_chess[i].length;a++){
            int left_value = save_chess[i][a];
            if(value==left_value){
                count++;
            }else{
                break;
            }
        }

        if(count>=5){
            return true;
        }
        return false;
    }

    public boolean checkColumn(int i,int j){
        int value = save_chess[i][j];
        //先定义一个计数器
        int count = 1;
        //先从上边寻找相同连子个数
        for(int a=i-1;a>=0;a--){
            int up_value = save_chess[a][j];
            if(value==up_value){
                count++;
            }else{
                break;
            }
        }

        //从下边寻找相同连子个数
        for(int a=i+1;a<save_chess[j].length;a++){
            int down_value = save_chess[a][j];
            if(value==down_value){
                count++;
            }else{
                break;
            }
        }

        if(count>=5){
            return true;
        }
        return false;
    }

    public boolean checkLeftXie(int i,int j){
        int value = save_chess[i][j];
        //先定义一个计数器
        int count = 1;

        for(int a=i+1,b=j-1;a<save_chess.length&&b>=0;a++,b--){
            int count_value = save_chess[a][b];
            if(count_value==value){
                count++;
            }else{
                break;
            }
        }

        for(int a=i-1,b=j+1;a>=0&&b<save_chess[a].length;a--,b++){
            int count_value = save_chess[a][b];
            if(count_value==value){
                count++;
            }else{
                break;
            }
        }
        if(count>=5){
            return true;
        }
        return false;
    }

    public boolean checkRightXie(int i,int j){
        int value = save_chess[i][j];
        int count = 1;
        for(int a=i+1,b=j+1;a<save_chess.length&&b<save_chess[a].length;a++,b++){
            int count_value = save_chess[a][b];
            if(count_value==value){
                count++;
            }else{
                break;
            }
        }

        for(int a=i-1,b=j-1;a>=0&&b>=0;a--,b--){
            int count_value = save_chess[a][b];
            if(count_value==value){
                count++;
            }else{
                break;
            }
        }
        if(count>=5){
            return true;
        }
        return false;
    }
    @Override
    public void mousePressed(MouseEvent e) {
    }
    @Override
    public void mouseReleased(MouseEvent e) {
    }
    @Override
    public void mouseEntered(MouseEvent e) {
    }
    @Override
    public void mouseExited(MouseEvent e) {
    }
}
Nickycocola
关注
【Java基础知识 1】Java入门级概述
学Java，找哪吒
09-25 16万+
优快云最强Java专栏，包含全部Java基础知识点、Java8新特性、Java集合、Java多线程、Java代码实例，理论结合实战，实现Java的轻松学习。
Java GC 基础知识快速回顾
最新发布
曾经“等你生日那天”都遥远得像未来，如今却可欢愉的挥手说“下个十年见”
03-02 16万+
本篇文章深入探讨了 Java 垃圾回收（GC）机制的核心概念、工作原理及其对应用性能的影响。我们介绍了垃圾回收的基本概念，包括堆和栈的内存管理、GC 的触发机制、GC 对开发者的重要性等。文章重点分析了常见的垃圾回收算法和回收器，涵盖了分代收集和分区收集策略，以及如何根据应用需求选择合适的回收器。最后，我们还讨论了 GC 的性能调优方法，帮助开发者通过优化内存管理提升应用性能，避免内存泄漏和性能瓶颈。通过本文的学习，读者将能够更好地理解和优化 Java 应用中的垃圾回收机制，确保程序的高效稳定运行。
JAVA基础阶段总结
07-06
总结PPT
Java基础阶段总结
BlueSky_USC的博客
03-09 2136
Java基础阶段总结 今天左哥给我们上了Java基础阶段的最后一次课，宣布正式结束了该阶段的学习，前几天的Java基础阶段的笔试和机试的成绩也出来了，笔试70.5分，机试80分；这成绩也是在我的意料之中；先不说这成绩怎么样，这只是检测这个阶段学得怎么样而已；下面来总结下我在这个阶段的学习历程、经验以及我的一些感受； 其实我很早就和华信结缘了，在我刚转专业过来的不久，华信就举办了
javaWeb阶段总结
11-01
传智播客达摩的终极作品，私人收藏的，对javaWeb整体性的总结。值得收藏，达摩的亲笔作品
Java阶段总结
it_xiaohui的博客
10-29 425
1.Java是什么？Java是一门编程语言或者开发者工具。2.Java的运行原理。3.使用Java编程需要做什么？需要下载JDK(开发者工具包)，并且需要配置配置环境变量，才能进行Java程序的编写。4.Java中类和对象。类是一群对象的特征母版，对象是类的实现。例如:一条狗是一个对象，它的状态有：颜色、名字、品种；行为有：摇尾巴、叫、吃等。再例如男孩和女孩，称之为类，具体的每个人，是这个类的对象。
java阶段总结
qq_38042891的博客
05-06 414
Java基础 1、 简述Java的基本历史 java起源于SUN公司的一个GREEN的项目，其原先目的是：为家用消费电子产品发送一个信息的分布式代码系统，通过发送信息控制电视机、冰箱等   2、 简单写出Java特点，写出5个以上，越多越好 简单的、面向对象的、分布式的、安全的、稳定的、与平台无关的、可解释的、多线的、动态的语言。   3、 什么是Java
精选资源
Java 基础核心总结_.zip
09-08
这份"Java 基础核心总结_.zip"文件显然包含了学习Java编程所必需的重要知识点，旨在帮助初学者或开发者巩固基础。让我们逐一深入探讨这些主题： 1. **Java概述**：Java是一种跨平台、面向对象的编程语言，由Sun ...
Java 阶段总结
Medran的博客
11-11 453
Java 运行原理Java 源代码通过虚拟机编译，再由不同系统的虚拟机翻译到各个系统使用。类和对象类是一群对象的母版，对象是类的实例。数据类型八大基本数据类型（byte,short,int,long,double,float,boolean,char），类类型变量Java 是强数据类型，定义变量的时候就定义类型。运算符+除了可以用作加法，还可以用作拼接，运算优先级用 () 去说明。流程控制三种流程：
java阶段性总结
JetBlack
08-14 495
java学习基础
Java总结（se阶段）
Within的博客
05-02 2128
        Java se是由Sun Microsystems公司于1995年5月推出的Java程序语言设计和java平台的总称。用Java实现的HotJava浏览器（支持Java applet）显示了Java的魅力：跨平台、动态的Web、Internet计算。从此，Java被广泛接受并推动了Web的迅速发展，常用的浏览器现在均支持Java applet。...
学习java的阶段性总结
qq_57469718的博客
09-05 271
this 在Java基础中，this关键字是一个重要的概念，使用this关键字可以完成以下的操作： ·调用类中的属性 ·调用类中的方法或构造方法 - 在一个构造方法中，调用另一个构造方法时，调用的代码 必须编写在构造方法的第一行。 ·表示当前对象 static 概述： static表示“静态”的意思，可以用来修饰乘员变量和成员方法（后续还会学习 静态代码块 和 静态内部类） static的主要作用在于创建独立于具体对象的域变量或者方法 简单...
JavaWeb阶段总结
qq_38961394的博客
09-05 663
HTML 文字排版类标签 标题标签：h1~h6 横线标签：hr 换行标签：br 段落标签：p 图片标签img 属性： src：图片的路径       alt：图片显示不出来的时候，给的文字提示信息       title：鼠标悬浮提示 清单和超链接 清单标签 无序清单：ul 属性type：circle/square/di...
JAVA第一阶段总结
LS1910831673的博客
11-11 2977
JAVA第一阶段总结 一；知识总结      JAVA学习的第一个小的阶段已经学习完了，在第一个阶段中学习了JAVA的语言的介绍，程序的运行环境，JAVA的基本点，变量和常量，基本数据类型，运算符与表达式，控制流程语句中的选择语句、嵌套if语句、循环语句、跳转语句。数组。 一；JAVA的基本点 1；标识符：在程序中一般用来定义常量，变量以及类的名称，它的首字母必须是字母，下划线_，美元符号
华清远见-Java基础阶段总结
m0_59106344的博客
07-25 374
学习Java基础阶段心得
2016年总结-JAVA程序员
小宝鸽
01-08 1万+
技术积累、工作心得、学习方向与职业规划、关于生活
Java基础知识点全面总结笔记
1. Java基础语法 Java的基础语法是进行Java程序开发的基石，包括数据类型、变量、运算符、控制流程、数组、方法、类和对象等方面。其中，数据类型分为基本数据类型和引用数据类型，基本数据类型包括整型、浮点型、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值