JAVA基础（java基础知识点）

25-02-05 26

在这篇文章中，我们将带领您了解JAVA基础的全貌，包括java基础知识点的相关情况。同时，我们还将为您介绍有关JavaWeb基础教程之Java基础加强版、java基本数据类型thinkinjava_T

在这篇文章中，我们将带领您了解JAVA基础的全貌，包括java基础知识点的相关情况。同时，我们还将为您介绍有关JavaWeb基础教程之Java基础加强版、java基本数据类型 think in java_Think in Java(一)：Java基础[通俗易懂]、java基础(6)java基础语句语法之(if..else判断)、java基础---Java简介与基础语法的知识，以帮助您更好地理解这个主题。

本文目录一览：

JAVA基础（java基础知识点）
JavaWeb基础教程之Java基础加强版
java基本数据类型 think in java_Think in Java(一)：Java基础[通俗易懂]
java基础(6)java基础语句语法之(if..else判断)
java基础---Java简介与基础语法

JAVA基础（java基础知识点）

01 面向对象

面向对象是一种思想，世间万物都可以看做一个对象，Java 是一个支持并发、基于类和面向对象的计算机编程语言。

面向对象软件开发具有以下优点：

代码开发模块化，更易维护和修改。
代码复用性强。
增强代码的可靠性和灵活性。
增加代码的可读性。

02 面向对象的特征

封装、继承、多态、抽象。

封装

给对象提供了隐藏内部特性和行为的能力。其实也就是将对象的属性和方法变为私有，对象提供一些能被其它对象访问的方法来改变它的属性，例如set/get方法，提高了代码的可用性和可维护性。在 Java 中，有 4 种修饰符： default、public、private 和 protected 。

继承

给对象提供了从基类获取字段和方法的能力。从而提供了代码的重用行，同时为实现多态性作准备。

多态

父类的引用指向子类。方法的重写,重载与动态链接构成多态性。例如接口和接口的多个实现类。当创建对象时，若左右类不同的时候，只能调用左边类的方法，但真正执行的是右边类对应的方法。如果进行了强制类型转换（一般是向上转型），执行的还是右边类对应的方法。

抽象

是把想法从具体的实例中分离出来的步骤，因此，要根据他们的功能而不是实现细节来创建类。Java 支持创建只暴漏接口而不包含方法实现的抽象的类。这种抽象技术的主要目的是把类的行为和实现细节分离开。

03 面向对象和面向过程的区别

面向过程

优点：性能比面向对象高，因为类调用时需要实例化，开销比较大，比较消耗资源。比如，单片机、嵌入式开发、Linux/Unix 等一般采用面向过程开发，性能是最重要的因素。

缺点：没有面向对象易维护、易复用、易扩展。

面向对象

优点：易维护、易复用、易扩展，由于面向对象有封装、继承、多态性的特性，可以设计出低耦合的系统，使系统更加灵活、更加易于维护。

缺点：性能比面向过程低。

04 重载和重写的区别

重写 override

方法名、参数、返回值相同。子类方法不能缩小父类方法的访问权限。子类方法不能抛出比父类方法更多的异常(但子类方法可以不抛出异常)。存在于父类和子类之间。方法被定义为 final 不能被重写。

重载 overload

参数类型、个数、顺序至少有一个不相同。不能重载只有返回值不同的方法。存在于同类中。

05 JDK、JRE、JVM 的关系

简单说，就是 JDK 包含 JRE 包含 JVM，JRE 包含 JVM。

Java 开发工具包，包含编写 Java 程序所必须的编译、运行等开发工具以及 JRE。

Java 运行环境，提供了运行 Java 应用程序所必须的软件环境，包含有 Java 虚拟机（JVM）和丰富的系统类库。系统类库即为 Java 提前封装好的功能类，只需拿来直接使用即可，可以大大的提高开发效率。

Java 虚拟机，提供了字节码文件(.class)的运行环境支持。

06 Java中的数据类型

Java 支持的数据类型包括基本数据类型和引用类型。

基本数据类型

整数值型：byte、short、int、long

字符型：char

浮点类型：float、double

布尔型：boolean

整数默认是int 型，小数默认是 double 型。Float 和 Long 类型的必须加后缀，比如：float f = 100f 。byte取值范围 -128至127。

引用类型

引用类型包括类、接口、数组等。

特别注意，String 是引用类型不是基本类型。引用类型声明的变量指向的是该实例对象在栈中的引用地址，实际的对象是存在堆中。

07 Java是值传递还是引用传递

在Java方法中所有的参数传递，不管基本类型还是引用类型，都是值传递，或者说是副本传递。只是在传递过程中分以下情况：

对基本数据类型进行操作

由于原始内容和副本都是存储实际值，并且是在不同的栈区（线程之间的栈是隔离的），因此形参的操作，不影响原始内容。

对引用数据类型进行操作

分两种情况，一种是形参和实参保持指向同一个对象地址，则形参的操作，会影响实参指向的对象的内容。一种是形参被改动指向新的对象地址（如重新赋值引用），则形参的操作，不会影响实参指向的对象的内容。

08 String、StringBuffer、StringBuilder 的区别

Java 平台提供了两种类型的字符串：String 和 StringBuffer/StringBuilder（可以储存和操作字符串）。

String

