Java，
Java，
构造函数
作用：构造函数会在实例化对象时自动调用
命名跟类名一样，没有返回值，不能使用return返回一个值，但是可以单独写一个return
支持重载
例如：public person(){ return; };
this关键字
指代当前对象（一般是指成员方法，或者成员变量）
可以在一个方法中调用另外一个方法：this.成员方法（）；/成员方法（）；
构造函数只能在另外一个构造函数中调用另外一个构造函数：
this();（必须位于第一行，且只能出现一次）
不能在方法中调用构造函数
垃圾回收函数(当一个对象在内存中释放时，finalize 方法会自动调用)
public void finalize(){ }
System.gc()； 通知java虚拟机进行垃圾回收
static
声明在类中
作用：可以被类的所有对象共享
static String name;
public static void student(){ ｝；
static｛｝；
作用：静态变量和方法被所有实例共享，不需要实例化就可以直接使用
类名.变量名/方法名 访问
静态方法（main）只能直接调用同类的静态方法和静态变量，如果非静态方法则需要创建实例
静态代码块被类加载时，main之前的静态代码块会先于main之前执行，由于类只加载一次，
后面的static代码块便不再执行
不能引用任何this /super调用
成员内部类
一个类中包含其他类
内部类可以在外部类中使用，并能访问外部类的成员（相当于局部方法未定义变量使用成员变量）
当外部类去访问内部类，则需要通过外部类对象去创建内部类对象
外部类名.内部类名 变量名=new 外部类名（）.new 内部类名（）；
匿名内部类
格式：new 父类（参数列表）或父接口
{
//匿名内部类实现部分
}
如果方法的参数被定义一个接口类型，那么就需要定义一个类来实现接口，可以使用匿名内部类
interface animal{
void shout();
}
public class a{}
main内
//定义一个内部类cat实现animal接口
class cat implements animal{
//实现shout方法
public void shout(){
System.out.println("喵喵。。。");
} }
//调用animalshout()方法并传入cat对象
}
animalShout(new cat());
public static void animalshout(animal an){
an.shout();
animalshout(new cat()){
// 内部类的对象，
相当于创建了一个实例对象并将对象传给animalshout方法
new animal()的括号表示创建对象为animal的子类，该子类是匿名的
public void shout(){
System.out.println("喵喵。。。")
}
}
所有的对象都放在堆里
全局变量放在栈里 内存有限
父类的全局变量为私有时，子类及其以外的类都不能访问
父类的构造函数子类也无法继承
访问父类的私有函数有俩种：
在该私有成员所在类通过定义新的方法来访问（该方法不能是私有）
通过所在类的构造函数来实现对该成员的访问
所有的代码都是在内存里运行的
继承
子类在继承父类的时候，会自动拥有父类的所有成员
类只支持单继承不允许多重继承，相当于一个类只能有一个直接父类
多个类可以继承一个父类（多个子类继承一个父类）
多层继承，一个类的父类再去继承另外的父类
重写父类的条件：相同的方法名，参数列表，以及返回值
当重写父类的时候，便只会调用子类的方法而不会再调用父类的方法
class animal{ }
class dog extends animal{}
super
作用：解决子类重写对象无法访问父类重写的方法，用super来访问父类的成员（变量，方法，构造函数）
在子类中使用 super.成员变量 super.成员方法
调用父类的构造函数 super(参数) （根据成员方法中是否有参数决定）必须位于第一行，并且只能出现一次
调用父类的私有（隐藏成员）
父类会比子类在继承的过程中先执行
super总是会调用离它最近的那个父类
final
可以用于修饰类，变量和方法
具有以下特性：
final修饰的类不能被继承
final修饰的方法不能被子类重写
final修饰的变量只能赋值一次
抽象类 abstract
只需要定义该有的功能而不定义具体功能怎么实现
注意：1.包含抽象方法的类必须声明为抽象类 2 .抽象类是不可以被实例化的 3抽象方法是没有方法体的
抽象方法是没有方法体的不可以被调用，如果要调用，则需要创建一个子类去实现抽象方法
普通方法可以出现在抽象类中，但也需要创建一个子类的对象去调用
abstract class animal{//抽象类
abstract void shout(); 抽象方法
}
class Dog extends animal{
void shout(){
System.out.prinln("具体实现的方法")；
}
main//创建Dog（子类）对象调用
接口
条件：如果一个抽象类中的所有方法都是抽象类
组成：接口是由属性常量和抽象方法组成的特殊类
目的：为了克服单继承的限制
public interface 接口 【extends 接口1，接口2】{
【public static final】 数据类型 常量名=值；//静态常量
【public abstract】 返回值 抽象方法名（参数列表）；//抽象方法
}
注意：由于接口中都是抽象方法，因此不能通过实例化对象的方式来调用接口中的方法
此时需要定义一个类并使用implements关键字实现接口中的所有方法。
属性和方法只能是常量，抽象
接口声明成什么样的类型，接口中的方法就为什么类型
一个类可以implements可以实现多个接口
例如：class brid implements egg,bridegg{ }
一个接口可以extends继承多个接口
interfac eat extends run,fly{ }
一个类可以在继承另一个类的同时实现多个接口，并且extends必须位于implements之前
class dog extends candia implements Animal{ }
class 类名 【extends <超类名>】【implements <接口1>,<接口2>，…】
例如：
interface Animal{
String xingwei="动物的行为"；//
void breathe（）；//默认为抽象方法
}
class dog implents animal { //dog类实现了animal接口
public void breathe(){
System.out.println(xingwei+"狗在呼吸")；
main//创建Dog（子类）对象调用
}
注意：一个类实现一个接口，必须把接口中的所有方法在（实现接口的那个类）实现方法，如果不能
必须写一个空方法，当一个类实现接口时，如果这个类是抽象类（接口类实现接口它的方法相当于抽象
方法）则只需要将部分方法实现，否则需要实现所有的方法
多态
定义：由于参数类型不同而导致执行效果各异的现象
interface animal{
void shour();
}
class dog implements animal{
void shout(){
System.out.println("汪汪");
}
class cat implements animal{
void shout(){
System.out.println("喵喵");
}
}
main内
//可以用父类的对象名去指向子类的对象
animal a=new dog();将父类animal对象a指向子类的dog对象
animal b=new cat();将父类animal对象b指向子类的cat对象
animalshout(a); 将a作为参数传入
animalshout(b); 将b作为参数传入
//定义一个静态的animalshout方法，接收一个animal类型的参数
public static void animalshout(animal an){
an.shout(); //调用实际的参数
}
对象的类型转换
1
animal a=new dog(); // 将dog对象当作animal类型来使用
animal b=new cat(); //将cat对象当作animal类型来使用
public static void animalshout(animal an){ //接收一个animal类型的参数
an.shout(); //调用实际的参数
}
2
将子类对象当作父类使用时不需要任何显示地声明，此时不能通过父类变量去调用子类中特有的方法
cat b=new cat();//创建cat类的实例对象
animalshout(b);
public static void animalshout(animal an){ //将cat对象当作父类animal对象传入
an.shout(); //调用实际的参数
an.sleept(); //sleep是子类的对象，无法调用会报错
可以通过 强制转换 cat CAT=(cat) animal;//将animal类型强转为cat类型，sleep为cat类的方法
这时便可以直接调用
向上转型 animal a=new cat(); //将父类对象a指向子类的对象
向下转型 cat CAT=(cat) animal; //将父类animal转换为子类cat型
3
dog b=new dog();//创建cat类的实例对象
animalshout(b);
public static void animalshout(animal an){ //将dog对象当作父类animal对象传入
cat CAT=(cat) animal;
an.shout();
an.sleept();
//dog类型不能转换为cat类型，在传入对象时，接收的是一个dog对象
然后又强制转换成为cat型，dog类型不能转换为cat类型，因为它们是同级别的子类
可以用 if(animal instance of cat ){
//判断cat类是否是animal类的实例对象或者子类实例（是否为cat对象），是则转换为cat
这样就算dog被传进来也不会强制转换为cat
cat CAT=(cat) animal;
an.shout();
an.sleept();
}
语法：对象（或者对象引用变量）instanceof类（或接口)
Object 类
每个类都直接或间接继承自该类，所有对象（包括数组）都实现了这个类的方法
常用方法
equals() //判断某个对象是否与此对象值相等 == 代表同一个
getClass() //返回此Object的运行时类
hashCode() //返回该对象的嘻哈码值
toString() //返回该对象的字符串表示
异常
Exception，运行时报错，可以处理的错误
RuntimeException 运行异常，没有处理也可以正常运行
编译异常 ，必须处理否则无法执行
error错误类 系统内部的错误，无法恢复
Throwable 常用方法
String getMessage() 返回throwable的详细字符串 描述异常
void printStackTrace() 追踪输出至标准错误流 追踪异常
void printStrackTrace(PrintStream s) 追踪输出到指定的输出流
try …catch 和finally
try{
//可能会出错的语句
}
catch(ExceptionType(Exception 类及其子类) e){
//异常处理的语句
e.printStackTrace();//打印捕获的异常信息
}
1如果程序可能出现异常却没有被try.包括起来，之后的所有语句都不会执行
2 如过可能出现异常的语句被try包括起来，那么没有异常的时候它不会执行catch中的语句
而是正常执行
3 如果发生异常的语句被try包括起来，try语句里出现异常语句之后的语句都不会执行，
转而执行catch语句，执行完后，看catch后是否有return,finally会执行，后面的便不会再执行
4 try …catch,finally中间不能写语句
throws
声明抛出异常
public static void divide(int x,int y)throws Exception{
//异常语句
}
自定义异常
public helloException extends Exception{
public helloException(){
super();//调用Exception无参的构造方法；
}
public helloException(){
super(message);//调用Exception有参的构造方法；
}
}
public class example{
pubic static void main(String[] args){
try{
int result=divide(4,-2);
System.out.println(result);
}
catch(helloException e){
System.out.println(e.getMessage);//打印捕获异常的信息
}
}
public static int divide(int x,int y) throws helloException{
if(y>0){
throw new helloException("除数是负数")；//用throw关键字声明异常对象
}
int result=x/y;
return result;
}
}
throws用于在方法中声明抛出异常的实例对象
throw 声明异常对象
JAVA API
系统提供的功能函数–API 应用程序接口（Application Programming Interface）
Stirng类 相当于常量,长度不可调整
StringBuffer 内容，长度可改变，调整
String的初始化
String a=new String();
String a=new String("name");
char[] charArray=new char[]("a","b","c"); //字符数组
String类的常用方法
String s="ab cdbef";
String s1="abc";
s.indexOf('a'); //返回指定字符第一次出现的索引 字符
s. lastindexOf('s'); //返回最后一次出现的索引
s. indexOf( "ab"); //返回指定字符串第一次出现的索引 字符串
s indexOf("ab") //返回指定字符串最后一次出现的索引
s.equals(s1); //将字符串与指定的字符串比较
s.contains("abcd") //判断此字符串是否包含指定的字符串
char[] chararr=s.toCharArray(); //将此字符串转换成字符数组
s.split("-"); //将原来的字符串转换成若干个子字符串
s.replace("替换"，“被替换的内容”) //将指定字符串替换成其他字符串
s.trim() //去除字符串两端的空格
s.substring(4); //截取字符串，从第四个到末尾 dbef
s.substring(4,6) //截取字符串，从第四个到第六个 db
注意：substring的第一个是从0开始的索引位置，第2个参数代表截取的结束位置（不包含在截取字符串内）
如果String字符串在获取字符，当访问字符串时，如果索引不存在，则会发生StringIndexOfBoundsException(字符串角标越界异常)
StringBuffer
字符串缓冲区
StringBuffer s=new StringBuffer();//定义一个字符串缓存区
s.append("abcd") //添加参数到StringBuffer对象中 abcd
s.insert(2,''124"); //在指定位置插入字符串 abc124d
s.deleteCharAt(2) //指定位置删除 ab124d
s.delete(1,5); //指定范围删除 a
s.replace(1,2,"l"); //将1到2的范围用l代替
区别
String 表示数据类型 可以用+连接 覆盖了Object类equals方法
StringBuffer 对自字符的增删 不能用+连接 未覆盖
System类
System常用方法
1 static void exit(); //终止正在运行的虚拟机
static void arraycopy(原数组，原数组起始位置，目标数组，目标数组起始位置，原数组个数) // 将原数组复制到指定的数组
int[] a={1,2,3,4,5,6,7};
int[] b={2,35,6,7,8};
2 currentTimeMillis() // 返回当前时间与1970年1月1日0点0分0秒之间的时间差 单位：毫秒
main内
long strattime=System.currentTimeMillis()；//循环开始的当前时间
int sum=0;
for(int i=0;i<100000000;i++){
sum+=i;
}
long endtime=System.currentTimeMillis()；//循环结束后的当前时间
System.out.println(endTime-stratTime);
3
static Properties getProperties() //获取当前系统属性
System.arraycopy(a,2,b,3,4);
for(int i=0; i<b.length;i++){
System.out.println(b[i]);
}
main内
//获取当前系统属性
Properties properties=System.getProperties();
System.out.println("prorerties");
Set<String> propertyNames=Properties.stringPropertyName(); //获取所有系统属性的key(属性名)，返回
set方法
泛型 ：临时存放
for(String key:propertyNames){ //获取当前键key（属性名）所对应的值（属性值） 加强型for循环
String value=System.getProperty(key);
System.out.println(key,value)
}
// 加强型for循环
for(int key:arr)
for(int arr[i]:arr)
System.out.println(key); System.out.println(arr[i]);
for(数据类型 集合元素值：集合式数组)
Runtime类
Runtime rt=Runtime.getRuntime();//获取
system.out.println(“处理器的个数：”+rt.availableProcessors())；
system.out.println(“空闲内存数量：”+rt.freeMemory())；
system.out.println(“最大可用内存数量：”+rt.maxMemory())；
System.out.println("该方法用于执行一个dos命令"+exec("notepad.exe"));
Thread.sleep(3000);//程序休眠3秒
process.destory();//杀掉进程
Math类
Math.abs(-1);//绝对值 1
Math.ceil(5.6);//求大于参数的最小整数 6.0
Math.floor(5.6);//求小于参数的最大整数 -5.0
Math.round(-4.6);//四舍五入 -5
Math.random();//随机数
Random类
Random r=new Randow(); //Random r=new Randow(12);
for(int x=0;x<10;x++){
System.out.println(r.nextInt(100)); //nextBoolean(),next..()
}
//随机生成100个整数
包装类
装箱 ——将基本数据类型的值转换为引用数据类型 int——Integer char——character其余的都大写
拆箱——将引用类型的对象转换为基本数据类型
int a=10;
Integer a=new Integer（a）；//自动装箱
Integer a=new Integer(10);
int b=a; //自动拆箱
集合
Collection单列
List 有序，可重复 ArrayList 一般常用于信息检索
LinkedList 常用于增加删除
set无序，不可重复 HashSet LinkedHashSet
Map双列 键值对 HashMap 适用于信息检索 ，不能出现重复的键 Map map=new HashMap();
LinkedHashMap 适用于增删 Map <String,String> linkedMap=new LinkedHashMap<String,String>();
Iterator
遍历collection 中的元素
Properties
主要用于存储字符串类型的键和值
Properties p=new Properties();
p.setProperties("color","red");//设置元素值
p.propertyNames(); //获取集合当中的key集合
p.property(key); //获取对应的键值
通过key遍历所有的value
Set keySet=map.keySet(); //Map对象的KEY集合
通过关系（entrySet）来遍历所有的元素,包含key，value
Set entrySet=map.entrySet();
直接获取Map 对象所有的Value值
Collection values=map.values();
输入输出
IO流
字节流 字符流
字节输入流 （文件等输入到程序中） 字符输入流
字节输出流 （程序输出到文件中） 字符输出流
FileInputStream in=new FileInputStream(“test.txt”,true);//当有true时表示追加，输入的内容不会删除，而是接着下面输入
字节输入流 字节输出流
InputStream （硬盘——>内存 , 一个一个的读）字节流 OutputStream 内存——>硬盘
FileInputStream (文件——>内存 ，全部读出来 )字节缓冲区 FileOutputStream 内存——>文件
BufferedInputStream 字节缓冲流 BuffereOutputStream
字节输入流转换成字符输入流 InputStreamReader
字节输出流转换成字符输出流 OutputStreamWriter
字符输入流 字符输出流
Reader Writer
FileReader Filewriter
BufferedReader BuffereWriter
FILE类
File file=new File("D:\\eclipse\hello");
方法
getParent();//返回文件的父路径
canRead();//是否可读
isFile();//判断是否是文件（不是目录），是返回true,否返回false
isDirectory();//判断是否是目录（不是文件），是返回true,否返回false
list();//列出指定目录的全部内容的名称
deleteDir();//删除文件
图形用户界面GUI
导入awt,swing 包
布局管理器 ：
Frame f=new Frame();
f.setLayout(new FlowLayout(fFlowLayout,LEFT,20,30));流式布局管理器
f.setLayout(new BorderLayout()); 边界
f.setLayout(new GridLayout（3,3）) 网格
事件处理的原理和机制
一、几种事件
1、窗体事件 WindowEvent
2、鼠标事件 MouseEvent
3、键盘事件 KeyEvent
二、事件监听器(接口，必须实现所有的方法)
1、窗体事件监听器 WindowListener
2、鼠标事件监听器 MouseListener
3、键盘事件监听器 KeyListener
三、事件适配器（类，仅重写需要的方法）
1、窗体事件适配器 WindowAdapter
2、鼠标事件适配器 MouseAdapter
3、键盘事件适配器 KeyAdatper
四、将监听器装上被监听对象
1、装窗体监听器
Frame f = new Frame();
f.addWindowListener(窗体监听器对象);
2、装鼠标监听器
Button btn = new Button();
btn.addMouseListener(鼠标监听器对象);
3、装键盘监听器
TextField tf = new TextField();
tf.addKeyListener(键盘监听器对象);
AWT绘图
Swing
相关文章
- 暂无相关文章
用户点评