_kudy
- 浏览: 15090 次
- 性别:
- 来自: 广州
-
最新评论
javase_18(回顾与反射机制学习)
- 博客分类：
- 1.javaSeBase
AM上午总结:
package com.java.kudy.day17_2.ObjectReview;
public class ObjectTest {
/**
*虚拟机做了什么事情?
*1.在栈内存中定义了一个变量p
*2.在类加载器中加载Person.class
*3.在堆内存中开辟空间,分配了一个物理地址
*4.初始化成员变量,如果没有初始值,那么虚拟机会自动初始化,所有的引用数据类型都为null
*5.调用构造函数,为成员赋值(field)
*6.将对象的首地址给变量p2
*/
public static void main(String[] args)
{
Person p = new Person("小细",18);
}
}
class Person
{
private String name;
private int age;
public Person(){}
public Person(String name,int age)
{
this.name = name;
this.age = age;
}
@Override
public String toString()
{
return name+"~"+age;
}
}
抽象类的回顾:
package com.java.kudy.day17_2.Extends;
public class ExtendsTest {
/*
* 抽象类:
* 1.用abstract修饰的类叫做抽象类
* 2.如果该类有抽象的方法,这个类必须要定义成抽象类
* 3.抽象类是更好的为了多态而服务,我们在设计软件的时,会有一些列类都具备相同的功能,这时方法一样的声明,即使是方法也可以复用.
* 我们应该抽象出一个抽象的父类,方便别人学习软件,也能实现一部分代码.说白了就是:更好的为了多态而服务.
* 4.继续抽象类需要实现抽象方法,或者把继承过来的类定义成抽象类.
*/
public static void main(String[] args) {
}
}
abstract class Student
{
public abstract void run();
}
接口和内部类的简单复习:
package com.java.kudy.day17_2.Extends;
/*
* 接口:一种特殊的抽象类,所有的方法都是抽象的.
* 1.实现接口用关键字:implements.可以实现多个接口,接口继承接口可以使用extends 关键字
* 2.接口中的所有的方法默认为:public abstractor 共同修饰,所以不需要另外声明
* 3.接口中所有的变量默认为常量:public static final所修饰,不需要声明(一份)
*
* 匿名内部类实现:
* new fulei(){
* //内部类的定义
* };
* final关键字:
* 1.修饰变量成常量.
* 2.修饰类不能被继承.
* 3.修饰方法不能被重写.
*/
public class InterfacesTest {
public static void main(String[] args) {
Teacher kudy = new Teacher(){
@Override
public void teching() {
System.out.println("同学们,其实我什么也不懂~~!");
}
//匿名内部类实现
};
}
}
interface Teacher
{
void teching(); //public abstract void teching();
}
package com.java.kudy.day17_2.Extends;
public class ExtendsDemo {
/*使用extends关键字,让子类继承父类
* 1.子类会自动复用于父类的方法
* 2.可以把一个子类的实例当做父类来使用,调用方法时,是调用子类的方法(多态),但必须是重写了父类的方法,不过可以转型.访问属性是访问父类的
* (静态绑定,-->在编译的期间就已经完成了变量的绑定)而访问方法是访问子类的(动态的绑定-->)
* 如果是调用子类特有的方法,需要强制转换成子类的类型.
* 假设:A的父类是B B的父类的C --> 如果父类型的C 引用指向子类型的对象-->A
* 但我想使用B类型的方法,我们只需要把B b = (B)c;强制转换就可以.因为c对象本来就是A.
* 3.子类的实例化: 子类在实例化过程中一定调用父类的构造方法,我们在子类的构造函数的第一行可以用this(实参)调用自己的其他方法,
* Super(实参)调用父类的某个构造方法,如果第一行什么也不写.默认super()调用父类的不带参数的构造方法
* 4子类覆盖父类的方法: 方法名相同,参数类型相同.方法的返回值也必须要相同.
*
*/
public static void main(String[] args) {
C c = new A();
//如果我想调用b的方法,原因: 我是你A的父类
B b = (B)c;
b.run();
b.happy();
}
}
class C
{
public void run()
{
System.out.println("a");
}
}
class B extends C
{
public void run()
{
System.out.println("b");
}
public void happy()
{
System.out.println("我是happy达人");
}
}
class A extends B
{
public void run()
{
super.run();
System.out.println("c");
}
}
ArrayList(元素有序,底层数组实现.)
package com.java.kudy.day17_2.CollectionTest;
import java.util.ArrayList;
import java.util.Iterator;
import com.java.kudy.day17_2.reflectDemo.Person;
public class ArrayListTest {
public static void main(String[] args)
{
ArrayList<Person> al = new ArrayList<Person>();
al.add(new Person("a",1));
al.add(new Person("b",2));
al.add(new Person("c",3));
al.add(new Person("d",4));
al.add(new Person("e",5));
/*
* 迭代的三种方式:
*/
Iterator<Person> it = al.iterator();
while(it.hasNext())
{
Person p = it.next();
System.out.println(p);
}
for(Person p : al)
System.out.println(p);
for(int i=0; i<al.size(); i++)
{
System.out.println(al.get(i));
}
}
}
package com.java.kudy.day17_2.CollectionTest;
import java.util.HashSet;
import com.java.kudy.day17_2.reflectDemo.Person;
public class HashSetTest {
/*
* 通过哈希算法保证元素没重复性
* 首先通过哈希算法比较,再用equals比较.
* 1.hashCode
* 2.equals
*/
public static void main(String[]args)
{
HashSet<Person> al = new HashSet<Person>();
al.add(new Person("a",1));
al.add(new Person("b",2));
al.add(new Person("c",3));
al.add(new Person("d",4));
al.add(new Person("a",1));
for(Person p : al)
System.out.println(p);
}
}
TreeSet:可以写比较器..(如果没有实现接口的方法,会出异常信息)
package com.java.kudy.day17_2.CollectionTest;
import java.util.Comparator;
import java.util.TreeSet;
import com.java.kudy.day17_2.reflectDemo.Person;
public class TreeSetTest {
public static void main(String[]args)
{
TreeSet<Person> ts = new TreeSet<Person>(new Comparator<Person>(){
@Override
public int compare(Person s1, Person s2) {
int num = s1.getAge()-s2.getAge();
if(num!=0)
return num;
return s1.getName().compareTo(s2.getName());
}
});
ts.add(new Person("a",1));
ts.add(new Person("b",2));
ts.add(new Person("c",3));
ts.add(new Person("d",4));
ts.add(new Person("a",1));
for(Person p :ts)
System.out.println(p);
}
}
Map回顾练习:
package com.java.kudy.day17_2.CollectionTest;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map.Entry;
import java.util.Set;
public class HashMapTest {
/**
* @param args
*/
public static void main(String[] args)
{
HashMap<Teacher, Integer> hm =
new HashMap<Teacher, Integer>();
hm.put(new Teacher("a",1), 1);
hm.put(new Teacher("a",1), 1);
hm.put(new Teacher("b",2), 1);
hm.put(new Teacher("c",3), 1);
//保证了key的无重复性
/* //方式一:
Set<Entry<Teacher, Integer>> entrys = hm.entrySet(); //获取一个试图
Iterator<Entry<Teacher, Integer>> it = entrys.iterator();
while(it.hasNext())
{
Entry<Teacher, Integer> e = it.next(); //迭代器,迭代下一个内容
Teacher key = e.getKey();
Integer value = e.getValue();
System.out.println(key +"--"+value);
}*/
//方式二:
Set<Teacher> keys= hm.keySet();
for(Teacher t : keys)
{
Integer value = hm.get(t);
System.out.println(t+"--"+value);
}
}
}
Properties的应用:
package com.java.kudy.day17_2.CollectionTest;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.PrintStream;
import java.util.Enumeration;
import java.util.Properties;
public class PropertiesTest {
/**
* @param args
* 用于读写配置文件
* @throws IOException
* @throws FileNotFoundException
*/
public static void main(String[] args) throws FileNotFoundException, IOException {
Properties prop = new Properties();
prop.load(new FileReader("src/a.properties")); //读取进来
Enumeration e = prop.propertyNames();
//通过枚举获取到键-->值
while(e.hasMoreElements())
{
String key = (String)e.nextElement();
String value = prop.getProperty(key);
System.out.println(key+"----"+value);
}
// 调用 Hashtable 的方法 put 键和值进来 key value
prop.setProperty("name","my_kudy");
prop.setProperty("age", "19");
//直接把内容打印到一个配置文件里面去
prop.list(new PrintStream("src/a.properties")); //直接把字节和字符写入进去
//把内容输入里面去
}
}
PM下午总结:
JAVA语言中的反射机制：
在Java 运行时 环境中，对于任意一个类，能否知道这个类有哪些属性和方法？
对于任意一个对象，能否调用他的方法？这些答案是肯定的，这种动态获取类的信息，以及动态调用类的方法的功能来源于JAVA的反射。从而使java具有动态语言的特性。
JAVA反射机制主要提供了以下功能：
1.在运行时判断任意一个对象所属的类
2.在运行时构造任意一个类的对象
3.在运行时判断任意一个类所具有的成员变量和方法（通过反射甚至可以调用private方法）
4.在运行时调用任意一个对象的方法（*****注意：前提都是在运行时，而不是在编译时）
Java 反射相关的API简介：
位于java。lang。reflect包中
--Class类：代表一个类
--Filed类：代表类的成员变量
--Method类：代表类的方法
--Constructor类：代表类的构造方法
--Array类：提供了动态创建数组，以及访问数组的元素的静态方法。该类中的所有方法都是静态方法
----Class类
在 java 的Object类中的申明了数个应该在所有的java类中被改写的methods：
hashCode(), equals(),clone(),toString(),getClass()等，其中的getClass()返回yige
Class 类型的对象。
Class类十分的特殊，它和一般的类一样继承自Object，其实体用以表达java程序运行
时的 class和 interface，也用来表达 enum，array，primitive，Java Types 以及关键字void
，当加载一个类，或者当加载器（class loader）的defineClass（）被JVM调用，便产生一个Class
对象，
Class是Reflection起源，针对任何你想探勘的class（类），唯有现为他产生一个Class
的对象，接下来才能经由后者唤起为数十多个的反射API。
Java允许我们从多种途径为一个类class生成对应的Class对象。
--运用 getClass（）：Object类中的方法，每个类都拥有此方法
String str="abc";
Class cl=str.getClass();
--运用 Class。getSuperclass（）：Class类中的方法，返回该Class的父类的Class
--运用 Class。forName（）静态方法：
--运用 ,Class：类名.class
--运用primitive wrapper classes的TYPE语法： 基本类型包装类的TYPE，如：Integer.TYPE
注意：TYPE的使用，只适合原生（基本）数据类型
----运行时生成instance
想生成对象的实体，在反射动态机制中有两种方法，一个针对无变量的构造方法，一个针对带参数的
构造方法，，如果想调用带参数的构造方法，就比较的麻烦，不能直接调用Class类中的newInstance（）
，而是调用Constructor类中newInstance（）方法，首先准备一个Class[]作为Constructor的参数类型。
然后调用该Class对象的getConstructor（）方法获得一个专属的Constructor的对象，最后再准备一个
Object[]作为Constructor对象昂的newInstance（）方法的实参。
在这里需要说明的是 只有两个类拥有newInstance（）方法，分别是Class类和Constructor类
Class类中的newInstance（）方法是不带参数的，而Constructro类中的newInstance（）方法是带参数的
需要提供必要的参数。
package com.java.kudy.day17_2.reflectDemo;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
public class ClassTest {
/**
* @param args
* 反射的引用:
* ----Class类
在 java 的Object类中的申明了数个应该在所有的java类中被改写的methods：
hashCode(), equals(),clone(),toString(),getClass()等，其中的getClass()返回一个
Class 类型的对象。
Class类十分的特殊，它和一般的类一样继承自Object，其实体用以表达java程序运行
时的 class和 interface，也用来表达 enum，array，primitive，Java Types 以及关键字void
，当加载一个类，或者当加载器（class loader）的defineClass（）被JVM调用，便产生一个Class
对象，
Class是Reflection起源，针对任何你想探勘的class（类），唯有现为他产生一个Class
的对象，接下来才能经由后者唤起为数十多个的反射API。
的类
* @throws ClassNotFoundException
* @throws NoSuchFieldException
* @throws SecurityException
* @throws IllegalAccessException
* @throws IllegalArgumentException
* @throws NoSuchMethodException
* @throws InvocationTargetException
* @throws InstantiationException
*/
public static void main(String[] args) throws ClassNotFoundException,
SecurityException, NoSuchFieldException,
IllegalArgumentException, IllegalAccessException,
NoSuchMethodException, InvocationTargetException,
InstantiationException
{
Object obj = new Person();
//获取实例三中方法
//通过对象.getClass获取到运行时的类
Class clazz1 = obj.getClass(); //获取到一个类
System.out.println(clazz1.getName());
Class clazz2 = Person.class;
System.out.println(clazz2.getName());
String className = "com.java.kudy.day17_2.reflectDemo.Person";
Class clazz3 = Class.forName(className);
System.out.println(clazz3.getName());
Class clazz4 = int.class;
System.out.println(clazz4.getName()); //我们已经映射出一个类
//获取到一个类中所有的属性(成员属性-->字段)
Class clazz = Person.class;
Field[] fields = clazz.getDeclaredFields();
//遍历,.获取每一个成员属性
for(Field field : fields)
{
/*
* 基本的 Java 类型（boolean、byte、char、short、int、long、float 和 double）
* 和关键字 void 也表示为 Class 对象-->所以我们返回它的父类的正确的
*/
String name = field.getName(); //字段名
String type = field.getType().getName(); //类型
System.out.println("类型:"+type+"字段名:"+name);
}
/*
//获取一个obj对象name的属性,并且改变name属性的值
Field declareField = clazz.getDeclaredField("name"); //必须要知道一个字段的名字
declareField.setAccessible(true); //编译检查去掉-->private-->public
Object value = declareField.get(obj); //获取这个对象字段的值
System.out.println(value); //其实这个是打印了对象的toString方法
//如果底层字段的类型为基本类型，则对新值进行自动解包
declareField.set(obj,"kudy"); //异常信息:有可能底层是不能被访问的
Object oj = declareField.get(obj); //返回该字段的值,返回的是object 其实是String类型
System.out.println(oj.toString());*/
/*
* 获取一个类中定义的所有方法
*/
Method[] methods = clazz.getDeclaredMethods();
for(Method method : methods)
{
//1.获取到一个方法的名称
String name = method.getName();
//2.获取到一个方法的修饰符
System.out.print(name+"\t");
int num = method.getModifiers();
if(Modifier.isPublic(num))
System.out.print("public\t");
if(Modifier.isPrivate(num))
System.out.print("Private\t");
if(Modifier.isAbstract(num))
System.out.print("abstractor\t");
//3.获取到形参类型
Class[] parameterTypes = method.getParameterTypes();
for(Class type : parameterTypes)
System.out.print(type.getName()+"\t");
//4.获取到一个返回值类型
Class returnType = method.getReturnType(); //返回一个返回值类型 void
System.out.println(returnType.getName());
System.out.println();
}
/*
* 调用obj的setName方法将名字更改成王五
Method method =clazz.getDeclaredMethod("setName",String.class);
method.setAccessible(true);//去掉安全的检查
method.invoke(obj, "my_kudy");
System.out.println(obj.toString());
*/
//获得类中定义的构造方法
Constructor[] constructors = clazz.getDeclaredConstructors();
for(Constructor constructor : constructors)
{
String name = constructor.getName();
System.out.println("构造方法名为:"+name);
Class[] types = constructor.getParameterTypes();
System.out.println("参数类型为:");
for(Class type : types)
System.out.print(type.getName()+" ");
System.out.println();
}
//调用有参的构造方法,创建对象
//Class cz = String.class
/* Constructor constructor =
clazz.getDeclaredConstructor(String.class,int.class);*/
//基本参数和引用参数都要进行方法调用转换。
Constructor constructor =
clazz.getDeclaredConstructor(new Class[]{String.class,int.class});
Person p =(Person)constructor.newInstance("小细",19);
System.out.println(p);
//获得包名
Package pa = clazz.getPackage();
System.out.println(pa.getName());
//获得该类或接口的修饰符
int mod = clazz.getModifiers();
if(Modifier.isPublic(mod))
System.out.println("public修饰");
if(Modifier.isAbstract(mod))
System.out.println("Abstractor修饰");
}
}
面向接口编程思想:
接口:
package com.java.kudy.day17_2.GraphDemo;
public interface GetGraph {
Double getArea();
}
Round.class
package com.java.kudy.day17_2.GraphDemo;
public class Round implements GetGraph{
private double r;
@Override
public Double getArea() {
return Math.PI*r*r;
}
}
Test类:
package com.java.kudy.day17_2.GraphDemo;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.lang.reflect.Field;
public class Test {
/**
* @param args
* @throws IOException
* @throws ClassNotFoundException
* @throws IllegalAccessException
* @throws IllegalArgumentException
* @throws InstantiationException
*/
public static void main(String[] args) throws IOException, ClassNotFoundException, IllegalArgumentException, IllegalAccessException, InstantiationException
{
BufferedReader br = new
BufferedReader(new InputStreamReader(System.in));
System.out.println("请输入你需要实现的图形:");
String className = br.readLine();
//映射出一个圆
Class clazz = null;
try
{
clazz = Class.forName("com.java.kudy.day17_2.GraphDemo."+className);
}catch(RuntimeException e)
{
System.out.println("您输入的功能还没有实现!!!,等待更新!!");
return ;
}
//获取到一个类.为这个类创建对象
//获取到的类是Round.class
GetGraph g = (GetGraph)clazz.newInstance(); //为这个类创建对象
//本来是一个Person类型的引用,现在是Object
//Object obj = new Person();
//GetGraph g = (GetGraph) Person(); //如果是继承关系.是可以把它更改一吧.
//接口指向实现接口
/*
* Object obj = new Round();
* (GetGraph)
* 接口--> = 实现接口
*/
Field[] fields = clazz.getDeclaredFields();
//遍历所有的属性,并且为他赋值 field.getName()意思: 获取这个属性的名字
for(Field field :fields)
{
System.out.println("请输入"+field.getName()); //获取到这个属性的名字
String value = br.readLine();
field.setAccessible(true);//去掉安全检查
Double d = Double.parseDouble(value);
field.setDouble(g, d);
}
double area = g.getArea();
System.out.println(area);
}
}
小小的案例回顾:
package com.java.kudy.day17_2.GraphDemo;
class A {
public void run()
{
System.out.println("A.running");
}
}
class B extends A
{
public void run()
{
System.out.println("B.running");
}
}
class C extends B
{
public void run()
{
System.out.println("C.running");
}
}
public class TestExtends
{
/*
* 我父类型的引用指向子类型的对象
* 但是我们如果想拿第二个子类指向第一个父类.是不可以的.所以我们必须要把它所指向的类型更改为B
*/
public static void main(String[]args)
{
A a = new C();
a.run();
B b =(B)a;
b.run();
}
}
------------用面向接口的思想实现一个长方形(要求用到反射.)
接口:
package com.java.kudy.day17_2.CollectionTest;
public interface GetSRound {
//实现一个面积
double getArea();
}
实现长方形的方法:
package com.java.kudy.day17_2.CollectionTest;
public class Square implements GetSRound{
private double broder ;
@Override
public double getArea() {
return broder*broder;
}
}
Test:
package com.java.kudy.day17_2.CollectionTest;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.lang.reflect.Field;
import com.java.kudy.day17_2.GraphDemo.GetGraph;
public class Test {
/**
* @param args
* 用反射求一个正方形的面积
* @throws IOException
* @throws ClassNotFoundException
* @throws IllegalAccessException
* @throws InstantiationException
*/
public static void main(String[] args) throws IOException,
ClassNotFoundException,
InstantiationException,
IllegalAccessException
{
//字节流转换成字符流
BufferedReader br =
new BufferedReader(new InputStreamReader(System.in));
System.out.println("请输入你要希望求的图形");
String className = br.readLine(); //获取一个类
System.out.println(className);
Class clazz = null;
try
{
//获取一个类
//Class clazz = Square.class
clazz = Class.forName("com.java.kudy.day17_2.CollectionTest."+className);
}catch (RuntimeException e) {
System.out.println("该功能还没有实现.程序已经退出..");
return;
}
//为这个类创建对象
GetSRound g = (GetSRound)clazz.newInstance(); //接口指向实现接口.由于接口里面的方法已经被实现.所以调用她其实就是调用实现接口里面的方法
Field[] fields = clazz.getDeclaredFields(); //遍历成员变量
for(Field field : fields)
{
//遍历所有的成员变量,为属性赋值
System.out.println("请输入:"+field.getName()); //获取成员变量名
field.setAccessible(true); //去掉私有的检查,因为这个类是私有的就oh啦
String str = br.readLine();
Double value = Double.parseDouble(str);
field.setDouble(g, value);
}
double area = g.getArea();
System.out.println(area);
}
}
分享到：
发表评论
-
javase_22(TCP的理解)
2012-09-02 19:43 559TCP传输 Socket(客户端)和ServerSocket( ... -
javase_21(DUp的学习-->*)
2012-08-30 00:45 693Socket网络编程 网络协议 IP地址与端口号 本 ... -
javase_20(Awt初步认识)
2012-08-27 01:00 940多线程的再度复习.class package com.jav ... -
javase_19(多线程)
2012-08-24 23:32 799进程: 进程是具有一定独立功能的程序关于某个数据集合上的一次 ... -
javase_17(IO的总结)
2012-08-20 11:55 999所有的流在使用完毕时，都需要调用close方法进行关流，释放资 ... -
javase_16(其它流)
2012-08-20 11:52 814IO包中的其他流: 1.打印流 a)PrintWri ... -
javase_16(其它流)
2012-08-20 11:38 0IO包中的其他流: 1.打印流 a)PrintWri ... -
javase_15(File类的应用)
2012-08-19 00:07 802File类:用来将文件或者 ... -
javase_14(字节流)
2012-08-19 00:00 667字节流的抽象基类: InputStream(输入) ... -
javase_13(字符流)
2012-08-19 00:00 527IO(Input OutPut)流 IO流用来处理设备 ... -
javase_12(集合+时间对象)
2012-08-19 00:00 515Map集合 1.Map存储了一系列键值的映射关系2.M ... -
javase_11(集合的理解)
2012-08-19 00:00 829集合类： 为什么使 ... -
javase_10(String类日常操作)
2012-08-18 09:40 794第一: package com.ja ... -
javase_09(面向对象总结)
2012-08-18 09:39 854Java的环境配置 day01 1. 环 ... -
javase_08(基础面试题)
2012-08-18 09:38 662面试题：请说说抽象类和接口的区别 抽象类，使用abstrac ... -
javase_07(继承与设计模式)
2012-08-18 09:36 601/* 子类对象的实 ... -
javase_06(面向对象)
2012-08-18 09:29 652/* 内部类： .在类中定义的类我们称之为内部类, ... -
javase_05(面向对象)
2012-08-16 11:25 0一.构造函数的定义与 ... -
javase_05(面向对象)
2012-08-16 11:22 733一.构造函数的定义与作用 1.函数的名次与类同名2.没有 ... -
javase_04(面向对象)
2012-08-16 11:21 531面向对象：一种编程思想，使用对象来描述生活中的事物：面向对象的 ...
相关推荐
javase_day04_v1_pm_all.zip 基础代码，希望好好学习
JavaSE_8_GUI编程JavaSE_8_GUI编程JavaSE_8_GUI编程JavaSE_8_GUI编程
JavaSE_J2SE_5.0_API_中文文档_html格式
JavaSE的编程资料，包括基础，集合框架，IO流等等
JavaSE_Android精华版-----中文文档API，JavaSE_Android精华版-----中文文档API
02开发工具Eclipse_旺旺老师JavaSE_final02开发工具Eclipse_旺旺老师JavaSE_final
JavaSE__数组及常用算法.ppt
JavaSE_01 源代码 可以参考我上传的一个javase文档！
尚硅谷_JavaSE_第12章_集合与泛型_扩展练习_附带参考答案.md
javase_作业_8.继承作业答案1
VIP09_JavaSE_JavaIO_File_day0307-1.rar
JavaSE_柴林燕_阶段2.docx
JavaSE_11集合框架_旺旺老师.pdf
JavaSE_note 学习过程的笔记，喜欢的带走吧！JavaSE_note 学习过程的笔记，喜欢的带走吧！ JavaSE_note 学习过程的笔记，喜欢的带走吧！
该资源是学习JavaSE基础时，必不可少的帮助文档，此文档是中文版。适合初学者，适合有经验者，遇到断网，脑子断路就要用到它了。
此为JavaSE_all的课程学习文档，适合零基础、刚接触java的人阅读和学习，内附java的基本概念、思想和对应实例
一个简单的ATM机存取代码，可以用来简单学习JavaSE
尚硅谷_陈鑫_JavaSE_【Java概述、环境搭建、标识符、变量、基本数据类型】.md
mldn的学习文档，javase 文档，java基础知识
Java基础，Java的起源，jre,、jvm等介绍。