自学Java如何入门？

Posted 2023-04-11

自学Java看这一篇就够啦！Java学习路线图分享给你，跟着学习吧！

一、Java基础

JavaSE基础是Java中级程序员的起点，是帮助你从小白到懂得编程的必经之路。

在Java基础板块中有6个子模块的学习：

基础语法，可帮助你建立基本的编程逻辑思维；

面向对象，以对象方式去编写优美的Java程序；

集合，后期开发中存储数据必备技术；

IO，对磁盘文件进行读取和写入基础操作；

多线程与并发，提高程序效率；

异常，编写代码逻辑更加健全；

网络编程，应用服务器学习基础，完成数据的远程传输。

学习该阶段，可以完成一些简单的管理系统、坦克大战游戏、QQ通信等。

二、数据库

数据库不仅仅是Java开发工程师的必学课程，也是其他语言都需要掌握的技能。用于对交互过程中客户的数据进行存储。

该板块包括关系型数据库和非关系型数据库。

例如：mysql、oracle、redis、MongoDB等。数据库学习完毕后，可以将数据存储到数据库中，也可以通过SQL语句从数据库中查询数据，结合Java项目可以实现动态站点的数据的保存。

技术树



三、前端技术

Javaweb阶段包括前端、数据库和动态网页。Javaweb是互联网项目的入门课程，是学习后面高进阶课程的基础。

首先，我们先看一下前端板块。该板块主要包括如下几个模块：

html5，网页制作标记语言；

CSS，对HTML制作网页进行美化；

javascript，嵌入在页面中的脚本语言，具备逻辑性；

Vue，前端框架，简化了与服务器端交互的操作，用户良好的交互体验是必不可少的。

学习前端技术后，可以完成类似京东、淘宝的前端工程的编写。

技术树



四、动态网页技术

动态网页是中级程序员服务器端编程的基础，是高级框架学习的必备课程，后期学习的框架、服务底层都是基于动态网页技术之上的。

该板块包括Javaweb核心技术、包括Servlet、Request、Response、Cookie和Session等，通过这些技术的学习可以完成动态站点开发，可更好的完成服务器端与客户的交互，让页面的数据“动”起来，做出小型的应用系统。

技术树



五、编程强化

编程强化是对解决实际问题方面做一个深入的了解和应用，是对JavaSE基础的加强，对后期自动以框架和对一些服务框架的底层理解做支撑。

编程强化板块主要包括如下几个模块：多线程高级、涉及线程内存、线程通信等；JVM优化，对JVM底层进行调优来提高项目执行效率；NIO，同步非阻塞IO来提高效率。

学习该阶段，可以对原有项目进行优化从而使程序更快更稳定。

技术树




六、软件项目管理

JavaSE基础是Java中级程序员的起点，是帮助你从小白到懂得编程的必经之路。

在Java基础板块中有6个子模块的学习：基础语法，可帮助你建立基本的编程逻辑思维；面向对象，以对象方式去编写优美的Java程序；集合，后期开发中存储数据必备技术；IO，对磁盘文件进行读取和写入基础操作；多线程与并发，提高程序效率；异常，编写代码逻辑更加健全；网络编程，应用服务器学习基础，完成数据的远程传输。

学习该阶段，可以完成一些简单的管理系统、坦克大战游戏、QQ通信等。

技术树



七、热门技术框架

使用Javaweb进行企业级开发是完全可以的，但是开发效率比较低，所以对常用的逻辑操作进行封装就形成了框架，因此框架是企业开发的入门技能。

热门框架板块主流框架有如下几个：Spring框架，占据统治地位，其生态系统涉及各个方面解决方案；MyBatis框架，使用ORM思想对数据库进行操作。

该板块学习后，就可以进行真实企业级项目开发了，做出的项目也会更加符合企业要求。

技术树



八、分布式架构方案

随着互联网的发展，业务的复杂性和用户的体验性都需要提高，所以分布式架构出现了。该板块主要讲解的是分布式架构的相关解决方案。

主要包括如下模块：Dubbo，高性能的 RPC 服务发布和调用框架；SpringBoot，简化Spring应用的初始搭建以及开发过程；Spring Cloud，一系列框架的有序集合，如服务发现注册、配置中心、负载均衡、断路器、数据监控等。

该板块的学习，可以具备大型互联网项目开发的必备技术和实际经验，为进入BATJ打下基础

技术树



九、服务器中间件

中间件板块是大型互联网项目中必备的。服务中间件可以帮助各子模块间实现互相访问，消息共享或统一访问等功能。其包括远程服务框架中间件，例如阿里（Apache）的RPC框架Dubbo等；消息队列中间件，例如：阿里巴巴开源分布式中间件RocketMQ、高吞吐量消息发布和流处理服务Kafka等。

学习服务中间件是中级JavaEE工程师必要技术，也是JavaEE架构师必须精通的技术。

技术树




十、服务器技术

不管是使用原生Javaweb进行开发，还是使用框架进行开发，项目最终需要对外发布才能供全世界的人访问到，而服务器板块就可以解决这个问题，所以服务器是项目发布的必要技术。该板块包括虚拟化和web应用服务器的学习，主要包括如下几个模块：Vmware，虚拟机软件；Linux，专门用于服务器的系统；nginx，集群部署时反向代理服务器；Tomcat，项目发布时主要使用的服务器。

该板块学习后，我们就可以把开发好的项目发布到服务器中，然后供你的小伙伴远程访问了，超酷！

