Java程序设计
2020-12-11 16:38:31 0 举报AI智能生成
为你推荐
查看更多
java从入门到精通
作者其他创作
大纲/内容
Java程序设计
Java中的异常处理及捕获
异常的产生
导致程序中断执行的一种指令流，异常一旦出现没有进行合理处理就会程序中断
处理异常
1.格式一：try{ }catch() { }
e.printstacktrace打印出出现异常的原因
2.格式二：try{ }catch() { } finnaly{}
1.在捕获异常的时候，捕获大的范围的异常一定要放在捕获范围小的异常之后，否则程序无法进行。（exception有它之下的子类）
2.虽然用Exception捕获异常比较方便，但是这样也比好，因为所有一种异常都会按照同一种方式进行处理，若果在一些要求严格的项目里，一定要分开处理会更好。
3.RuntimeException异常
程序在编译的时候不会强制性要求用户处理异常，用户可以根据自己的需要选择性处理异常，如果没有处理又又发生异常，将交给JVM默认处理，也就是RuntimeException的子异常类，可以根据用户选择处理。
4.assert关键字
1.在java中的断言指的是程序执行到某行代码处时一定是预期的结果。
2.用法：例如：public class Testdemo{ public static void main(String args[]){ int num=10; assert num ==20:"num的内容不是20" System.out.println（“num=”+num） } } 使用不会影响程序执行。
5.自定义异常
JAVA的高级应用
正则表达式
认识正则表达式（Regex）
1、概念：正则表达式就是用于描述这些规则的工具。换句话说，正则表达式就是记录文本的规则的代码
2、作用：在编写处理字符串的程序或网页时，经常会有查找符合某些复杂规则的字符串的需要
3、正则表达式的语法：
1.通过String类的matcher方法进行比较
2.通过Pattern和Matcher类
正则表达式的用法
1、Pattern类（模式类）
1、创建一个正则表达式：构造方法是私有的，不可以直接而创建，但可以通过Pattern.complie(String regex)
2、方法
3.返回一个Matcher对象：Pattern.matcher(CharSequence input)
2、Matcher类（匹配类）
2.对前面的字符串警醒匹配，只有匹配到字符串的最前面才返回TRUE:Matcher.lookingAt()
4.返回匹配到字符串中的索引位置：Matcher.start()
5.返回匹配到的字符串的最后一个字符在字符串中的索引位置：Matcher.end()
6.返回匹配到的字符串：Matcher.group()
7.用与返回有多少组（正则表达式中带括号的）：groupCount()
正则表达式的符号
1、元字符
.：所有字符 []:匹配到任意一个字符 [^]:不匹配 [-]:范围 \\d:数字[0-9] \\w:代表小写字母、大写字母、下划线和数字 \\s:代表空白字符(space)
2、限定符
3、分支符号
如果满足其中任意一种规则都应该当成匹配，用“|”把不同的规则分隔开
4、分组
可以用小括号来指定子表达式(也叫做分组)
5、反义
\\W:匹配任意不是字母、数字、下划线、汉子的字符 \\S:匹配任意不是空白符的字符 \\D：匹配任意非数字的字符 \\B：匹配不是单词开头或结束的位置 [^x]：匹配除x外的任意字符 [^aeiou]：匹配除aioue外的任意字符
6、后向引用分组
用于重复搜索前面某个分组匹配的文本。
7、零宽断言
前缀查找，取出后缀：(?=exp)也叫零宽度正预测先行断言
后缀查找，取出前缀：(?<=exp)也叫零宽度正回顾后发断言
8、贪婪与懒惰
多线程
1、进程
（1）概念：系统进行资源分配和调度的一个独立单位
（2）特点：
1.独立性（系统中独立存在的实体，它可以拥有自己独立的资源）
2.动态性（是一个正在系统中活动的指定集合）
3.并发性（多个进程可以在单个处理器上并发执行，多个进程之间不会互相影响）
2、线程
（1）概念：在进程中最小的处理单位。线程是进程的组成部分
（2）用法：
1.一个线程的生命周期
新建状态：使用 new 关键字和 Thread 类或其子类建立一个线程对象后，该线程对象就处于新建状态。它保持这个状态直到程序 start()
就绪状态:：当线程对象调用了start()方法之后，该线程就进入就绪状态。
运行状态:：如果就绪状态的线程获取 CPU 资源，就可以执行 run()，此时线程便处于运行状态。
阻塞状态:：如果一个线程执行了sleep（睡眠）、suspend（挂起）等方法，失去所占用资源之后，该线程就从运行状态进入阻塞状态。
等待阻塞：运行状态中的线程执行 wait() 方法，使线程进入到等待阻塞状态。
同步阻塞：线程在获取 synchronized 同步锁失败(因为同步锁被其他线程占用)。
其他阻塞：通过调用线程的 sleep() 或 join() 发出了 I/O 请求时，线程就会进入到阻塞状态。当sleep() 状态超时，join() 等待线程终止或超时，或者 I/O 处理完毕，线程重新转入就绪状态
死亡状态:：一个运行状态的线程完成任务或者其他终止条件发生时，该线程就切换到终止状态。
2.线程的优先级
每一个 Java 线程都有一个优先级，这样有助于操作系统确定线程的调度顺序。Java 线程的优先级是一个整数，其取值范围是 1 （Thread.MIN_PRIORITY ） - 10 （Thread.MAX_PRIORITY ）。默认情况下，每一个线程都会分配一个优先级 NORM_PRIORITY（5）。
3.创建一个线程的三种方法
（1）通过Thread类继承
（2）通过实现Runnable接口实现
（3）通过Callable和Future创建线程
4.Thread的静态的方法
public static void yield()暂停当前正在执行的线程对象，并执行其他线程。
public static void sleep(long millisec)在指定的毫秒数内让当前正在执行的线程休眠（暂停执行）
public static boolean holdsLock(Object x)当且仅当当前线程在指定的对象上保持监视器锁时，才返回 true。
public static Thread currentThread()返回对当前正在执行的线程对象的引用。
public static void dumpStack()将当前线程的堆栈跟踪打印至标准错误流。
5.Thread类对象调用方法
public void start()使该线程开始执行；Java 虚拟机调用该线程的 run 方法。
public void run()如果该线程是使用独立的 Runnable 运行对象构造的，则调用该 Runnable 对象的 run 方法；否则，该方法不执行任何操作并返回。
public final void setName(String name)改变线程名称，使之与参数 name 相同。
public final void setPriority(int priority) 更改线程的优先级。
public final void setDaemon(boolean on)将该线程标记为守护线程或用户线程。
public final void join(long millisec)等待该线程终止的时间最长为 millis 毫秒。
public void interrupt()中断线程。
public final boolean isAlive()测试线程是否处于活动状态。
6.线程的同步
a:使用同步方法 synchronized void methodA() { \t //要同步的语句 }
b:使用同步块 synchronized(object) { \t //要同步的语句 }
深入理解JAVA语言
1、泛型
1.什么是泛型
表示类中属性或方法的类型标记，在使用的时候才动态设置类型。
2.泛型的几种用法
1、通配符（？可以接收泛型任意类型）
1.？extends类：设置泛型上限，可以在声明上和方法参数上使用； 例如：？extends Number 可以设置Number或者是Number的子类（Interger、Double）
2.?super类：设置泛型下限，方法参数上使用。 例如： ？super String 只能设置String 或者String的父类
2、泛型接口
在接口上定义子类
1.在子类设置泛型
2.为父接口明确定义泛型
3、泛型方法
1.泛型方法不一定非要定义在支持泛型的类里面
2.泛型方法的格式：public class Fanxing{ public static void main (String args[]) { String str=fun("你好"); System.out.println("str"); } public static <T> T fun(T t){ return t;}}
3.泛型的作用及注意：
1.泛型解决的是向下转型所带来的安全隐患，其核心组成就是在声明类或或接口的时候不设置参数或属性类型。
2.“？”可以接收任意的泛型类型，只能够取出，但是不能够修改。
Java的OOP
概念：面向对象编程（Object Oriented Programming）为了解决生活中的实际问题，从而方便沟通和提高效率。
特征：
封装（安全性）
继承（复用性）
多态（扩展性）
OOP的核心思想
类和对象的关系：（1）类是对象的抽象 类是通过分析对象的共同属性和方法，抽象的得到概念 （2）对象是类的实例 对象是实际生活中的一个具体存在，拥有自己的属性和方法。
通过面向对象来编写程序
1、分析并找到类 public class 类名{ }
2、分析这个类中的属性 public class { 属性类型1 属性1....}
3、分析这个类中的方法（行为）
4、实例化类------测试 类名 对象名=new 类名（）；通过对象名.属性进行赋值 通过对象名.方法（实际参数），对方法进行调用
面向对象-----类和对象
1、方法重载
满足条件（要求）
1、必须在同一类中
2、两个或两个以上方法才构成重载关系
3、方法名相同，参数列表不同 ①参数个数不同 ②参数个数相同，至少要保证参数类型相同 ③如果参数个数和类型都相同，至少保证参数顺序不同
好处
1、提高方法识别度
2、给调用者提供自动调用的便捷之处
3、一个功能（方法）可以处理多种形式的参数，提高代码的利用性
2、构造方法
1、构造方法的名字必须和类名一致，且没有void关键字和返回类型
2、每个类中都有一个默认的无参构造方法，如果定义了新的构造方法，则系统自带的无参构造方法将会消失。
3、构造方法只有在new的时候才能被调用，其他任何地方都不能通过{对象.}调用到构造方法(创建对象时自动调用)
构造方法一般用来初始化成员变量，或者完成其他初始化操作。构造方法可以重载
3、this关键字（指的是当前的活动对象，谁调用就指向谁）
分支主题
1、在类中：调用成员变量 this.变量名
2、在类中：调用成员方法 this。方法[实参]
3、在构造方法中，通过this调用其他的构造方法。这句代码必须放在构造方法的第一行this([其他构造方法的参数])
4.类中构造方法互相调用，一定要保留出口。
4、作用域
private 私有的 --------类可见
friendly/default 友好的/默认的 --------包可见
protected 受保护的 --------包可见+不同包子类可见
public 公共的 --------工程可见
5、封装
作用
①隐藏实现细节，对属性做验证控制
②迫使用户通过方法来设置和获取属性数据
③更好维护代码
封装的具体实现
（1）将属性私有化private
(2)利用setter和getter方法来弥补作用于私有化的不便
setter语法：public void set属性名（数据类型 变量）{ this.属性=变量； } ①无返回类型 ②方法名必须按照set方法属性名的第一个首字母要大写 ③ 参数类型必须和属性的数据类型相同。
getter语法：public 返回类型get属性名（）{ return this.属性名} ①有返回类型要和属性数据类型一致 ②属性名第一个首字母要大写 ③没有参数
6、Static 关键字
可以修饰方法和属性，还有代码快（但都必须是静态的）
静态成员不是某个对象独有，而是所有类的成员共享，
静态方法里面不能有非静态成员
非静态方法可以访问静态成员
静态的成员在类的加载之后对象被创建之前被调用，比构造方法还早。
7、继承
概念：可以重复利用父类的属性和方法
特点和特征
1、继承是属于单继承，它能继承父类的属性和方法。子类可以自由扩展父类的属性和方法，并重新重新定义父类的方法。
2、一个子类只有一个父类，但一个父类可以有多个子类
3、系统会自动调用子类重写的方法，子类的作用域范围不能比父类的小（public(同工程目录可见)-->protected(包可见+子类可见)-->默认的(包可见)-->private（类可见））
4、super关键字可以调用父类的属性和方法
继承的过程
class B extends A{} 先调用父类的构造方法在构造子类的构造方法
8、方法的递归调用
概念：一个方法自己调用自己的情况，一定需要一个结束的条件。并且每次调用都要去修改这个结束条件。
注意;
1、递归操作尽量减少，否则可能出现内存溢出。
2.需要设置结束条件，否则会出现死循环。
9、接口的用法
1.什么是接口
如果一个类中只是由抽象方法和全局常量所组成，那么在这种情况下不会将其定义为一个抽象类，而只会将其定义为接口。所谓的接口就属于一个特殊的类，而且这个类只有抽象方法与全局常量。
2.接口的使用原则
①接口必须要有子类，但是此时一个子类可以使用implements关键字实现多个接口；
②接口的子类（不是抽象类），就要覆写接口中的全部抽象方法
③接口对象可以利用子类对象的向上转型进行实例化操作
3.接口的应用----工厂设计模式
class Factory{public static 接口类 getInstance(String className){ if("apple".equals(className)){ return new Apple();}else if("orange".equals(className)){ return new Orange();}else{ return null;}}}
4、接口的应用-----代理设计模式
含义：核心主体在于有一个主题操作接口（可能有多种方法），核心业务主体只完成核心功能。而代理主题只完成所有核心主题的辅助性操作
//定义一个接口 interface Subject{ public void make(); } //通过接口实现一个主体class RealSubject implements Subject{ public void make(){ System.out.println("核心主题")}} //通过接口实现一个辅助class ProxySubject implements Subject{ private Subject subject //定义一个实体对象 public ProxySubject(Subject subject){ //定义一个带一个参数的构造方法 this.subject=subject; } public void Prepare(){ System.out.println("核心主题操作前的准备"); } public void make(){ this.prepare(); this.subject.make(); this.destroy(); } public void destory(){ System.out.println("核心主题操作后的结尾"); } }public class TestDemo{ public static void main(String args[]){ Subject sub new proxySubject(new RealSubject()); sub.make();}}}
10.java的习惯命名法
1.如果类是接口前面加上字母I，例如：IMessage
3.如果是类直接编写，例如 Message
Java的映射
1.实现基本字段的转换
2.解决外键问题（一对一的关系；一对多的关系）
一对多关系
1.书写类、构造方法、输出数据
2.①设置关系数据 （1）先准备好各自独立的对象 （2） 设置关系（如一个城市属于一个省；一个省份有多个城市） ②取出关系数据
3.设置并取出数据
Java的结构
顺序结构：执行顺序与书写顺序一致，是最简单、最基本的结构。
条件结构：按照一定的条件选择性执行
if
if ....else
if.....else if....else
嵌套if
Switch语句
格式：switch(整型变量或字符串变量){case1：......break;case2: .......break;............default.......break;}
注意点if...else if .....else转换为switch语句要点：
1、布尔表达式使用的是等值判断
2、变量必须是整型或字符串
3、case当中对比的值，必须和数据类型兼容
循环结构
while循环
格式：
int i=0;while(赋值运算符/boolean类型true or false){循环体；}
用法：
do.....while 循环
格式:
do{循环体}while（布尔表达式）；
与while 循环不同的是，它至少会执行一次。
for循环及多重嵌套循环
格式：
for（int i=0(初始值);布尔表达式；i++增量）
用法及注意：
1、最先执行初始化部分，可以声明一种类型，可初始化一个或多个循环控制变量，也可以是空语句。
3、执行一次循环后，更新一次循环控制变量。
4、再次检测
循环中的关键字：
break;
跳出最里面的循环，并且继续执行循环下面的语句。
continue
在while语句中或do......while语句中，循环直接跳转到布尔表达式中
在for 循环语句中，循环直接跳转到更新语句中。
当为true时，执行continue，进入到下一次循环。
数组
概念：是同一种数据类型的集合，储存在内存中的一连串的储存空间
数组中的数据类型必须相同或至少兼容（可以存储引用数据类型）
长度一经确定就不允许修改，必须声明或初始化才能被调用
数组的使用(常常和循环一起连用)
1、声明：数据类型 维度 名字 例如：int[] arry /int ary[]
2、初始化
①动态初始化
声明+初始化，赋值是分开的 例如：ass[0]="我们"
②静态初始化
③ 默认初始化
声明+初始化 例如：int[]t=new int[10];
3、for的加强
for(int y:arry){System.out.println(y)}
方法
概念：是完成特定功能的代码块
一般的格式：修饰符 返回值类型 方法名（参数类型 参数名）{ 方法体语句 ； return 返回值 }
做法：
思考步骤：A：返回值的类型，结果的数据类型 B：要传递几个参数以及参数的数据类型
JAVA中的类
String类和包装类
包装类
出现包装类缘由：在面向对象思想中，将基本数据类型装在java.lang中封装的，而在集合中不存在基本数据类型。
包装类与基本数据类型的区别：
1、书写的方式不同，包装类的首字母必需大写
3、使用方式不同：包装类必须通过构造方法初始化，基本数据类型可以直接赋值，集合中只能使用包装类
4、存储位置和方式不同：基本数据类型存在栈中，对象在堆空间中，引用地址在栈中。
5、声明方式不同：包装类需要实例化，在队中分配空间
String 字符串的常用方法
3、检验字符串是否以str开头：startsWith（String str）:boolean
4、检验字符串是否以Str结束：endsWith(String str):boolean
5、获得字符串该索引的位置：charAt(int injdex):char
6、将字符串转化为字符数组：toCharArray():char[]
7、获取字符串的长度：length（）：int
9、返回字符串的索引值：lastIndexof(只是从字符串的后面开始检索)/indexof(String str):int
10、字母的大小写的转换：toUpperCase/toLowerCase:String
11、将字符串换的空格去掉：trim():String
12、比较字符串的值：a.equals(String str):boolean
String字符串的其他方法
1.比较 例如：String stra="Hello" String strb=new String("Hello") String strc=Strb stra =strb false strb=strc true 通过以上分析“==”的确进行了比较，但是比较的并不是字符串对象包含的内容，而是所在内存地址的数值。应采用.equal()进行比较 。（在以后开发重要判断输入的内容是否等于某一字符串时，一定要将比较的字符串写在前面。）
2.字符串不区分大小写的方法
public boolean equalsignoreCase(String anotherstring)
3.判断字符串的内容是否为空：str.isEmpty()或者用.equal(str).
Math 类
1、常量的值：①：记录圆周率：Math.PI ②：记录e的常量：Math.E
2、求三角函数方法：Math.sin/asin/cos/acos/tan/atan
3、角度与弧度相互转化：①Math.toDegrees(弧度转为角度)； ②Math.toRadians(角度转弧度)
5、比较大小：①得到不小于某数的最大整数 Math.ceil ②得到不大于某数的最大整数 Math.floor ③求两数中的最大/最小 Math.max/min
日期类
1、util.Date
1、获取时间戳：long time=d1.getTime();
2、获取当前的系统时间：Date d2=new Date();
3、将long类型的数字转化为对应的时间：Date d3=new Date(1234565555665L);
4、将字符串转化为日期类型:Date d4=new Date("2018/08/22")
6、通过getxxxx()方法，获取对应的时间 int year=d6.getYear(); 通过setXX()方法设置对应的时间 年份：获取要+1900，设置年份要-1900；月份：从0-11，一月到12月，星期：从0-6，星期天到星期六
2、sql.Date
1、sql.Date 只能表示日期
2、sql.Time 只能表示时间
3、sql.TimeStamp 能表示日期和时间
3、日历类Calendar
特点：是一个抽象类，通过静态方法getInstance实例对象 Calendar c1=Calendar.getInstance();
常用方法：
格式化日期
步骤：① Date d10=new Date（）；②SimpleDateFormat sdf=new SimpleDateFormat("yyyy年MM月dd日......")
格式代表：
yyyy 年 MM 月 dd 日 HH/hh 24小时制/12小时制 mm 两位数的分 ss 两位数的秒 E 中文的星期 a 中文的上午/下午
File类
1、File类本身只是操作文件的，不涉及内容
2、File类中重要的方法
1.设置完整路径：public File (String pathname)
2.删除文件 ：public boolean delete()
3.判断文件是否存在 ： public boolean exists()
4.找到父路径：public File getparentFile()
5.创建目录：public boolean mikdirs()
3、在使用File类操作的时候路径的分隔符使用: file.separator
4.File类中进行输入与输出操作步骤
1.通过File类定义一个要操作的文件的路径
2.通过字节流或者字符流的子类对象为父类对象实例化
3.进行数据的读（输入）、写（输出）操作
4.数据流属于资源操作，资源操作必修关闭
5、java.io的两类流
1.字节流（JDK 1.0）：Inputstream、OutputStream
Outputstream:
三个输出的方法
输出单个字节：public abstract void write(int b)
输出全部字节数组：public void write(byte [] b)
子类 FileOutputStream
创建或者覆盖已有的文件：Public FileOutputStream(File file)
InputStream
FileInputStream
BufferedInputStream
DateInputStream
PushbakInputStream
ByteArrayInputStream
2.字符流（JDK 1.1）：Reader 、Writer
Reader
BufferedReader
InputStreamReader
FileReader
ByteArrayReader
Writer
OutputStreamWriter
FileWriter
charArrayWriter
Java数据类型和变量及扫描仪
1.基本数据类型
1、char（字符型）2、Boolean（布尔型）3、byte（字节型）{1字节 范围：-128-127} 4、float（单精度字节） 5、double（双精度）6、long（长整型） {8字节 范围：-2^63-2^63-1} 7、short（短整型） {2字节 范围：-2^15-2^15-1} 8、int（整型） {4字节 范围：-2^31-2^31-1}
2.变量
定义：是一个数据储存空间。通过变量名可以快速找到储存的数据。
用法
先声明变量再赋值。例如：int age=18；
潜规则：
1、Java是大小写敏感的语言，类名首字母大写，其他（包名、方法名、变量名）用小写
2、是由字母、数字、下划线、美元符号（$）组成
少用下划线、常亮随时用定义
3.数据类型转换
（1）自动转换:j级别低的数据类型可以自动转换成级别高的数据类型 例如：byteb1=20;byte b2=50; int b=b1+b2;(数据类型的优先级：（char、byte、short）<int<long<float<double)
(2)强制类型转换：
1、一般的声明变量的可直接在Java中通过
2、如果是低级型Char型，向高级型（整型）转换时，会自动转换为对应的ASII码值 例如：char='a';int i=c;System.out.println("结果为："+i);输出：output:97;
4、将级别高的数据转换为级别低的数据时，可以强制类型转换 例如：byte b1=20;byte b2=60; char b=(char)(b1+b2);
5、数据自动提升
4.关于扫描仪
作用：获取控制台输入的内容
步骤：
1\\导包：import java.util.Scanner;
2\\实例化扫描仪的类：Scanner input=new Scanner(System.in);
3\\获取控制台的类容，并转换成对应的类型：int----input.nextInt(); double--input.nextDouble();String----input.next();
5.获取随机数的方法：
6.判断数据是否出错的方法：
if(input.hasNextInt()){}else{System.out.println("请输入规范的数值。")}
7.常见的数据转换、赋值问题：
①转换为百分数方法一：
1、导包：import java.text.DecimalFormat;
2、声明：DecimalFormat df=new DecialFormat(0.00%)(注意是输出的数是double型)
3、输出：System.out.println(""+(df.format(p)));
②转换为百分数的方法二：
③字符串的判断问题
if(b.equals("所要判断字符串的值")){}
8.数组的定义及使用
1.认识数组
概念：数组就是一组相关变量的集合。
数组的开辟步骤：（数组不能越界）
1.声明数组：数据类型 数组名称 []=new 数据类型[长度]；
2.开辟数组：数据类型 [] 数据名称=new 数据类型[长度]；
缺陷：数组长度不能改变
2.二维数组
1.静态初始化
2.动态初始化
3.数组的操作方法
1.数组拷贝
system.arraycopy(数组1，数值，数组2，数值)
2.数组排序
java.util.Array.sort();
4.对象数组
Java的运算符
运算符分类
按功能分：算术运算符、关系运算符、逻辑运算符、位运算符、移位运算符、赋值运算符、三值运算符
按操作数分：单目运算符、双目运算符、三目运算符
算术运算符
种类：
“+”、“-”、“*”、“/”：“%”（取模）；“++”（自增）；“--”（自减）
(2)自增：前自增 ++i （先自增再赋值） 后自增 i++ （先赋值，后自增）例如：i=2 ++i=3，i=3；i++=2，i=3；
（3）自减同自加同理
关系运算符
小规则：
①char类型在比较的时候，比较的是字符ASCII码值
②float和double再做==比较时，可能会有精度丢失（false）
运算符的优先级
算术运算符>关系运算符
优先级从大到小是：
①++、--
②*、/、%
③+、-
④<、<=、<、>=
⑤==、！=
⑥！=、==
⑦& |
⑧&& || ？：
逻辑运算符
①逻辑非（！）表示取反 例如：！true=flase； ②逻辑与（&&）两个条件为true才为真； ③逻辑并（||）只要满足任一条件即为真；
三目运算符
布尔表达式？值1：值2；
当为true时，执行值1；当为flase时，执行值2；（注意：值1和值2必须保持兼容）
赋值运算符
+=、-=、*=、/=、%=、>>=、|=、&=、等等几种运算符组合形成的。
例如：a+=b相当于a=a+b;
认识java
Java的发展
Java语言是由SUN（斯坦福大学公司）推出的高级编程语言，应用于电子产品中。09年4月美国甲骨文公司74亿美元收购SUN，取得Java版权。
Java语言特点
简单、面向对象、分布性、安全性、体系结构中立、高性能、跨平台、可移植、多线程以及动态性
Java的运行原理
代码的基本结构（HelloWorld.java)
Public class HelloWorld(首字母大写){ public static void main(String[] args){System.out.print("输出要显示的数值")；}}
Java代码的注意点
Class定义的是一个类，与Java源文件相同
Public表示公有的，是相对其他类的可见性
main是程序的起点，起程序从这里开始执行
代码以分号结束，类名和一些关键字严格区分大小写，类名的名称必须是字母或下划线
注释及命令
三种注释类型
单行注释//
多行注释/* */
文档注释/** */
几种命令
Windows+R 打开运行对话框
CD 文件路径 切换到对应的文件夹中
所属盘： 回车 转到对应盘中
Javac 文件名.java 生成Class文件 Java 文件名 执行程序
换行及空格方法
换行：println("") 、 \； 空格：\\t
Java中输入的快捷键
sysout+alt+/或者alt+?:实现System.out.println();
自动导包或者删除包：Ctrl+shift+o
将窗口最大化：Ctrl+m
自动注释当前行或选择多行：Ctrl+/ Ctrl+Shift+/自动注释选择的代码块
格式化代码：Ctrl+shift+f
快速OUTline视图：Ctrl+o 快速转换编辑器：Ctrl+e 在前行上或下创建空白：Ctrl+enter/Ctrl+enter+shift
简单Java类的编写原则
.类名称=表名称
.属性名称（类型）=表字段（类型）
一个实例化对象=一行记录
多个实例化对象（对象数组）=多行记录
引用关系=外键约束
0 条评论
回复 删除
下一页