是只读字符串，也就意味着 String 引用的字符串内容是不能被改变的。每次对 String 类型进行改变的时候，都会生成一个新的 String 对象，然后将指针指向新的 String 对象。

StringBuffer/StringBuilder

表示的字符串对象可以直接进行修改，区别在StringBuffer是线程不安全的。

09 String s = new String(“xyz”);会创建几个对象

s不是对象，s是指针引用。String类型是final的，是不可改变的，对String类型的变量进行操作，只会改变变量的引用地址，而不会改变原String对象。在 jvm 的工作过程中，会创建一片内存空间存放 string 对象以及final修饰的变量，我们把这片内存空间叫做常量池。

10 Integer的缓存策略

为了节省内存和提高性能，在创建新的 Integer 对象之前会先在缓存中查找。有一个专门的 IntegerCache 类来负责 Integer 的缓存。这种 Integer 缓存策略仅在自动装箱的时候有用，使用构造器创建的 Integer 对象不能被缓存。

Byte，Short，Long 有固定范围: -128 到 127。对于 Character, 范围是 0 到 127。除了 Integer 可以通过JVM参数改变范围外，其它的都不行。

11 equals 与 == 的区别

对于equals方法

如果equals方法没有重写，比较的是引用类型的变量所指向的对象的地址。

如果equals方法有重写，诸如String、Date等类。比较的是所指向的对象的内容。

对于==

如果作用于基本数据类型的变量，则直接比较其存储的 “值”是否相等。

如果作用于引用类型的变量，则比较的是所指向的对象的地址。

12 equals方法和hashcode方法的关系

HashCode主要是为了查找的快捷性，HashCode是用来在散列存储结构（hash表）中确定对象的存储地址。

为什么hashcode使查找的更快？比如：我们有一个能存放1000个数这样大的内存中，在其中要存放1000个不一样的数字，用最笨的方法，就是存一个数字，就遍历一遍，看有没有相同得数，当存了900个数字，开始存901个数字的时候，就需要跟900个数字进行对比，这样就很麻烦，很是消耗时间，用hashcode来记录对象的位置，来看一下。hash表中有1、2、3、4、5、6、7、8个位置，存第一个数，hashcode为1，该数就放在hash表中1的位置，存到100个数字，hash表中8个位置会有很多数字了，1中可能有20个数字，存101个数字时，他先查hashcode值对应的位置，假设为1，那么就有20个数字和他的hashcode相同，他只需要跟这20个数字相比较(equals)，如果每一个相同，那么就放在1这个位置，这样比较的次数就少了很多，实际上hash表中有很多位置，这里只是举例只有8个，所以比较的次数会让你觉得也挺多的，实际上，如果hash表很大，那么比较的次数就很少很少了。

通过前面这个例子，大概可以知道，先通过hashcode来比较，如果hashcode相等，那么就用equals方法来比较两个对象是否相等。用个例子说明：上面说的hash表中的8个位置，就好比8个桶，每个桶里能装很多的对象，对象A通过hash函数算法得到将它放到1号桶中，当然肯定有别的对象也会放到1号桶中，如果对象B也通过算法分到了1号桶，那么它如何识别桶中其他对象是否和它一样呢，这时候就需要equals方法来进行筛选了。

如果两个对象equals相等，那么这两个对象的HashCode一定也相同；如果两个对象的HashCode相同，不代表两个对象就相同，只能说明这两个对象在散列存储结构中，存放于同一个位置。所以，如果对象的equals方法被重写，那么对象传的HashCode方法也尽量重写。

13 final、finally、finalize 的区别

Final

可以修饰变量、方法和类。final类不能被继承，因此一个类不能既是abstract 又是final 的；final方法不能重写；final变量必须在声明时给定初值且不可修改。

Finally

与try catch搭配使用，无论是否发生异常，finally语句块的代码都会执行。

Finalize

#finalize() 方法，是在 Object 类中定义的，因此所有的类都继承了它。这个方法是由垃圾收集器在确定这个对象没有被引用时对这个对象调用的。

14 抽象类和接口的区别

从设计层面来说，抽象是对类的抽象，是一种模板设计，接口是行为的抽象，是一种行为的规范。

它们的实现有共同点，不同点在于：接口中所有的方法隐含的都是抽象的，而抽象类则可以同时包含抽象和非抽象的方法。

类可以实现很多个接口，但是只能继承一个抽象类。类可以不实现抽象类和接口声明的所有方法，当然，在这种情况下，类也必须得声明成是抽象的。

接口和抽象类都不可以被实例化；接口中声明的变量和成员函数默认都是 final 的；抽象类可以包含非 final 的变量，成员函数可以是 private，protected 或者是 public 。

15 类的实例化顺序

初始化顺序如下：

父类【静态成员】和【静态代码块】，按在代码中出现的顺序依次执行。
子类【静态成员】和【静态代码块】，按在代码中出现的顺序依次执行。
父类【普通成员】和【普通代码块】，按在代码中出现的顺序依次执行。
执行父类的构造方法。
子类【普通成员】和【普通代码块】，按在代码中出现的顺序依次执行。
执行子类的构造方法。

17 成员变量与局部变量的区别

从语法看

成员变量是在类中定义的变量，而局部变量是在方法中定义的变量或是方法的参数；成员变量可以被 public,private,static 等修饰符所修饰，而局部变量不能被访问控制修饰符及 static 所修饰；但是成员变量和局部变量都能被 final 所修饰；