技术树



十一、容器技术

容器化技术是近两年超级火的一个专题，通过容器化技术可以对环境进行打包，方便移植，大大提高了开发效率。该板块包括容器化技术Docker和其平台管理引擎Kubernetes，其中，Docker 是一个开源的应用容器引擎，可以打包应用以及依赖包到一个可移植的镜像中，然后发布到任何流行的Linux或Windows 机器上，也可以实现虚拟化。而Kubernetes是一个开源的，用于管理云平台中多个主机上的容器化的应用，Kubernetes的目标是让部署容器化的应用简单并且高效。通过该板块的学习，你可以通过上述技术快速搭建环境，节省开发时间，提高开发效率。

技术树




十二、业务解决方案

虽然我们已经具备了基础技术和高阶技术，但是要想与企业开发相接轨，还需要对实际项目的业务解决方案进行探究。而此版块就是在实际业务场景中的真实解决方案集合，常用的业务解决方案有如下：搜索业务场景解决方案、日志收集与分析场景解决方案、工作流引擎场景解决方案、任务调度场景解决方案、地图开发平台场景解决方案、支付开放平台场景解决方案、图表可视化场景解决方案。通过分析实际业务来学习这个解决方案技术集，完全可以达到中级甚至高级工程师水平。

技术树

参考技术A 可以先搜索java相关工具的使用，然后再进行java的基础学习，java学习的内容很多，大致可以分为以下几个阶段进行学习！！！
一、预科学习：
HTML5：HTML5标签入门、HTML5表格、表单
CSS3：CSS3选择器和简单属性、CSS3定位和布局、CSS3复杂选择器和高级属性
数据库：mysql数据库安装和数据操作、约束和简单查询、复杂查询、数据库设计、oracle的安装与数据操作、oracle与mysql的对比学习

二、JavaSE
Java语言基础、程序逻辑：环境配置和第一个语言程序-HelloWorld 变量运算符 条件和循环 方法和数组
Java面向对象：面向对象入门 面向对象应用_管理系统类 Java常用类、String相关、算法相关 面向对象深入（重载、this、static ）继承（重写、super、初始化顺序） 多态（抽象类和接口、final、克隆和比较接口 设计模式、对象和类的生命周期）
API：异常、日志 集合 集合工具类和泛型 IO JDBC基础线程 网络编程 反射 NIO Junit
Java面向对象思想：设计模式 面向对象原则
Java底层理论：集合底层 性能监控工具 反编 JUC

三、Java web
web基础：TOMCAT/WEB程序结构/HTTP协议 Servlet基础入门、servlet作用域（cookie、session、ServletContext）、 Cookie和Session 、Servlet的交互/JSP原理及运用、 JavaBean/EL/JSTL/MVC思想 、JSP+Servlet+JDBC综合练习、Session购物车案例/验证码/防止表单重复提交、监听器过滤器
第三方工具包：连接池、事务、分页、文件上传下载、Dom4j/Log4j/Log back
JavaScript和jQuery框架技术：JS入门和DOM基础 、DOM模型深入 、jQ基础、 jQ操作DOM
MVC动态Web开发技术：自定义MVC框架、DAO框架、前端框架（layUI）
Web开发高级运用：tomcat server服务器配置 、nginx使用、 jetty配置
网络编程：网络原理、HTTP协议基础、Linux操作系统、云服务搭建

四、SSM框架
Spring框架、SpringMVC框架、MyBatis框架：mybatis入门、 配置文件详解和动态sql的使用、 mybatis管理关系映射和延迟加载、 查询缓存和逆向工程 、Spring入门和集成、myBatis SpringMVC入门 、SSM集成、 Spring配置详解 、Spring AOP、 Spring事务配置 、SpringMVC高级功能 、SpringMVC原理

五、前沿技术
高可用、高并发、高扩展：Spring Boot 、缓存 、分布式 、全文索引、 服务中间件、 myCat、 云服务 、人脸识别 、语言识别 、JVM底层+优化 参考技术B

零基础学习Java该从何学起?很多刚开始学习Java的人都没有一个正确的学习方向，以至于在学习过程中走了很多弯路今天小编就来给大家规划规划Java学习路线。

如果是英语不好的零基础人员，那么学Java需要从英语开始学习，不过只需要把常用的编程语句背熟就行，不需要把英语学的很好。常用的编程语句都记住，后期自己做项目就会简单一些。

学好英语后或者英语本身就不错的人则先开始学Java基础部分。Java基础知识主要包含：基础语法、核心类库、面向对象编程、异常、集合、IO流等知识。基础知识的学习很重要，大家要重视起来，因为基础学不好后期学框架也很难学懂。

基础知识学好后你需要学习Java框架，虽然Java框架很多但是你只需要学习热门的几个框架就可以了，因为目前企业中基本也只会用到热门框架，其他的框架可以边工作边学习。主要是通过学习Spring、SpringMVC、Spring
Boot、Spring Could这些当前热门框架，从而熟练掌握企业实际开发中需要的核心技能。

基础知识和框架学完后就需要学习Java流行技术了，这也是为了接下来找工作做铺垫。目前比较流行的Java技术有JavaScript、jQuery脚本语言和异步交互技术AJAX等，学会这些技术你就可以自己开发网页了。

以上就是Java的学习路线。当然在学习过程中也不要忘记自己找些项目练手，一是因为如果找工作的话需要有项目经验，一是因为项目实战可以帮助你发现自己哪里学的不好，好及时改正。