从存储方式看

成员变量是对象的一部分，而对象存在于堆内存，局部变量存在于栈内存。

从生命周期看

成员变量是对象的一部分，它随着对象的创建而存在，而局部变量随着方法的调用而自动消失。

成员变量如果没有被赋初值，则会自动以类型的默认值而赋值（被 final 修饰的成员变量必须显示地赋值），而局部变量则不会自动赋值。

18 内部类

内部类是指在一个外部类的内部再定义一个类。内部类提供了更好的封装，除了该外围类，其他类都不能访问。内部类主要有以下几类：成员内部类、局部内部类、静态内部类、匿名内部类。

典型的情况是，内部类继承自某个类或实现某个接口，内部类的代码操作创建其的外围类的对象，内部类提供了某种进入其外围类的窗口。使用内部类最吸引人的原因是：每个内部类都能独立地继承自一个（接口的）实现，所以无论外围类是否已经继承了某个（接口的）实现，对于内部类都没有影响。内部类是一个编译时的概念，一旦编译成功，就会成为完全不同的两个类。对于一个名为outer的外部类和其内部定义的名为inner的内部类。编译完成后出现outer.class和outer$inner.class两个类。

成员内部类

作为外部类的一个成员存在，与外部类的属性、方法并列。可以被访问修饰符修饰。创建成员内部类时先创建外部对象，再由外部类创建内部类：

Outer out = new Outer(); Outer.Inner outin = out.new Inner()。如果你用的是静态内部类，那就不需要对其外围类对象的引用。

注意事项：

成员内部类中，不能定义静态成员（包括属性和方法）；
成员内部类中，可以访问外部类的所有成员；
内部类和外部类的同名实例变量可以共存；
在内部类中访问内部类自己的变量直接用变量名，也可以用this.变量名；
如果内部类中没有与外部类同名的变量，则可以直接用变量名访问外部类变量；
如果内部类中有与外部类同名的变量，则可以用外部类名.this.变量名

局部内部类

在方法中定义，与局部变量类似，局部内部类不能有访问说明符，因为它不是外围类的一部分，但是它可以访问当前代码块内的常量，和此外围类所有的成员。访问局部内部类必须先有外部类对象，用外部对象调用局部内部类所在的方法。

注意事项：

成员内部类中，不能定义静态成员；
成员内部类中，可以访问当前代码块内的常量，和此外围类所有的成员；
内部类和外部类的同名实例变量可以共存；
在内部类中访问内部类自己的变量直接用变量名，也可以用this.变量名；
如果内部类中没有与外部类同名的变量，则可以直接用变量名访问外部类变量；
如果内部类中有与外部类同名的变量，则可以用外部类名.this.变量名；
可以访问外部类的局部变量(即方法内的变量)，但是变量必须是final的；

静态内部类（嵌套类）

其实就是static的成员内部类。普通的成员内部类对象隐含地保存了一个引用，指向创建它的外围类对象。然而，当成员内部类是static时，就不是这样了。

生成一个静态内部类不需要外部类成员：这是静态内部类和成员内部类的区别。静态内部类的对象可以直接生成：Outer.Inner in = new Outer.Inner()。

注意事项：

静态内部类可以用public,protected,private修饰；
静态内部类中可以定义静态或者非静态的成员；
静态内部类只能访问外部类的静态成员(包括静态变量和静态方法)

匿名内部类

简单地说，匿名内部类就是没有名字的内部类。

注意事项：

匿名内部类不能有构造方法。
匿名内部类不能定义任何静态成员、方法和类。
匿名内部类不能是public,protected,private,static。
一个匿名内部类一定是在new的后面，用其隐含实现一个接口。

匿名内部类主要用在回调函数中，在Java中，通常就是编写另外一个类或类库的人规定一个接口，然后你来实现这个接口，然后把这个接口的一个对象作为参数传给别人的程序，别人的程序必要时就会通过那个接口来调用你编写的函数,执行后续的一些方法,。

JavaWeb基础教程之Java基础加强版

这篇文章主要介绍了JavaWeb基础教程之Java基础加强版的相关资料,需要的朋友可以参考下

1、myeclipse的安装和使用

* eclipse：是一个免费的开发工具 * myeclipse：是一个收费的插件，破解myeclipse， ** 安装目录的要求：不能有中文和空格 ** 安装完成之后，选择一个工作空间，这个工作空间不能有中文和空格 * 破解myeclipse ** 运行run.bat文件，但是运行之前，必须要安装jdk，通过配置环境变量 * myeclipse的使用 * 创建一个工程 - 类型 java project web project - 选择依赖的jdk，可以使用myeclipse自带的jdk，或者可以使用安装的jdk * 创建包 package - cn.itcast.test XX.XX.XX * 在包里面创建一个类 - 类的命名规范： ** 首字母要大写比如： TestDemo1 UserManager * 在类里面创建方法 public void test1(参数列表) { 方法体或者返回值; } - 方法的命名规范首字母小写比如：addNum() * 定义变量 - 变量的命名规范 ** 首字母小写，第二个单词的首字母要大写，比如 userName * 这些命名还有一种方式 ** 使用汉语拼音命名 yonghuming mima ** 不能把汉语拼音和英文字母混合使用 userMing * 命名的最基本的原则：看到名字知道是什么含义 * 代码需要有缩进 * 运行程序 run as java application debug as java application