参考技术C 这里为你整理了一份关于Java全栈开发的学习路线与知识点，希望可以帮助到你：
第一阶段：Java专业基础课程

阶段目标：
1. 熟练掌握Java的开发环境与编程核心知识
2. 熟练运用Java面向对象知识进行程序开发
3. 对Java的核心对象和组件有深入理解
4. 熟练应用JavaAPI相关知识
5. 熟练应用JAVA多线程技术
6. 能综合运用所学知识完成一个项目

知识点：
1、基本数据类型，运算符，数组，掌握基本数据类型转换，运算符，流程控制。
2、数组，排序算法，Java常用API，类和对象，了解类与对象，熟悉常用API。
3、面向对象特性，集合框架，熟悉面向对象三大特性，熟练使用集合框架。
4、IO流，多线程。
5、网络协议，线程运用。

第二阶段：JavaWEB核心课程

阶段目标:
1. 熟练掌握数据库和MySQL核心技术
2. 深入理解JDBC与DAO数据库操作
3. 熟练运用JSP及Servlet技术完成网站后台开发
4. 深入理解缓存，连接池，注解，反射，泛型等知识
5. 能够运用所学知识完成自定义框架

知识点：
1、数据库知识，范式，MySQL配置，命令，建库建表，数据的增删改查，约束，视图，存储过程，函数，触发器，事务，游标，建模工具。
2、深入理解数据库管理系统通用知识及MySQL数据库的使用与管理。为Java后台开发打下坚实基础。Web页面元素，布局，CSS样式，盒模型，JavaScript，jQuery。
3、掌握前端开发技术，掌握jQuery。
4、Servlet，EL表达式，会话跟踪技术，过滤器，FreeMarker。
5、掌握Servlet相关技术，利用Servlet，JSP相关应用技术和DAO完成B/S架构下的应用开发。
6、泛型，反射，注解。
7、掌握JAVA高级应用，利用泛型，注解，枚举完成自己的CRUD框架开发为后续框架学习做铺垫。
8、单点登录，支付功能，项目整合，分页封装熟练运用JSP及Servlet核心知识完成项目实战。

第三阶段：JavaEE框架课程

阶段目标：
1. 熟练运用Linux操作系统常见命令及完成环境部署和Nginx服务器的配置
2. 熟练运用JavaEE三大核心框架：Spring,SpringMVC,MyBatis
3. 熟练运用Maven,并使用SpringBoot进行快速框架搭建
4. 深入理解框架的实现原理，Java底层技术，企业级应用等
5. 使用Shiro,Ztree和Spring,SpringMVC,Mybaits完成企业项目

知识点：
1、Linux安装配置，文件目录操作，VI命令，管理，用户与权限，环境部署，Struts2概述，hiberante概述。
2、Linux作为一个主流的服务器操作系统，是每一个开发工程师必须掌握的重点技术，并且能够熟练运用。
3、SSH的整合,MyBatis,SpringMVC,Maven的使用。
4、了解AOP原理，了解中央控制器原理，掌握MyBatis框架，掌握SSM框架的整合。
5、Shiro,Ztree，项目文档，项目规范，需求分析，原型图设计，数据库设计，工程构建，需求评审，配置管理，BUG修复，项目管理等。
6、独立自主完成一个中小型的企业级综合项目的设计和整体架构的原型和建模。独立自主完成一个大型的企业级综合项目，并具备商业价值。

第四阶段：分布式与微服务课程

阶段目标：
1.掌握前端框架VUE及Bootstrap的应用开发
2.基于SpringCloud完成微服务架构项目的开发
3.掌握NoSQL数据库Redis的使用
4.掌握消息队列RabbitMQ的使用
5.掌握Mycat数据库中间件的使用

知识点：
1、Bootstrap前端框架、VUE前端框架、RabbitMQ消息队列。
2、掌握Bootstrap前端框架开发、掌握VUE前端框架开发、掌握RabbitMQ消息队列的应用、掌握SpringBoot集成RabbitMQ。
3、Redis缓存数据库的应用、Java基于Redis的应用开发、基于SpringCloud微服务架构开发实战。
4、掌握NOSQL数据库Redis的安装、使用，Redis客户端的安装使用，Java访问操作Redis数据库，Redis的持久化方案、主从复制、高可用。
5、掌握SpringCloud微服务架构的开发，注册中心，网关配置，配置中心，微服务间通信及容器化部署。
6、项目文档，项目规范，需求分析，数据库设计，工程构建，需求评审，配置管理，BUG修复，项目管理等。
7、掌握数据库中间件Mycat的应用，基于Mycat实现数据读写分离，高可用集群。
8、掌握项目开发的流程，按照项目开发流程完成基于微服务架构项目的需求分析，编码开发。 参考技术D

对于每一位才开始接触JAVA的新手来说，先不要管算法和数据结构，大多数简单的程序不需要用到算法和数据结构，所以当你真正需要时再去学习。编程一段时间以后，你就会知道在哪些地方用到他们。

这时知道算法的名字并了解它们的功能，然后动手去实践。当我们在去理解算法并动手编程实践过程中获得成长，如果现在还在迷茫的自学，找不到什么突破口的人来说，这可能是一个硬伤！所以找一个经验丰富的老师是很重要的哟，再加上同学一起学习怎会是难事？如果你有强烈的学习欲望。

第一：我们常常都说要先预习，所以这是肯定的，如果你接收能力非常强的话就可以不预习。如果只是一般最好提前预习一下，有什么不懂的做记号，在老师讲的时候就会更清楚一些。这是很关键的。可以帮你提高很多的。

第二：在自己学习或者跟着老师学习完以后。一定要理解知道是怎么回事，在自己完成一些习题，跟着老师或者自己看的例子。不懂一定要问，一定要问和与自己的伙伴交流沟通，一起讨论这是你学习成功的一大法宝。只有通过自己的思考写出来的代码才是自己的，你死记硬背下来的代码肯定不是你的。学程序一定要讨论。不管是未来你要从事产品经理还是做项目，讨论是程序员必须具备的东西。

第三：做练习时最好是独立完成。不会的才采用第二点。动手操作的过程中将自己不会的东西记录下来。然后针对性的找人指导。如果你还是一个人在奋战与程序界，如果你想真正的学好，精通JAVA，可以跟着经验丰富的师资团队、JAVA课程研发者一起学习和交流。每天也能够一起学习更多最新的java项目实战。

第四：多思考，多学习，多问，多做一些逻辑方面的题。因为学程序逻辑是最重要的，英语好不好和学好程序没有任何关系，所以不用太在意这个，努力去学习去做，选对方向，找对人帮助，你就能够学好。

第五：开始学习时就从最简单的程序入手，不要急，比先写一引起加减法，比较这些题。有助于你的理解。

建议大家如果还有多的时间就多看一下别的语言，看一下有什么相似点，总结一下，对你编程来说也有一定的帮助。

Java不是一门独立存在的一门编程语言，它与其他语言都有共同之处也有不同之处。技术的联系都是千丝万缕的。就好比现在Java应用最多之处恐怕就是WEB，那么你就需要了解前端，也就是我们常常说的html等等。所以Java所涉及的技术并不是单一的，你应该要学习Java所涉及的基础知识，对于“CLASSPATH要怎么设置啊”、“跪求JDK下载地址”等等问题，你不该问，因为网上太多答案了，甚至换个角度说，你是不是还不适合直接学习编程?

1)买本Java的书。

关于Java面的书其实有很多，但是并不是每一本适合你自己，其实书不在于多，在于是否适合自己，你自己是否看得懂，此外要求希望比较新版本书籍，因为技术每天都在更新。

2)准备Java学习环境

对于Java初学者，不建议用IDE工具，通过一行行的代码，您会遇上很多问题，只有这样才能培养你怎么去解决问题，并加深你对Java的理解，为日后编程生活积累丰富的知识。

3)Java基础学习之路

Java的体系分为Java SE、Java EE和Java ME，Java的敲门砖就是Java SE了，也就是你要入门学习的内容，不论你日后是选择哪个体系领域作为发展方向，你都得从Java SE起步。

4)JavaEE学习之路

学完Java SE，别以为掌握Java，那只是完成“万里长征”的第一步。接下来选择学习Java EE或是Java ME(或者你还想不断深入学习Java SE，只要你喜欢，你可以一直深入下去，就像前面所说的，我不会讲到Java ME的学习);估计选择Java EE方面的学习者会多一些，Java EE所涉及技术非常多，考虑到初学者的接受程度，我会尽量从最常用的角度来介绍。

学习Java EE，在开发环境上不建议再用文本编辑器，我感觉Eclipse比较适合初学者，个人也非常喜欢Eclipse。如果你现在也在学习java，在入门学习java的过程当中缺乏系统的学习教程，或者说缺乏一个交流技术的地方，你可以申请加入我的Java学习交流qun：前面输入是：三九零，最后输入是：七八一四。。里面还有我这几年整理的java学习手册，面试题，开发工具，PDF文档教程，你可以自行去下载。如果你喜欢用别的IDE如NetBeans，也没什么问题，关键看个人喜欢。

三、学习JSP/Servlet

在Java EE中，要学习JSP/Servlet(结合Tomcat、MySQL)技术，你还得掌握HTML基础知识，最好再掌握些Java、CSS的技术，而了解XML是必不可少的。在学习JSP/Servlet过程中，应该结合学习 JDBC、数据库开发技术，毕竟绝大多数Java Web项目都是和数据库紧密结合的。

四、 学习数据库开发技术

数据库技术是做业务系统必备技能，Java Web开发人员最低程度都应该掌握SQL语句的使用!你可以结合实际需要，选择一种数据库，并花大力气掌握其开发技术。

记住，学习数据库开发技术和学习Java EE，是相对独立的，你可以在学习JSP/Servlet的同时，学习数据库开发技术(如SQL语句等)，或者先学数据库开发技术，之后再学习JSP/Servlet。

五、Java之外的学习

等你对Java EE有些感悟的时候，你自然就会想不断扩充你的知识层面，那么到这个时候你可以学习Spring、Hibernate，以及各种Web框架。随着技术以及经验不断积累，你会逐步分析、设计等更高层次的知识，这时候，你可进一步学习相关的UML、模式等知识

 最后，给大家一些建议：实践是学习任何一门技术必修课，技术是否学到家，完全要在实战上说明一切，Java学习没有捷径可走，每天只能多练，才能真正学透一门技术。。。

Java快速入门！大专学历自学Net看大仙如何快速转职Java

Java是什么？我就是死都不会学Java

1.注释

注释的重要性不言而喻，我们不管写什么代码注释必不可少，那么java的注释的书写方式与注释模板是怎么进行的呢？我们来看一下。