2、debug的调试模式（断点调试模式）

* 使用这种模式，调试程序（看到程序里面数据的变化） * 使用debug第一步需要设置一个断点（让程序运行停止在这一行） - 显示出来行号 - 双击左边，出现一个圆点，表示设置了一个断点 * 使用debug as方式，运行程序 - 提示是否进入到调试界面，yes - 在断点那一个，有一个绿色条，表示程序停止在这一行，没有向下运行 * 可以让程序向下执行， - 使用 step over 快捷键是 F6（单步执行） - resume F8：表示调试结束，直接向下运行 ** 比如当前的断点之后还有断点，跳到下一个断点， **如果当前断点后面没有断点，程序直接运行结束 * debug另外一个用途 ** 查看程序的源代码 ** F5 step into：进入到方法 ** F7 step return :返回

3、myeclipse的快捷键的使用

* 代码提示 alt / * 快速导包 ctrl shift o * 单行注释 ctrl / * 去掉单行注释 ctrl / * 多行注释 ctrl shift / * 去掉多行注释 ctrl shift * 删除行 ctrl d

4、junit的使用

* 单元测试 * 测试对象是是一个类中的方法 * juint不是javase的一部分，想要使用导入jar包 ** 但是，在myeclipse中自带了junit的jar包 * 首先junit版本 3.x 4.x * 单元测试方法时候，方法命名规则 public void 方法名() {} * 使用注解方式运行测试方法, 在方法的上面 ** @Test：表示方法进行单元测试 --- @Test public void testAdd1() { TestJunit test01 = new TestJunit(); test01.testAdd(2, 3); } - 选中方法名称，右键运行点击run as --- junit test - 当出现绿色条，表示方法测试通过 - 当出现了红棕色条，表示方法测试不通过 --- 要运行类中的多个测试方法，点击类中的其他位置，run as --- junit test ** @Ignore ：表示这个方法不进行单元测试 ** @Before: 在每个方法执行运行 ** @After：在每个方法之后运行 ** 断言（了解） - Assert.assertEquals("测试期望的值", "方法运行的实际的值") jdk5.0新特性 jdk 1.1 1.2 1.4 5.0 ** 泛型、枚举、静态导入、自动拆装箱、增强for、可变参数 ** 反射

5、泛型的简介