package frist;
/*
 * @Description HelloWorld类
 * @Author 王延领
 **/
class HelloWorld {
    /*
    这是我们Java程序的主入口，
    main方法也是程序的主线程。
    */
    public static void main(String[] arg)
    {
        //输出
       System.out.println("wyl");
    }
}

1.1 注释

以上可以看出java的注释主要有三种
单行注释：只能注释当前行，以//开始，直到行结束

 //输出

多行注释：注释一段文字，以/*开始， */结束！

 /*
    这是我们Java程序的主入口，
    main方法也是程序的主线程。
 */

文档注释：用于生产API文档，配合JavaDoc。

/*
 * @Description HelloWorld类
 * @Author 王延领
 **/

1.2 idea注释模版配置

1.2.1 定义java文件头部的注释

File => setting => editor => File and Code Templates-class -Includes

/**
  * @创建人 王延领
  *@创建时间 ${DATE}
  *描述 Todo
**/

以上当你创建一个class的时候就会带上以上信息了

1.2.2 给java类中的方法添加上注释

第一步勾选Enable Live Templates
首先要在上一步中勾选中 Enable Live Templates

第二步新建一个Group
其次要打开LiveTemplates 然后新建一个Group
如图：

在弹窗口中输入你想要的group名称，wyl

其中：Abbreviation 为快捷键,当输入w的时候就会提示对应的方法注释模板，j为类的注释模板

Templete Text
注释内容，$$ 为动态模板参数点击Edit Vaariables 选择对应动态值。

/*
 * @描述: TODO
 * @作者 王延领
 * @时间 2021/7/12
 * @版本 1.0
 */
public class wyl {
    /**
     *@描述
     *@参数 [str]
     *@返回值 [java.lang.String]
     *@创建人 王延领
     *@创建时间 2021/7/12
     *@修改人和其它信息
     */
    public String CommentTemplate(String str)
    {
        return str;
    }
}

2.关键字

关键字	说明
private	一种访问控制方式：私用模式
protected	一种访问控制方式：保护模式
public	一种访问控制方式：共用模式
abstract	表明类或者成员方法具有抽象属性
class	类
extends	表明一个类型是另一个类型的子类型，这里常见的类型有类和接口
final	用来说明最终属性，表明一个类不能派生出子类，或者成员方法不能被覆盖，或者成员域的值不能被改变
implements	表明一个类实现了给定的接口
interface	接口
native	用来声明一个方法是由与计算机相关的语言（如C/C++/FORTRAN语言）实现的
new	用来创建新实例对象
static	表明具有静态属性
strictfp	用来声明FP_strict（单精度或双精度浮点数）表达式遵循IEEE 754算术规范
synchronized	表明一段代码需要同步执行
transient	声明不用序列化的成员域
volatile	表明两个或者多个变量必须同步地发生变化
break	提前跳出一个块
continue	回到一个块的开始处
return	从成员方法中返回数据
do	用在do-while循环结构中
while	用在循环结构中
if	条件语句的引导词
else	用在条件语句中，表明当条件不成立时的分支
for	一种循环结构的引导词
instanceof	用来测试一个对象是否是指定类型的实例对象
switch	分支语句结构的引导词
case	用在switch语句之中，表示其中的一个分支
default	默认，例如，用在switch语句中，表明一个默认的分支
try	尝试一个可能抛出异常的程序块
catch	用在异常处理中，用来捕捉异常
throw	抛出一个异常
throws	声明在当前定义的成员方法中所有需要抛出的异常
import	表明要访问指定的类或包
package	包
boolean	基本数据类型之一，布尔类型
byte	基本数据类型之一，字节类型
char	基本数据类型之一，字符类型
double	基本数据类型之一，双精度浮点数类型
float	基本数据类型之一，单精度浮点数类型
int	基本数据类型之一，整数类型
long	基本数据类型之一，长整数类型
short	基本数据类型之一,短整数类型
super	表明当前对象的父类型的引用或者父类型的构造方法
this	指向当前实例对象的引用
void	声明当前成员方法没有返回值
goto	保留关键字，没有具体含义
const	保留关键字，没有具体含义

3.数据类型

3.1.数据类型转换

3.1.1自动类型转换
自动类型转换：容量小的数据类型可以自动转换为容量大的数据类型。

注：如果低级类型为char型，向高级类型（整型）转换时，会转换为对应ASCII码值
3.1.2 强制类型转换
强制类型转换，又被称为造型，用于显式的转换一个数值的类型.
转换方式为：(type)var ，运算符“()”中的type表示将值var想要转换成的目标数据类型。 条件是转换的数据类型必须是兼容的。

double x = 3.14;
int nx = (int)x; //值为3
char c = 'a';
int d = c+1;
System.out.println(d); //98
System.out.println((char)d); //b

3.1.3.包装类过渡类型转换

• eg1:int i=Integer.parseInt(“123”)
  说明：此方法只能适用于字符串转化成整型变量
• eg2: float f=Float.valueOf(“123”).floatValue()
  说明：上例是将一个字符串转化成一个Float对象，然后再调用这个对象的floatValue()方法返回其对应的float数值。
• eg3: boolean b=Boolean.valueOf(“123”).booleanValue()
  说明：上例是将一个字符串转化成一个Boolean对象，然后再调用这个对象的booleanValue()方法返回其对应的boolean数值。
• eg4:double d=Double.valueOf(“123”).doublue()
  说明：上例是将一个字符串转化成一个Double对象，然后再调用这个对象的doublue()方法返回其对应的double数值。