* 为什么要使用泛型？ - 一般使用在集合上 ** 比如现在把一个字符串类型的值放入到集合里面，这个时候，这个值放入到集合之后，失去本事的类型，只能是object类型，这个时候，比如想要对这个值进行类型转换，很容易出现类型转换错误，怎么解决这个问题，可以使用泛型来解决 * 在集合上如何使用泛型 - 常用集合 list set map - 泛型语法集合比如 List * 在泛型里面写是一个对象，String 不能写基本的数据类型比如int (****) ** 写基本的数据类型对应包装类 byte -- Byte short -- Short int -- Integer long -- Long float -- Float double -- Double char -- Character boolean -- Boolean * 在list上使用泛型 list的三种实现 ArrayList linkedList Vector 代码： @Test public void testList() { List list = new ArrayList(); list.add("aaa"); list.add("bbb"); list.add("ccc"); //遍历list集合有几种方式三种 //普通for循环迭代器增强for //普通for循环 for(int i=0;i it = list.iterator(); while(it.hasNext()) { System.out.println(it.next()); } * 作业1： ArrayList linkedList Vector 这三个区别 * 在set上使用泛型代码： //泛型使用set集合上 @Test public void testSet() { Set set = new HashSet(); set.add("www"); set.add("qqq"); set.add("zzz"); //set.add("qqq"); //遍历set 有几种方式两种 //迭代器增强for //使用增强for遍历 for (String s2 : set) { System.out.println(s2); } System.out.println("================="); //使用迭代器遍历 Iterator it1 = set.iterator(); while(it1.hasNext()) { System.out.println(it1.next()); } } * 在map上面使用泛型 - map结构：key-valu形式代码： //在map上使用泛型 @Test public void testMap() { Map map = new HashMap(); map.put("aaa", "111"); map.put("bbb", "222"); map.put("ccc", "333"); //遍历map 有几种遍历方式两种 // 1、获取所有的key，通过key得到value 使用get方法 // 2、获取key和value的关系 //使用第一种方式遍历 //获取所有的key Set sets = map.keySet(); //遍历所有key返回的set for (String key : sets) { //通过key得到value String value = map.get(key); System.out.println(key+" : "+value); } System.out.println("=============="); //得到key和value的关系 Set> sets1 = map.entrySet(); //遍历sets1 for (Entry entry : sets1) { //entry是key和value关系 String keyv = entry.getKey(); String valuev = entry.getValue(); System.out.println(keyv+" : "+valuev); } }

6、泛型使用在方法上

* 定义一个数组，实现指定位置上数组元素的交换 * 方法逻辑相同，只是数据类型不同，这个时候使用泛型方法 * /* * 使用泛型方法需要定义一个类型使用大写字母表示 T :这个T表示任意的类型 * 写在返回值之前 void之前 * =======表示定义了一个类型这个类型是 T * 在下面就可以使用这个类型了 T * */ public static void swap1(T[] arr ,int a,int b) { T temp = arr[a]; arr[a] = arr; arr[b] = temp; } ** 作业2：实现一个泛型方法，接受任意一个数组，颠倒数组中所有元素

[b]7、泛型在类上的使用（了解）

* 在一个类上定义一个类型，这个类型可以在类里面直接使用 * public class TestDemo04 { //在类里面可以直接使用T的类型 T aa; public void test11(T bb) {} //写一个静态方法在类上面定义的泛型，不能再静态方法里面使用 public static void test12(A cc) {} }

8、枚举的简介

* 什么是枚举？ ** 需要在一定的范围内取值，这个值只能是这个范围内中的任意一个。 ** 现实场景：交通信号灯，有三种颜色，但是每次只能亮三种颜色里面的任意一个 * 使用一个关键字 enum ** enum Color3 { RED,GREEN,YELLOW; } * 枚举的构造方法也是私有的 * 特殊枚举的操作（了解） ** 在枚举类里面有构造方法 ** 构造方法里面有参数，需要在每个实例上面都写参数 ** 在枚举类里面有抽象方法 ** 在枚举的每个实例里面都重写这个抽象方法

9、枚举的api的操作

** name() ：返回枚举的名称 ** ordinal() ：枚举的下标，下标从0开始 ** valueOf(Class enumType, String name) ：得到枚举的对象 ** 还有两个方法，都是这两个方法不在api里面，编译的时候生成两个方法 *** valueof(String name) 转换枚举对象 *** values() 获得所有枚举对象数组 * 练习：枚举对象、枚举对象下标、枚举对象名称表示之间的转换 - //知道枚举的对象，得到枚举名称和下标 @Test public void test1() { //得到枚举对象 Color100 c100 = Color100.RED; //枚举名称 String name = c100.name(); //枚举的下标 int idx = c100.ordinal(); System.out.println(name+" "+idx); } - //知道枚举的名称，得到枚举的对象和下标 @Test public void test2() { String name1 = "GREEN"; //得到对象 Color100 c1 = Color100.valueOf(name1); //枚举下标 int idx1 = c1.ordinal(); System.out.println(idx1); } - //知道枚举的下标，得到枚举的对象和名称 @Test public void test3() { int idx2 = 2; //得到枚举的对象 Color100[] cs = Color100.values(); //根据下标得到对象 Color100 c12 = cs[idx2]; //得到枚举的名称 String name = c12.name(); System.out.println(name); }

10、静态导入(了解)

* 可以在代码里面，直接使用静态导入方式，导入静态方法或者常量 * import static XX.XX.xxx * import static java.lang.System.out; import static java.util.Arrays.sort; ** 比如现在实现一个计算器在Math类里面

11、自动拆装箱

* 装箱 ** 把基本的数据类型转换成包装类 * 拆箱 ** 把包装类转换成基本的数据类型 ** //自动装箱 Integer i = 10; //自动拆箱 int m = i; ** 在jdk1.4里面如何实现装箱和拆箱 - //在jdk1.4里面实现拆装箱 public void test1() { //装箱 Integer m = new Integer(10); //拆箱 int a = m.intValue(); } ** jdk是会向下兼容 - 比如 jdk1.4里面写的代码，这个时候到5.0里面也可以运行 ** 练习：向下兼容 == 执行的结果是会调用 doSomething(double m) == 首先在jdk1.4里面肯定调用这个方法，如果调用下面的方法，需要类型转换，但是jdk1.4不能实现自动拆装箱 == 由于jdk是向下兼容，所以，在jdk1.4调用这个方法，在jdk5.0里面还是会调用这个方法 public static void main(String[] args) { doSomething(10); } public static void doSomething(double m) { System.out.println("double......"); } public static void doSomething(Integer a){ System.out.println("integer....."); } ** 记住：八种基本的数据类型对应的包装类 * int --- Integer * char--- Character

12、增强for循环（*****）

* 语法 for(遍历出来的值 : 要遍历的集合) {} - for(String s : list) { System.out.println(s); } * 使用场景：数组；实现Iterable接口的集合可以使用增强for循环 * 在集合上使用增强for循环遍历 list set 实现了Iterator接口，所以可以使用增强for循环 map不能使用增强for循环，没有实现Iterator接口，所以不能使用增强for循环 * 增强for循环出现目的：为了替代迭代器 ** 增强for底层就是迭代器实现的

13、内容补充

（1）泛型擦除 * 首先泛型只是出现在源代码阶段，当编译之后泛型不存在了（2）练习：实现一个泛型方法，接受任意类型的数组，颠倒数组中所有元素代码 public static void reverses(T[] arr1) { /* * 基本思想：把第一个元素和最后一个元素交换位置，把第二个元素和倒数第二个元素交换位置。。。。 * 交换长度/2 * */ //遍历数组 for(int i=0;i

14、可变参数

* 可变参数可以应用在什么场景： ** 实现两个数的相加，实现三个数的相加四个数的相加 -- 如果实现的多个方法，这些方法里面逻辑基本相同，唯一不同的是传递的参数的个数，可以使用可变参数 * 可变参数的定义方法数据类型...数组的名称 * 理解为一个数组，这个数组存储传递过来的参数 - 代码 public static void add1(int...nums) { //nums理解为一个数组，这个数组存储传递过来的参数 //System.out.println(nums.length); int sum = 0; //遍历数组 for(int i=0;i

15、反射的原理（********理解********）

* 应用在一些通用性比较高的代码中 * 后面学到的框架，大多数都是使用反射来实现的 * 在框架开发中，都是基于配置文件开发 ** 在配置文件中配置了类，可以通过反射得到类中的所有内容，可以让类中的某个方法来执行 * 类中的所有内容：属性、没有参数的构造方法、有参数的构造方法、普通方法 * 画图分析反射的原理 * 首先需要把java文件保存到本地硬盘 .java * 编译java文件，成.class文件 * 使用jvm，把class文件通过类加载加载到内存中 * 万事万物都是对象，class文件在内存中使用Class类表示 * 当使用反射时候，首先需要获取到Class类，得到了这个类之后，就可以得到class文件里面的所有内容 - 包含属性构造方法普通方法 * 属性通过一个类 Filed * 构造方法通过一个类 Constructor * 普通方法通过一个类 Method

16、使用反射操作类里面的无参数的构造方法（**会写**）

* 首先获取到Class类 - // 获取Class类 Class clazz1 = Person.class; Class clazz2 = new Person().getClass(); Class clazz3 = Class.forName("cn.itcast.test09.Person"); * 比如：要对一个类进行实例化，可以new，不使用new，怎么获取？ - //得到Class Class c3 = Class.forName("cn.itcast.test09.Person"); //得到Person类的实例 Person p = (Person) c3.newInstance(); * 代码 //操作无参数的构造方法 @Test public void test1() throws Exception { //得到Class Class c3 = Class.forName("cn.itcast.test09.Person"); //得到Person类的实例 Person p = (Person) c3.newInstance(); //设置值 p.setName("zhangsan"); System.out.println(p.getName()); }

17、使用反射操作有参数的构造方法（**会写**）

//操作有参数的构造方法 @Test public void test2() throws Exception { //得到Class Class c1 = Class.forName("cn.itcast.test09.Person"); //使用有参数的构造方法 //c1.getConstructors();//获取所有的构造方法 //传递是有参数的构造方法里面参数类型，类型使用class形式传递 Constructor cs = c1.getConstructor(String.class,String.class); //通过有参数的构造方法设置值 //通过有参数的构造方法创建Person实例 Person p1 = (Person) cs.newInstance("lisi","100"); System.out.println(p1.getId()+" "+p1.getName()); }

18、使用反射操作属性（**会写**）

* //操作name属性 @Test public void test3() { try { //得到Class类 Class c2 = Class.forName("cn.itcast.test09.Person"); //得到name属性 //c2.getDeclaredFields();//表示得到所有的属性 //得到Person类的实例 Person p11 = (Person) c2.newInstance(); //通过这个方法得到属性，参数是属性的名称 Field f1 = c2.getDeclaredField("name"); //操作的是私有的属性，不让操作，需要设置可以操作私有属性setAccessible(true),可以操作私有属性 f1.setAccessible(true); //设置name值 set方法，两个参数：第一个参数类的实例，第二个参数是设置的值 f1.set(p11, "wangwu"); //相当于在 p.name = "wangwu"; System.out.println(f1.get(p11)); //相当于 p.name }catch(Exception e) { e.printstacktrace(); } }

19、使用泛型操作普通方法（**会写**）

* 使用Method类表示普通方法 * 代码 //操作普通方法，比如操作 setName @Test public void test4() throws Exception { //得到Class类 Class c4 = Class.forName("cn.itcast.test09.Person"); //得到Person实例 Person p4 = (Person) c4.newInstance(); //得到普通方法 //c4.getDeclaredMethods();//得到所有的普通方法 //传递两个参数：第一个参数，方法名称；第二个参数，方法里面参数的类型 Method m1 = c4.getDeclaredMethod("setName", String.class); //让setName方法执行，执行设置值 //使用invoke(p4, "niuqi");传递两个参数：第一个参数，person实例；第二个参数，设置的值 //执行了invoke方法之后，相当于，执行了setName方法，同时通过这个方法设置了一个值是niuqi m1.invoke(p4, "niuqi"); System.out.println(p4.getName()); } * //操作的私有的方法，需要设置值是true * //m1.setAccessible(true); * 当操作的方法是静态的方法时候，因为静态方法调用方式是类名.方法名，不需要类的实例 * 使用反射操作静态方式时候，也是不需要实例 * 在invokie方法的第一个参数里面，写一个 null - m1.invoke(null, "niuqi");

以上所述是小编给大家介绍的JavaWeb基础教程之Java基础加强版，希望对大家有所帮助，如果大家有任何疑问请给我留言，小编会及时回复大家的。在此也非常感谢大家对小编网站的支持！

java基本数据类型 think in java_Think in Java(一)：Java基础[通俗易懂]

大家好，又见面了，我是你们的朋友全栈君。

一. OOP的特点

(1) 万物皆为对象;

(2) 程序是对象的集合，他们通过发送信息来告诉彼此所要做的;

(3) 每一个对象都有自己的由其它对象所构成的存储;

(4) 每一个对象都拥有它的类型;

(5) 某一特定类型的对象都能够接收相同的消息;

二. Java比C++简单?

(1) Java有垃圾回收器, 不用手动销毁对象;

(2) Java使用单根继承;

(3) Java仅仅能以一种方式创建对象(在堆上创建);

三. 数据存储

(1) 寄存器: 速度最快, 数量有限, 它位于CPU内部, 但我们不能直接控制它。在C,C++中同意你向编译器建议寄存器的分配方式。

(2) 堆栈: 存放基本类型的数据和对象的引用, 但对象本身不存放在栈中，而是存放在堆中。

(3) 堆: 存放用new产生的对象, 速度比分配栈要慢一些。

(4) 静态存储: 固定的一块存储区域, 静态存储里面的数据在整个程序执行期间都能訪问到。

(5) 非RAM: 对象被转化成某种能保存在其它介质上的东西, 要用的时候又能在内存里重建。

四. “==” 和 equals

(1) == 用于推断引用对象的内存地址是否同样。

(2) equals比較的也是地址, 可是假设你重写了equals方法, 那么它就能够比較对象的内容。

五. 关于sizeof

C和C++的sizeof()用于获取数据须要占用多少字节的内存, 之所以须要sizeof是考虑到平台移植, 由于C和C++同样

的数据类型在不同的机器上占用的内存长度不一样; 而Java不须要sizeof, 由于Java的数据类型在不同的平台上占用字节是一样的,

Java是跨平台的。

java基础(6)java基础语句语法之(if..else判断)

java基础必备:语句语法之 if..else判断

if...else判断
一: if单条件判断

(1) 顺序结构
特点: 由上到下依次执行
语句: 其他所有

(2)选择结构
特点: 选择不同, 执行结果不同
语句:

if语句【最重要】
switch语句
If语句：只要在Java中需要做判断
Java中的“if”，可以翻译成现实生活中的“假如、如果”

(3) 循环结构
特点: 重复执行
语句:

for、while、
do-while循环语句

(4) 结论

If是一个“超级三元运算符”,三元运算符能做的，if能做
If能做，三元运算符不一定能做
if可以替代三元运算符

if语句的具体语法格式如下：
if(判断条件){
代码块
}

判断条件是一个布尔表达式
判断条件：
为true，执行if中代码块；
为false，跳过代码块

二: if…else…单条件判断(二选一)

if…else语句具体语法格式如下：
       if (判断条件){
   代码块1
}else{
   代码块2
}

判断条件：

为true，运行if中的代码块1；
为false，运行else中的代码块2

三. if…elseif…else…多条件判断

(1)说明

if: 如果
else if：再如果
else：否则

(2) if…else if…else语句具体语法格式如下：
       if (判断条件1) {
   代码块1
} else if (判断条件2) {
   代码块2
}
...
else if (判断条件n) {
   代码块n
} else {
   末尾代码块
}

   1、执行顺序：从上到下
   2、原则：
       哪个if判断条件为true，就进入哪个if执行代码块
       判断条件为false，则继续判定后排if的判断条件
   3、补充：
       结构中所有if为false时，才会执行else中的末尾代码块
       结构中无论哪个代码块被执行完毕，整个结构都将结束
       else if可以写零~无限多个

(4)额外问题(获取的值n，是x~y之间（包含x和y）: )
注意：

x小值
Y大值
n>=x && n<=y
(1) 变量x ,
判断x是否在 60~80之间。（包含60和80）
if(x>=60 && x<=80){ }
(2) 变量x ,
判断x是否在 60~80之间。（包含80）
if(x>60 && x<=80){ }
(3) 变量x,
判断x是否在 80~60之间。
(60~80)
if(x>60 && x<80){}
(4) 变量x,
判断x是否在 60~80之间或 90~100之间
if( (x>60 && x<80) || (x>90 && x<100)){ }

四. 多层IF

If嵌套可以无限次嵌套
多层if嵌套,可用让程序判断,更为细致

If... Else if条件顺序：

1.最难匹配的应该在最前面（最难为true的放最前面）
2.最容易匹配的应该在最后面（最容易为true的放最后）

防止：
else if 后面的代码永远被忽略

请给努力中的自己点个赞哦!

每天进步一点点`~~~~~

java基础---Java简介与基础语法

1.计算机简介--硬件？

答：看的见的(显示器，鼠标，键盘，摄像头，显卡，声卡，CPU靠芯片运行，主板)

2.计算机简介—软件？

答：系统软件和应用软件

3.什么是程序?

答：1）将大象放进冰箱分三步-->打开冰箱-->把大象放进去-->关闭冰箱

2）将一系列很复杂的事情，分成很小的步骤，通过小步骤的完成最终完成一个大的功能,，其中一个步骤发生故障整个程序就瘫痪

3）完成某些事情的一种既定方式和过程

4）银行取钱带卡去银行-->排号-->喊你-->办理业务-->输入密码-->走人..

4.什么是指令？

答：老板让秘书做3件事，秘书挨个执行(程序里要执行一组语句，指令被逐条执行)

5.计算机程序？

答：为了让计算机执行某些操作或解决某个问题而编写的一系列有序指令的集合

编写程序的工具就是计算机语言，Java就是多种语言中的一种

6.语言发展历史？

答：汇编语言:机器认识的语言，比较抽象。

面向过程的语言：例如C语言。什么事情都需要亲力亲为。

面向对象的语言：java、C++、python(谷歌力推，面向人工智能)和go（面向人工智能）

7.Java能做什么？

答：企业级应用：java ee enteprises edition企业级开发

web B/S Browser 浏览器/服务器

桌面应用：java se standard edition 标准开发

C/S Client/server 客户端

移动互联网时代：

Android平台

8.Java的发展历史？

答：1995年Java语言面世...等等

9.Java发展简介？

开发公司：Sun Microsystems公司于1995年5月推出，甲骨文74亿美元收购Sun。

名字起源：java是印度尼西亚爪哇岛的英文名称

主要特性：1.语法简单易学(Java语言的语法与C语言和C++语言很接近使得大多数程

序员很容易学习和使用Java ）

2.语言平台无关(一次编译到处运行)

3.语言健壮性(Java的强类型机制、异常处理、垃圾自动收集等)

10.开发平台简介？

Java平台由Java虚拟机（简称JVM）和Java 应用编程接口（简称API）构成。

API相当于会各种技能的工人，JVM相当于工厂

Jdk简介：JDK 是整个Java的核心，包括了Java运行环境（JRE）、Java工具和Java基础类

库。

Jdk组成：(关键工具）

javac – 编译器，将源程序转成字节码

java – 运行编译后的java程序（.class后缀的）

11.开发环境搭建？

第一步下载安装JDK

第二步配置环境变量

1-JAVA_HOME

C:\Program Files\Java\jdk1.8.0_40

2-Path

C:\Program Files\Java\jdk1.8.0_40\bin

3-CLASS

.;%JAVA_HOME%\lib;%JAVA_HOME%\lib\dt.jar;%JAVA_HOME%\lib\tools.jar;

第三步在cmd命令窗口中使用Javac确定环境搭建完成

12.使用记事本开发Java程序？

使用记事本编辑源程序，命名名字后以.java为后缀名保存（保存在盘符下面）

public class HelloWorld {

public static void main(String[ ] args) {

System.out.println("Hello World!!!");

}

cmd-- >d:-->javac 文件全名--->java 文件名

使用javac命令编译.java文件，生成.class文件

使用java命令运行.class文件，输出程序结果

13.Java的运行过程以及原理？

第一步编写源代码

第二步编译源代码成字节码

第三步装入字节码，开始运行

14.使用eclipse的开发Java程序？

File-->New-->Project-->java Project-->next-->起名字--> Use an execution...-->javaSE-1.8

src指的是根目录，存放程序的地方

JRE System Library java环境运行的图书馆/库

选择中src--->右键--->new--->class--->首字母必须大写

15.设置写代码区域个人偏好？

window -->Preferences--->General-- ->Appearance--->color and Fonts--->java---Text font---edit--选择字体

16.设置运行结果区域个人偏好？

window -->Preferences--->General--->Appearance--->color and Fonts--->Debug---Text font---edit--选择字体

17.快捷键？

自动补全/提示 alt+/

//syso打印语句

System.out.println();

18.如何运行？

右键点击程序-->Run As-->Java Application-->出现运行结果

点击run case

运行完毕后记得随手关闭，运行结果哪里的小叉，以便下次运行其他代码时不会冲突

19.使用eclipse编译哪里去了？

自动编译，自己保存运行ok

20.Java程序的结构？

public class HelloWorld {

public static void main(String[ ] args) {

System.out.println("Hello World!!!");

}

class表示类，main方法默认要执行，一个类只有一个main(外面是类，里面是方法)

类名与文件名完全一样

21.打印语句有几种？

带换行的

System.out.println("...");

不带换行的

System.out.print("世界你好啊...");

22.换行符与制表符?

System.out.print("\n");

System.out.print("cccc\tdddd");

23.关于java的注释？

多行注释 ctl+shift+/ 效果 /* */

单行注释 ctrl+/ 效果//

24.编写java常见5种错误？

1.public修饰的类的名称必须与Java文件同名!

举例：

public class helloWorld { //源文件名为HelloWorld.java
public static void main (String[ ] args){
System.out.println("我的第一个MyEclipse小程序！");
}
}

2.main()方法作为程序入口，返回值void必不可少！

举例：

public class HelloWorld {
public static main (String[ ] args) {
System.out.println("我的第一个MyEclipse小程序！");
}
}

3.语法出错，无法解析system！Java对大小写敏感!

举例：

public class HelloWorld {
public static void main (String[ ] args) {
system.out.println("我的第一个MyEclipse小程序！");
}
}

4.每一条Java语句必须以分号结束!

举例：

public class HelloWorld {
public static void main (String[ ] args) {
System.out.println("我的第一个MyEclipse小程序！")
}
}

5.注意：不要漏写引

举例：

public class HelloWorld {
public static void main (String[ ] args) {
System.out.println( 我的第一个MyEclipse小程序！);
}
}

25.打印语句的练习:输出商品价目表

1.输出商品价目表

使用\t和\n进行显示格式的控制

public class Case1 {

//main

public static void main(String[] args) {

//syso

System.out.println("\t\t购物清单");

System.out.println("商品名称\t购物数量\t商品单价\t金额");

关于JAVA基础和java基础知识点的介绍已经告一段落，感谢您的耐心阅读，如果想了解更多关于JavaWeb基础教程之Java基础加强版、java基本数据类型 think in java_Think in Java(一)：Java基础[通俗易懂]、java基础(6)java基础语句语法之(if..else判断)、java基础---Java简介与基础语法的相关信息，请在本站寻找。

本文标签：