• eg5: long l=Long.valueOf(“123”).longValue()
  说明：上例是将一个字符串转化成一个Long对象，然后再调用这个对象的longValue()方法返回其对应的long数值。
• eg6: char=Character.valueOf(“123”).charValue()
  说明：上例是将一个字符串转化成一个Character对象

++++++++++++++++++++++++++++++++++++++++++++++++++++++

4.常量、变量、运算符

常量

变量是什么：就是可以变化的量！
我们通过变量来操纵存储空间中的数据，变量就是指代这个存储空间！空间位置是确定的，但是里面放
置什么值不确定！Java是一种强类型语言，每个变量都必须声明其类型。

//数据类型 变量名 = 值；可以使用逗号隔开来声明多个同类型变量。

注意事项：
每个变量都有类型，类型可以是基本类型，也可以是引用类型。
变量名必须是合法的标识符。
变量声明是一条完整的语句，因此每一个声明都必须以分号结束
变量作用域
类变量（静态变量： static variable）：独立于方法之外的变量，用 static 修饰。
实例变量（成员变量：member variable）：独立于方法之外的变量，不过没有 static 修饰。
局部变量（lacal variable）：类的方法中的变量。

变量

常量(Constant)：初始化(initialize)后不能再改变值！不会变动的值。

final 常量名=值;
final double PI=3.14;

命名规范

1. 所有变量、方法、类名：见名知意
2. 类成员变量：首字母小写和驼峰原则 : monthSalary
3. 局部变量：首字母小写和驼峰原则
4. 常量：大写字母和下划线：MAX_VALUE
5. 类名：首字母大写和驼峰原则: Man, GoodMan
6. 方法名：首字母小写和驼峰原则: run(), runRun()

运算符

Java 语言支持如下运算符：
算术运算符: +，-，，/，%，++，–
赋值运算符 =
关系运算符: >，<，>=，<=，==，!= instanceof
逻辑运算符: &&，||，!
位运算符: &，|，^，~ ， >>，<<，>>> (了解！！！)
条件运算符 ？：
扩展赋值运算符:+=，-=，=，/=

5.java流转控制

if…else、while、do…while、for、switch…case 在这就不累述了。
跳转：
return
return从一个方法返回，并把控制权交给调用它的语句序；或者直接结束当前的程序；
break
break语句在for、while、do···while循环语句中，经常用于强行退出当前循环；
continue
continue语句用于跳过此次循环，执行下次循环；

6.方法

那么什么是方法呢？
Java方法是语句的集合，它们在一起执行一个功能。
方法是解决一类问题的步骤的有序组合
方法包含于类或对象中
方法在程序中被创建，在其他地方被引用
设计方法的原则：方法的本意是功能块，就是实现某个功能的语句块的集合。我们设计方法的时候，最
好保持方法的原子性，就是一个方法只完成1个功能，这样利于我们后期的扩展。
方法的优点
使程序变得更简短而清晰。
有利于程序维护。
可以提高程序开发的效率。
提高了代码的重用性。

定义

修饰符 返回值类型 方法名(参数类型 参数名){
...
方法体
...c
return 返回值;
}

**修饰符：**修饰符，这是可选的，告诉编译器如何调用该方法。定义了该方法的访问类型。
**返回值类型 ：**方法可能会返回值。returnValueType 是方法返回值的数据类型。有些方法执行所需
的操作，但没有返回值。在这种情况下，returnValueType 是关键字void。
**方法名：**是方法的实际名称。方法名和参数表共同构成方法签名。
**参数类型：**参数像是一个占位符。当方法被调用时，传递值给参数。这个值被称为实参或变量。参
数列表是指方法的参数类型、顺序和参数的个数。参数是可选的，方法可以不包含任何参数。
形式参数：在方法被调用时用于接收外界输入的数据。
实参：调用方法时实际传给方法的数据。
**方法体：**方法体包含具体的语句，定义该方法的功能。

方法的重载

就是说一个类的两个方法拥有相同的名字，但是有不同的参数列表。

可变参数

在方法声明中，在指定参数类型后加一个省略号(…) 。
一个方法中只能指定一个可变参数，它必须是方法的最后一个参数。任何普通的参数必须在它之前声
明。

typeName... parameterName

递归

自己调用自己

7.数组

数组的定义：

数组是相同类型数据的有序集合.
数组描述的是相同类型的若干个数据,按照一定的先后次序排列组合而成。
其中,每一个数据称作一个数组元素,每个数组元素可以通过一个下标来访问它们.

数组的四个基本特点：

1. 其长度是确定的。数组一旦被创建，它的大小就是不可以改变的。
2. 其元素必须是相同类型,不允许出现混合类型。
3. 数组中的元素可以是任何数据类型，包括基本类型和引用类型。
4. 数组变量属引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量

数组声明

dataType[] arrayRefVar; // 首选的方法
或
dataType arrayRefVar[]; // 效果相同，但不是首选方法

创建数组

arrayRefVar = new dataType[1 arraySize];

数组的元素是通过索引访问的。数组索引从 0 开始，所以索引值从 0 到 arrayRefVar.length-1。

三种初始化

静态初始化
除了用new关键字来产生数组以外,还可以直接在定义数组的同时就为数组元素分配空间并赋值。

int[] a = {1,2,3};
Man[] mans = {new Man(1,1),new Man(2,2)};

动态初始化
数组定义、为数组元素分配空间、赋值的操作、分开进行。

int[] a = new int[2];
a[0]=1;
a[1]=2;

数组的默认初始化
数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实
例变量同样的方式被隐式初始化。

public static void main(String[] args) {
int[] a=new int[2];
boolean[] b = new boolean[2];
String[] s = new String[2];
System.out.println(a[0]+":"+a[1]); //0,0
System.out.println(b[0]+":"+b[1]); //false,false
System.out.println(s[0]+":"+s[1]); //null, null
}

数组边界

下标的合法区间：[0, length-1]，如果越界就会报错；

for 和For-Each 循环

for(type element: array){
System.out.println(element);
}

for (int i = 1; i < myList.length; i++) {
System.out.println(myList[i]);
}

多维数组

type[][] typeName = new type[typeLength1][1 typeLength2];

Arrays 类

数组的工具类java.util.Arrays
java.util.Arrays 类能方便地操作数组. 使用之前需要导包！
具有以下常用功能：
给数组赋值：通过 fill 方法。
对数组排序：通过 sort 方法,按升序。
比较数组：通过 equals 方法比较数组中元素值是否相等。
查找数组元素：通过 binarySearch 方法能对排序好的数组进行二分查找法操作。
转换为list: 通过asList(a)进行转换

8.面向对象

万物皆为对象！！！对象是抽象概念的具体实例。

以类的方式组织代码，以对象的组织(封装)数据就是面向对象

继承

继承是java面向对象编程技术的一块基石，因为它允许创建分等级层次的类。

class 父类 {
}
class 子类 extends 父类 {
}

public interface A {
    public void eat();
    public void sleep();
}

public interface B {
    public void show();
}

public class C implements A,B {
}

为什么要继承，因为有重复。所以才继承，进而我们就知道了。父类就是公共部分的定义或规则

Java 不支持多继承（只能继承一个类），但支持多重继承。

特点

• 子类拥有父类非 private 的属性、方法。

• 子类可以拥有自己的属性和方法，即子类可以对父类进行扩展。

• 子类可以用自己的方式实现父类的方法。

• Java 的继承是单继承，但是可以多重继承，单继承就是一个子类只能继承一个父类，多重继承就是，例如 B 类继承 A 类，C 类继承 B 类，所以按照关系就是 B 类是 C 类的父类，A 类是 B 类的父类，这是 Java 继承区别于 C++ 继承的一个特性。

• 提高了类之间的耦合性（继承的缺点，耦合度高就会造成代码之间的联系越紧密，代码独立性越差）

super 与 this 关键字

class Animal {
  void eat() {
    System.out.println("animal : eat");
  }
}

class Dog extends Animal {
  void eat() {
    System.out.println("dog : eat");
  }
  void eatTest() {
    this.eat();   // this 调用自己的方法
    super.eat();  // super 调用父类方法
  }
}

public class Test {
  public static void main(String[] args) {
    Animal a = new Animal();
    a.eat();
    Dog d = new Dog();
    d.eatTest();
  }
}

animal : eat
dog : eat
animal : eat

final关键字
final 关键字声明类可以把类定义为不能继承的，即最终类；

class SuperClass {
  private int n;
  SuperClass(){
    System.out.println("SuperClass()");
  }
  SuperClass(int n) {
    System.out.println("SuperClass(int n)");
    this.n = n;
  }
}
// SubClass 类继承
class SubClass extends SuperClass{
  private int n;

  SubClass(){ // 自动调用父类的无参数构造器
    System.out.println("SubClass");
  }  

  public SubClass(int n){ 
    super(300);  // 调用父类中带有参数的构造器
    System.out.println("SubClass(int n):"+n);
    this.n = n;
  }
}
// SubClass2 类继承
class SubClass2 extends SuperClass{
  private int n;

  SubClass2(){
    super(300);  // 调用父类中带有参数的构造器
    System.out.println("SubClass2");
  }  

  public SubClass2(int n){ // 自动调用父类的无参数构造器
    System.out.println("SubClass2(int n):"+n);
    this.n = n;
  }
}
public class TestSuperSub{
  public static void main (String args[]){
    System.out.println("------SubClass 类继承------");
    SubClass sc1 = new SubClass();
    SubClass sc2 = new SubClass(100); 
    System.out.println("------SubClass2 类继承------");
    SubClass2 sc3 = new SubClass2();
    SubClass2 sc4 = new SubClass2(200); 
  }
}

------SubClass 类继承------
SuperClass()
SubClass
SuperClass(int n)
SubClass(int n):100
------SubClass2 类继承------
SuperClass(int n)
SubClass2
SuperClass()
SubClass2(int n):200

构造函数

子类是不继承父类的构造器（构造方法或者构造函数）的，它只是调用（隐式或显式）。如果父类的构造器带有参数，则必须在子类的构造器中显式地通过 super 关键字调用父类的构造器并配以适当的参数列表。

如果父类构造器没有参数，则在子类的构造器中不需要使用 super 关键字调用父类构造器，系统会自动调用父类的无参构造器。

重写(Override)与重载(Overload)

重写(Override)

重写是子类对父类的允许访问的方法的实现过程进行重新编写, 返回值和形参都不能改变。即外壳不变，核心重写

class Animal{
   public void move(){
      System.out.println("动物可以移动");
   }
}

class Dog extends Animal{
   public void move(){
      System.out.println("狗可以跑和走");
   }
}

public class TestDog{
   public static void main(String args[]){
      Animal a = new Animal(); // Animal 对象
      Animal b = new Dog(); // Dog 对象
      a.move();// 执行 Animal 类的方法
      b.move();//执行 Dog 类的方法
   }
}

动物可以移动
狗可以跑和走

方法的重写规则

• 参数列表与被重写方法的参数列表必须完全相同。

• 返回类型与被重写方法的返回类型可以不相同，但是必须是父类返回值的派生类（java5 及更早版本返回类型要一样，java7 及更高版本可以不同）。

• 访问权限不能比父类中被重写的方法的访问权限更低。例如：如果父类的一个方法被声明为 public，那么在子类中重写该方法就不能声明为 protected。

• 父类的成员方法只能被它的子类重写。

• 声明为 final 的方法不能被重写。

• 声明为 static 的方法不能被重写，但是能够被再次声明。

• 子类和父类在同一个包中，那么子类可以重写父类所有方法，除了声明为 private 和 final 的方法。

• 子类和父类不在同一个包中，那么子类只能够重写父类的声明为 public 和 protected 的非 final 方法。

• 重写的方法能够抛出任何非强制异常，无论被重写的方法是否抛出异常。但是，重写的方法不能抛出新的强制性异常，或者比被重写方法声明的更广泛的强制性异常，反之则可以。

• 构造方法不能被重写。

• 如果不能继承一个类，则不能重写该类的方法。

重载(Overload)

重载(overloading) 是在一个类里面，方法名字相同，而参数不同。返回类型可以相同也可以不同。

每个重载的方法（或者构造函数）都必须有一个独一无二的参数类型列表。

最常用的地方就是构造器的重载。

public class Overloading {
    public int test(){
        System.out.println("test1");
        return 1;
    }

    public void test(int a){
        System.out.println("test2");
    }   

    //以下两个参数类型顺序不同
    public String test(int a,String s){
        System.out.println("test3");
        return "returntest3";
    }   

    public String test(String s,int a){
        System.out.println("test4");
        return "returntest4";
    }   

    public static void main(String[] args){
        Overloading o = new Overloading();
        System.out.println(o.test());
        o.test(1);
        System.out.println(o.test(1,"test3"));
        System.out.println(o.test("test4",1));
    }
}

重载规则:

• 被重载的方法必须改变参数列表(参数个数或类型不一样)；

• 被重载的方法可以改变返回类型；

• 被重载的方法可以改变访问修饰符；

• 被重载的方法可以声明新的或更广的检查异常；

• 方法能够在同一个类中或者在一个子类中被重载。

• 无法以返回值类型作为重载函数的区分标准。

  区别点	重载方法	重写方法
  参数列表	必须修改	一定不能修改
  返回类型	可以修改	一定不能修改
  异常	可以修改	可以减少或删除，一定不能抛出新的或者更广的异常
  访问	可以修改	一定不能做更严格的限制（可以降低限制）

多态

多态是同一个行为具有多个不同表现形式或形态的能力。

多态就是同一个接口，使用不同的实例而执行不同操作。

多态性是对象多种表现形式的体现。

多态的优点

1. 消除类型之间的耦合关系
2. 可替换性
3. 可扩充性
4. 接口性
5. 灵活性
6. 简化性

多态存在的三个必要条件

继承
重写
父类引用指向子类对象：Parent p = new Child();

class Shape {
    void draw() {}
}

class Circle extends Shape {
    void draw() {
        System.out.println("Circle.draw()");
    }
}

class Square extends Shape {
    void draw() {
        System.out.println("Square.draw()");
    }
}

class Triangle extends Shape {
    void draw() {
        System.out.println("Triangle.draw()");
    }
}

虚函数

虚函数的存在是为了多态。

Java 中其实没有虚函数的概念，它的普通函数就相当于 C++ 的虚函数，动态绑定是Java的默认行为。如果 Java 中不希望某个函数具有虚函数特性，可以加上 final 关键字变成非虚函数。

多态的实现方式

方式一：重写：

方式二：接口

方式三：抽象类和抽象方法

抽象类

拥有抽象方法的类就是抽象类，抽象类要使用abstract关键字声明.

abstract class A{//定义一个抽象类
	public void fun(){//普通方法
		System.out.println("存在方法体的方法");
	}
	public abstract void print();//抽象方法，没有方法体，有abstract关键字做修饰

}

继承抽象类

我们可以通过以下方式继承 Employee 类的属性

抽象类的使用原则
（1）抽象方法必须为public或者protected（因为如果为private，则不能被子类继承，子类便无法实现该方法），缺省情况下默认为public；
（2）抽象类不能直接实例化，需要依靠子类采用向上转型的方式处理；
（3）抽象类必须有子类，使用extends继承，一个子类只能继承一个抽象类；
（4）子类（如果不是抽象类）则必须覆写抽象类之中的全部抽象方法（如果子类没有实现父类的抽象方法，则必须将子类也定义为为abstract类。）；

package com.wz.abstractdemo;

abstract class A{//定义一个抽象类

	public void fun(){//普通方法
		System.out.println("存在方法体的方法");
	}

	public abstract 以上是关于自学Java如何入门？的主要内容，如果未能解决你的问题，请参考以下文章
 
 自学Java应该怎么入门？
 自学Java怎么入门？
 Java自学是看书还是看视频？有没有推荐？
 Java快速入门！大专学历自学Net看大仙如何快速转职Java
 小白自学JAVA怎么入门？
 软件编程入门自学好吗