Java基础复习资料------继承与多态 / jdk安装/记事本程序运行/变量/对象,属性,方法,构造方法,重载方法,重写方法/多态/异常/多线程等等...持续更新中 (生活举例+代码举例+图片))
Java基础复习资料
- jdk安装
- 运行记事本程序
- 变量/常量
- 程序结构
- 八大基本数据类型
- 对象
-
- 属性
- 方法
-
- 1.构造方法
- 2.重载方法
- 3.重写方法
- 其他函数方法
-
- this
- super
- 类
-
- 继承 extends
- 接口 implements / interface
- 多态(考)
- 包装类
- 抽象类 abstract
- 数据封装
-
- set / get 方法
- 异常
- 多线程
- 常用工具类
- 集合框架
-
- Iterator 迭代器(遍历) 父接口
- 泛型 e / E
- 栈与队列
- 文件操作
- 文件操作输入输出流 (考)
- 待续、更新中
jdk安装
内容过多,请看往期链接: jdk/idea/环境变量配置
运行记事本程序
内容过多,请看往期链接: java编译运行记事本文件
变量/常量
变量:
成员变量( 类里 ):
又叫 全局变量
成员变量是在类中声明的变量，它们属于对象的一部分成员变量的
作用域: 整个类，在类中的任何方法、构造函数或代码块中都可以访问
局部变量 ( 方法里):
局部变量是在方法、构造函数或代码块内部声明的变量
作用域: 只在声明它的作用域内可见
常量:
常量用final 修饰, 且常量名大写
final String STU_NAME=“zs”;
程序结构
顺序
所有程序都按从前往后的顺序执行
条件
if -else
if else if else if …else 多重
嵌套if
switch
循环
for 循环
代码:
public class Hello
{
public static void main(String[] args)
{
Scanner input=new Scanner(System.in);
System.out.println("输入字符: ");
String a=input.nextLine();
System.out.println("输出: "+a);
// 数据类型[] 数组名 = new 数据类型[大小] ;
int [] shu=new int[3];
// 数组输入
for( int i=0; i<shu.length; i++ )
{
System.out.println(" 输入提示信息: ");
shu[i] = input.nextInt(); //字符 ; 整型 input.nextInt()
}
// 数组输出
for( int i=0; i<shu.length; i++ )
{
System.out.println("输出: "+ shu[i]); //字符 ; 整型 input.nextInt()
}
}
}
八大基本数据类型
基本数据类型:
整数类型: 字节型byte / 短整型short /整型int /长整型long
浮点类型: 单精度float /双精度double
字符类型:char
布尔类型: true / false
引用数据类型:
数组
类
接口
字符串
代码:
/**
声明8个基本数据类型变量，并输出
*/
public class printvalues5 {
public static void main(String[] args) {
int intValue = 10;
long longValue = 1000000L;
float floatValue = 9.8f;
double doubleValue = 9.9;
char charValue = 'l';
boolean booleanValue = true;
byte byteValue = 127;
short shortValue = 6553;
System.out.println("int值: " + intValue);
System.out.println("long值: " + longValue);
System.out.println("float值: " + floatValue);
System.out.println("double值: " + doubleValue);
System.out.println("char值: " + charValue);
System.out.println("boolean值: " + booleanValue);
System.out.println("byte值: " + byteValue);
System.out.println("short值: " + shortValue);
}
}
对象
又称: (实体、实例)
万物皆是对象，描述客观事物的一个实体，由一组属性和方法构成
语法:
类名 对象名= new 类名();
属性
描述对象特点的词(年龄、身高等)；变量的声明
例如:
我这个个体的 身高, 体重, 爱好等
方法
又名: 操作、动作、函数
例如: 购买商品这个动作
语法：
访问修饰符 返回值类型 方法名 ( 参数列表)
{ 方法体 }
访问修饰符(访问权限):
public、Protected、Default( 默认的, 什么都不写 )、Private (权限由公开--------到——私有)
返回值类型:
void ; 无需return ;
八中数据类型 ; 其他类型 都需return ; return 值;
return:
void 无需return ; / 其他类型 都需return ; return 值;
return 只能返回一个值 ; 返回多个值,打包成一个数组或对象 ,进行返回
方法名:
格式: 字母 数字 $ _
为动名词词组, 方法名首字母小写
参数:
带参, 写活
不带参, 写死
代码:
public void buyshop()
{
System.out.println(shopname);
}
成员方法
成员，都在一个类内：叫成员变量 或 成员方法
1.构造方法
又名
构造方法== 构造函数==构造器
初始化对象: 类名 对象名=new 类名()
作用:
创建对象的同时对属性赋值(初始化对象), 通过调用当前类的构造方法来实现创造对象操作
语法：
访问修饰符 类名() { }
特点：
方法名与类名相同、无返回值类型、同一个类中可有多个构造方法
系统自带构造方法:
public Student() //系统自带, jvm虚拟机默认提供一个无参数构造方法
{ }
但，一旦写一个带参构造方法，虚拟机就不在提供系统的构造方法.
一般写法：写个带参构造，同时再写一个无参构造
三个方法区别:
相同：1方法名 2同一个类里面
不同：1参数不同：参数个数不同、参数类型不同、参数顺序不同
代码:
1 带参构造方法
学生老师类:
// 此时类名为 Student
//学生类 a,b
public class Student
{
String name;
int age;
public Student(String name, int age) // 带参数的 构造方法
{
this.name = name;
this.age = age;
}
// 自己写的如下
public Student() // 不带参数构造
{
name = "nihao";
age = 12;
}
// 系统自带的
public Student()
{
}
}
// 运行
public class Runtest
{
public static void main(String[] args)
{
Student a = new Student("nihao2", 12);
a.printInfo();
//一般写法,初始化对象:
// a.name = "nihao";
// a.age = 12;
// a.printInfo();
}
}
2 无参构造/有参构造
public class StrudentCanshu
{
String name, type, hoppy;
int age;
public void printInfo()
{
System.out.println(name);
System.out.println(type);
System.out.println(hoppy);
System.out.println(age);
}
// 构造方法 -无参
public StrudentCanshu()
{
name = "无参";
type = "1版1";
hoppy = "划水";
age = 101;
}
// 构造方法-有参
public StrudentCanshu(String name, String type, String hoppy, int age)
{
this.name = name; // this表示当前对象; 将该方法的参数name的值赋给当前对象的name属性
this.type = type;
this.hoppy = hoppy;
this.age = age;
}
}
// 运行
public class RunStudent
{
public static void main(String[] args)
{
StrudentCanshu wo0=new StrudentCanshu(); // 无参构造
wo0.printInfo(); //普通输出
System.out.println(); //空行
StrudentCanshu wo=new StrudentCanshu("你好有参","1班2","摸鱼",211); //有参构造
wo.printInfo();
}
}
结果:
2.重载方法
条件:
同一个类中
有多个方法且方法名相同 ( 可以有返回值类型 )
参数不同；
作用:
根据不同的参数类型和个数来调用不同的方法
区别构造方法:
构造方法自动满足重载，构造方法一定是重载方法，重载方法不一定是构造方法
代码举例:
//1 构造方法:
// 还是上面的例子, 此时类名为 Student, 两者 互为重载方法
public class Student
{
public Student(String name, int age) // 带参数的 构造方法
{
this.name = name;
this.age = age;
}
// 自己写的如下
public Student() // 不带参数构造
{
name = "nihao";
age = 12;
}
// 2 自己写的方法:
// 重载方法:
public void printInfo() // 方法名为printinfo, 不为类名 Student,不满足构造方法
{
System.out.println(name);
System.out.println(age);
}
// 重载方法：上下两个互为
public void printInfo(int num)
{
}
}
// 运行
public class Runtest
{
public static void main(String[] args)
{
Student a = new Student("nihao2", 12);
a.printInfo();
Student b=new Student();
b.printInfo();
}
}
结果
3.重写方法
条件:
1.子类继承父类
2.访问修饰符相同 (特例为两者访问权限相同，如都为public)
一般，子类方法的访问权限不能比父类更加严格，即子类方法的访问权限更宽松
3.返回值类型相同
4.方法名相同
5.参数列表相同
6.异常 , 子类方法不能比父类抛出更多的异常
例如:
父类、子类中有相同的方法，这时就为重写.
重写时，优先调用子类方法
区别于重载:
重载: 方法名相同,但参数不同,实现多个方法的调用(同个类中重载)
重写: 整个方法都相同,特例除过访问修饰符可能不同且有继承(两个类 中重写)
代码举例:
/// 父类
public class human //不放父类创建对象，抽象类
{
private String name;
private String gender;
private int age;
// 父类中重写方法:
public void print()
{
System.out.println(name);
System.out.println(gender);
System.out.println(age);
}
public String getName()
{
return name;
}
public void setName(String name)
{
this.name = name;
}
public String getGender()
{
return gender;
}
public void setGender(String gender)
{
this.gender = gender;
}
public int getAge()
{
return age;
}
public void setAge(int age)
{
this.age = age;
}
}
// 子类 学生类
public class student extends human
{
private String xuehao;
// 子类中 重写方法
public void print()
{
// 没有调用父类, 运行优先调用子类, 仅仅输出 xuehao
// 不输出父类中print的姓名,性别,年龄等
// 解决方法: 使用 super 调用父类方法
super.print(); // super 调用了 父类的print()方法
System.out.println(xuehao);
}
public String getXuehao()
{
return xuehao;
}
public void setXuehao(String xuehao)
{
this.xuehao = xuehao;
}
}
// 子类老师
public class teacher extends human
{
private String gonghao;
public String getGonghao()
{
return gonghao;
}
public void setGonghao(String gonghao)
{
this.gonghao = gonghao;
}
public void print()
{
super.print(); // super 调用了 父类的print()方法
System.out.println(gonghao);
}
}
// 运行
public class TestRun
{
public static void main(String[] args)
{
student le =new student();
le.setXuehao("20322341234");
// 通过set 方法 设置属性 ,使其可以访问private 封装的数据类型
le.setAge(23);
le.setGender("男");
le.setName("xy");
le.print();
// 重写，优先调用子类方法, 但在子类中调用了父类的super方法才可访问到公用属性
System.out.println();
System.out.println("重写，优先调用子类方法, 但在子类中调用了父类的super方法才可访问到公用属性 ");
System.out.println();
teacher yang=new teacher();
yang.setGonghao("23429878");
yang.setAge(22);
yang.setGender("男");
yang.setName("杨");
yang.print();
}
}
结果:
其他函数方法
this
访问当前类的属性、方法
表示当前对象
this()
用于当前类的构造方法，且用在第一句
super
super .
调用父类的方法
前提:权限够. 用私有private 访问修饰符修饰的方法调用不了
super()
调用父类的构造方法
使用时,出现在子类构造方法的第一句话.
分为:
父类的无参构造
父类的有参构造
代码:
// 子类继承父类
public class student extends human
{
String xuehao;
public void print() // 子类中 重写方法
{
super.print(); // super.调用父类human中方法print()
System.out.println(xuehao);
}
}
// 父类
public class human //不放父类创建对象，抽象类
{
private String name;
private String gender;
private int age;
// 父类中重写方法:
public void print() // 子类中super即调用父类的print()
{
System.out.println(name);
System.out.println(gender);
System.out.println(age);
}
}
indexOf() :查找字符串位置 ; 找不到-1 ; 找到返回
lastIndexOf(): -1 ; 从右往左找
subString(): 截取字符串
“abcd”.subString( 0 或 1 ) : 1, 从1开始到字符串结束 , 结果bcd
“abcd”.subString(1,3 ) : 从1开始,3结束不包括3 ; 结果bc
split() : 字符串截取
“abcdabc”.split(“d”) : 返回字符串类型的数组 : [abc,abc]
“abcdabc”.split(“c”) : 结果[ab,dab]
toLowerCase(): 转小写
toUpperCase() : 转大写
代码:
String str = "hello, world!";
String lowerStr = str.toLowerCase(); //将字母全部转为小写
String upperStr = str.toUpperCase(); //将字母全部转为大写
System.out.println(lowerStr);
System.out.println(upperStr);
length() : 获取字符串长度
“abc”.length() : 结果3
类
要求: 首字母大写
描述: 对多个对象的抽象(分类)
例如： 对52个对象学生，进行分类，学生类或人类；
类的设计原则
高内聚：类内部的数据由自身来进行维护，不要由外部进行干涉，隐藏该隐藏的内容(内部隐藏，外部透明)
低耦合：提供公共的拥护访问接口，由用户进行调用
类与对象的区别：
类，范围性概念，范围广； 对象，具体化的.
类是对象的抽象，对象是类的具体 .
例: 人类 与 我
类与接口:
类 之间可以相互继承
接口 之间可以相互继承
类 实现 接口
继承 extends
原因：
类中属性，有冗余问题
用类的方法写程序, 而类之间也有关系，大小范围；
例如:
动物类中也分为：水生的、哺乳的、飞行的、陆地的...
解决冗余问题：
父类：
抽出公共的部分，单独形成一个类；（各个类的属性方法出现大量的重复、冗余）
子类:
继承父类的属性方法；但子类中保留了下个性化属性方法
网页中叫引用，程序中叫继承
其他说明:
+ public
- private
子类——小范围的类 大学生类
父类——大范围的类 人类
两个类不一定继承
继承条件：
关键词: is
子类是一个父类, 小范围的类继承大范围的类
例如:
学生是人类
汽车式交通工具类
代码:
// 子类1 狗类
public class Dog extends Pet
{
private String starin; //品种
// 方法输出
public void printstarin()
{
System.out.println("品种：" + starin);
}
// set /get 设置/获取私有属性值
public String getStarin()
{
return starin;
}
public void setStarin(String starin)
{
this.starin = starin;
}
}
// 子类2 企鹅类
public class Penguin extends Pet
{
private String sex;
public void printPenguinsex()
{
System.out.println("企鹅性别:"+sex);
}
public String getSex()
{
return sex;
}
public void setSex(String sex)
{
this.sex = sex;
}
}
// 父类 宠物类
// 共性的特征和操作
public class Pet
{
private String name;
private int health; // 健康值
private int love; // 亲密度
public void printfulei()
{
System.out.println("姓名：" + name);
System.out.println("健康值：" + health);
System.out.println("宠爱度：" + love);
}
// 访问 私有的属性
public void setName(String name)
{
this.name = name;
}
public void setHealth(int health)
{
this.health = health;
}
public void setLove(int love)
{
this.love = love;
}
public String getName()
{
return name;
}
public int getLove()
{
return love;
}
public int getHealth()
{
return health;
}
}
// 运行类
public class PetRun
{
public static void main(String[] args)
{
// 狗类
Dog xiaohuang = new Dog();
// 原先,没有封装，则为：xiaohuang.strain=“土狗”；
xiaohuang.setStarin("土狗");
xiaohuang.setName("小黄"); // 父类公共属性
xiaohuang.setHealth(10); // 父类公共属性
xiaohuang.setLove(9); // 父类公共属性
// 输出
xiaohuang.printstarin();
xiaohuang.printfulei();
System.out.println();
//企鹅类
Penguin qie = new Penguin();
qie.setSex("公");
// 输出
qie.printPenguinsex();
}
}
结果:
接口 implements / interface
问题:
继承都为 单继承:
每个类只能继承一个唯一的父类, 如extends 后面只能出现 一个父类
单继承缺点:
任何一个类,只能单继承, 只能有一个父类; 不能扩展自身的能力
解决:
解决1:
希望功能越来越强大,往父类中写入越来越多的功能,修改现有的程序来扩展
缺点:导致父类功能越来越复制,容易搞坏本来程序
解决2:
提供接口,附加功能
说明:
继承只能有一个
接口可以有多个
关键字:
interface 接口
相当于类class ,把class 换为 interface 即为接口形式
方法都默认用 public abstract 修饰的 , 没有方法体
变量都默认用 public static final 修饰的
不存在构造方法 等
implements 实现
相当于继承extends , 把extends 换为 implements
注意:
extends 后只能跟一个父类
implements 后面可以跟多个接口, 使用"," 隔开
@Override 重写
接口当中的所有方法 , 默认都是且只允许为: 公共的抽象方法 public abstract
因而在父类中要重写 @Override 该方法
例:
接口子类--- void joinDevice();
父类----
@Override //重写接口方法
public void joinDevice()
{
System.out.println("接入了一个鼠标");
}
语法:
public class computer implements erji, jianpan (多个接口)
public interface Typec (这时的类就不用class 了,而用interface )
定义:
一种能力或规范:
能力:
我会打太极,喝水, 听歌 ; 具有听歌/喝水的能力,这是一种能力
汽车方向盘具有调整方向的能力
规范:
耳机的插线头与手机的接收口必须一致,才可以听歌,是一种规范
喝水杯子的杯身与杯盖 必须匹配,是一种规范
例如:
符合接口定义:
浏览器扩展: 扩展功能, 实在不行就卸载,浏览器本身功能并不变
Windows系统,更新打补丁
人:附加翅膀,可以飞
反面教材:
电视机有声音小的bug, 自己拆开来修理声音时, 最终没修好,且还开不了机了
解决方案:
使其原有功能不变, 通过附加新的功能或设备来解决bug. 最差的结果是声音即便没修好,但可以看电视,就是声音小些罢了.
功能:
多继承,最大程度的去扩展程序的功能
开闭原则(修改关闭,附加扩展开启), 用附加功能来扩展功能
好处:
能力强大了,具有更多的能力; 继承更多的父类来强大自身或扩展了自身的功能
代码举例:
/**
父类
*/
public class Computer implements Use,Typec,MusicLine
{
// 实现接口
private String brand;
private String type;
public Computer(String brand, String type) //带参构造方法
{
this.brand = brand;
this.type = type;
}
//一般打印方法
public void print()
{
System.out.println(brand);
System.out.println(type);
}
// 访问数据get/set方法
public String getBrand()
{
return brand;
}
public void setBrand(String brand)
{
this.brand = brand;
}
public String getType()
{
return type;
}
public void setType(String type)
{
this.type = type;
}
@Override //重写接口方法
public void joinDevice()
{
System.out.println("接入了一个鼠标");
}
@Override
public void typeDevice()
{
System.out.println("接入了一个typec接口的键盘"); //重写方法,接口默认为abstract 抽象方法
}
@Override
public void musciLine()
{
System.out.println("接入了一个耳机");
}
}
/**
接口 use
*/
public interface Use
{
void joinDevice(); // 抽象方法 ,接口当中的所有方法默认都是,且只允许为公共的抽象方法 public abstract
}
/**
接口 Typec
*/
package jiekouinterface;
public interface Typec
{
void typeDevice();
// 附加typec 设备
}
/**
接口 MusicLine
*/
package jiekouinterface;
public interface MusicLine
{
void musciLine();
}
/**
运行 类
*/
package jiekouinterface;
/**
* 电脑 -类
* usb接口 -接口
* 接入usb接口的鼠标
* type-c的键盘
*
*/
public class RunJiekou
{
public static void main(String[] args)
{
Computer computer=new Computer( "华为","mate 10pro");
computer.print();
computer.joinDevice();
computer.typeDevice();
computer.musciLine();
}
}
结果:
多态(考)
特点:
面向对象的特征之一: 多态/封装/继承
面向对象的语言: c#(sharp 尖锐的)/ java/c++ 等都拥有面向对象的特征
定义:
变态,变化形态;
1. 做同一件事情,由于环境/条件/过程等等因素各有不同,则会得到不同的结果
2. 程序中,同一个引用类型(父类),使用不同的实例(子类,对象),则产生不同的结果
条件:
1.继承重写
2.父类引用指向子类实例
如: 父类类名 对象名=new 子类类名();
一般为: 类名 对象名=new 类名()
注意:
new 后不能出现 接口/ 抽象类; 不能被实例化
作用:
主要为了实现 多态性
例如:
变色龙: 颜色变了,但本身物种不变
考试: 同学考试--答题,交卷 ; 老师--监考,收卷,阅卷
52个同学考试: 都在答题,交卷 ; 考试成绩不同,52种结果
拍照: xy拍照, 打印照片; 两种结果: 黑白/彩色
练字: 写的快,字练的丑;写的慢,字练的漂亮
代码:
// 父类people
public abstract class People
{
public abstract void takeExam();
private String name;
public String getName()
{
return name;
}
public void setName(String name)
{
this.name = name;
}
public int getAge()
{
return age;
}
public void setAge(int age)
{
this.age = age;
}
public String getGender()
{
return gender;
}
public void setGender(String gender)
{
this.gender = gender;
}
private int age;
private String gender;
protected void printinfo()
{
System.out.println(name);
System.out.println(age);
System.out.println(gender);
}
}
// 子类学生类
public class Student extends People
{
@Override
public void takeExam()
{
System.out.println("答题");
System.out.println("交卷");
System.out.println();
}
}
// 子类老师类
public class Teacher extends People
{
@Override
public void takeExam()
{
System.out.println("监考");
System.out.println("收卷");
System.out.println();
}
}
// 运行
public class Runpolymorphic
{
public static void main(String[] args)
{
People xy= new Student();
xy.takeExam();
People nihao =new Teacher();
nihao.takeExam();
}
}
结果:
包装类
包装类: 将数据类型设计为类, 面向对象的操作
包装类 对应基本数据类型
Character char
Integer int
Byte byte
Float float
Short short
Long long
Double double
Boolbean boolbean
装箱: 基本类型转换为 包装类
拆箱: 包装类 转换为 基本类型
代码:
package lei.putonglei.baozhuanglei;
public class PackageBaozhuang
{
public static void main(String[] args)
{
int x = 30;
Integer i = new Integer(x); //装箱
int tem = i.intValue(); // 拆箱
// 自动拆箱装箱
int xx = 30;
Integer ii = x; //自动装箱
Double aDouble = 3.14;
double d = aDouble; // 自动拆箱
String s1 = "1234";
String s2 = "12.34";
int a = Integer.parseInt(s1); // 将字符串 s1 转换为整型数值并赋值给变量 a
float b = new Float(s2); // 使用构造函数将字符串 s2 转换为浮点数并赋值给变量 b
System.out.println("整数的乘法: " + a + "*" + a + "=" + a * a);
System.out.println("小数的乘法: " + b + "*" + b + "=" + b * b);
String fstr = String.valueOf(1.23f); // 将浮点数值转换为字符串并赋值给变量 fstr
String dabstr = String.valueOf(2.34); // 将双精度浮点数值转换为字符串并赋值给变量 dabstr
String blstr = String.valueOf(true); // 将布尔值转换为字符串并赋值给变量 blstr
System.out.println(blstr.toUpperCase()); // 将字符串 blstr 转换为大写并打印出来
}
}
抽象类 abstract
原因: 父类创建对象,就会丢了好多子类的属性
解决: 让父类不能访问子类；约束不让父类类创建对象
特点:
抽象类不能用new 实例化 ，new 后面不能为 抽象类
对两层或多层关系的父子类或 曾祖、父子类等， 至少让最底层不为abstract 类, 可以创建对象
父类 对 子类抽象，子类 对 对象抽象
抽象方法 abstract
原则:
父类抽象, 子类重写
abstract 一般对父类进行抽象
特征:
抽象方法没有方法体
抽象方法所在的类一定为抽象类
如果父类出现了抽象abstract方法，那么子类继承后必须重写这个方法
对于一般的方法，可以重写，可以不重写
代码举例:
/// 父类
public abstract class PeopleAbstract // abstract 抽象类/父类
{
private String name;
private String gender;
private int age;
public abstract void printinfo(); //抽象方法 abstract 没有方法体, 对其运行结果无影响
public String getName()
{
return name;
}
public void setName(String name)
{
this.name = name;
}
public String getGender()
{
return gender;
}
public void setGender(String gender)
{
this.gender = gender;
}
public int getAge()
{
return age;
}
public void setAge(int age)
{
this.age = age;
}
}
// 子类:
public class StudentAbstract extends PeopleAbstract
{
private String sno;
public void printinfo() // 重写抽象方法printinfo()
{
// 调用父类的方法，但是父类方法为private ，访问不了
System.out.println(sno);
System.out.println(getAge());
System.out.println(super.getGender());
System.out.println(super.getName());
}
public String getSno()
{
return sno;
}
public void setSno(String sno)
{
this.sno = sno;
}
}
// 子类: 老师类
public class TeacherAbstarct extends PeopleAbstract
{
public void printinfo() // 重写抽象方法printinfo()
{
System.out.println(tgonghao);
System.out.println(super.getAge());
System.out.println(super.getGender());
System.out.println(super.getName());
}
public String getTgonghao()
{
return tgonghao;
}
public void setTgonghao(String tgonghao)
{
this.tgonghao = tgonghao;
}
private String tgonghao;
}
数据封装
数据的封装
接口访问，实则set/get方法的调用
他们是公有的，可访问
作用: 访问私有的数据
注意
修饰类时，只能使用默认的或public进行修饰，无法使用其他的修饰符
set / get 方法
右键----generate ----getter and setter ---全选---确认
set 设置属性
返回值类型void , 带参; 方法体中 参数属性指向当前对象的属性值
public void setName(String name)
{
this.name = name;
}
get 获取属性值
返回值类型根据返回的数据类型返回, 方法体中return
public String getName()
{
return name;
}
异常
定义:
程序运行的不正常现象(按照语法规则写后)
解决的方法:
try{ }
catch( ) { }
finally{};
三种搭配方式:
try{ } catch() {} finally{};
try{ } cantch() {} ;
try { } finally{};
try:
try 方法体中跟 可能出现问题的代码 { }
catch:
Exception: 所有错误类型的父类
普通捕获一次:
catch (错误类型 e) { 提示信息 }
注意: 捕获的错误类型与出现问题的代码一致
多路捕获:
多个catch 捕获多种异常
多个catch 子类异常在前, 父类异常在后
catch (ArithmeticException ex)
{
System.out.println("空指针异常 ");
}
catch(Exception ex)
{
System.out.println("空指针异常 ");
}
finally
类似: 葱花,蒜苗,盐巴 (做饭)
作用: 资源释放（类似图书馆借书，最终都要还书）
不管程序正常执行，还是错误执行，finally都要执行
java有垃圾回收机制
思路:
1 申请资源, 程序处理
2 程序处理,错误
3 资源释放
关键字:
1 throw 抛出异常
throw new 异常对象
例如: throw new ArrayIndexOutOfBoundsException(" 数组下标越界");
2 throws (s声) 声明异常
语法：访问权限 返回类型 方法名() throws 异常类型列表{ }
异常类型列表:
表示可以出现多个异常 ，父类子类顺序随意 ; 交给上级程序处理
例如:
public static void main(String[] args) throws ArrayIndexOutOfBoundsException, NullPointerException
{ }
BankException 自定义异常
继承exception 父类
例如: 存钱存正数 ,存负数抛出异常
assert 断言
处理方法:
异常程序 无需set方法
代码1:
/**
多路捕获
*/
public class Duolu
{
public static void main(String[] args)
{
try
{
int[] nums = {11, 12, 133};
System.out.println(nums[3]);
int n1 = 1;
int n2 = 0;
int n3 = n1 / n2;
System.out.println(n3);
String name = null;
System.out.println(name.length());
int[] numbers = {1, 2, 3};
int index = 4;
int result = numbers[index];
System.out.println("Result结果: " + result);
}
catch (ArrayIndexOutOfBoundsException e)
{
System.out.println("捕获结果: " + e);
}
catch (NullPointerException ex)
{
System.out.println("null ");
}
catch (Exception ex) // 父类
{
System.out.println("null ");
}
}
}
结果:
代码2:
// 自定义异常
public class BankExcption extends Exception //自定义异常类BankExcption 继承父类Exception
{
String ses; //声明了一个字符串变量 ses，用于存储异常信息
public BankExcption(int in, int out) // 带参构造方法 ,in 收入, out 支出, 初始化ses变量
{
ses = "收入: " + in + "是负数或支出" + out + "是正数, 不符合要求";
}
public String warnMess() // 普通方法 返回ses的值,用于获取自定义异常的方法的提示信息
{
return ses;
}
public static class Bank //静态 bank类
{
private int money; // 余额
public int getMoney() //get方法, 获取余额值
{
return money;
}
public void income(int in, int out) throws BankExcption
{
// throws 声明异常 ,income 方法，用于处理收入支出的逻辑，可能会抛出 BankExcption 异常
int newIncome = in + out; // 实际收入= 收入和支出综合
if (in < 0 || out >= 0 || newIncome < 0)
{
// 如果收入小于0，支出大于等于0，或者实际收入小于0; 三条件只要满足一个则抛出 BankExcption 异常
throw new BankExcption(in, out); // 抛出 BankExcption 异常
}
System.out.println(" 本次收入 : " + newIncome);
money = money + newIncome; // 更新余额
}
public static void main(String[] args)
{
Bank b = new Bank(); // 创建 Bank类 对象
try
{
b.income(200, -100); // 执行 income 方法
b.income(400, -100);
b.income(600, -100);
System.out.println(" 银行存款现有: " + b.getMoney()); // 输出当前余额
b.income(400, -100);
b.income(-100, 200); // -100 小于0, 满足条件
}
catch (BankExcption e)
{// 捕获 BankExcption 异常
System.out.println(" 出现问题: " + e.warnMess()); // 输出异常信息
}
System.out.println(" 银行最终有存款: " + b.getMoney()); // 输出最终余额
}
}
}
结果:
多线程
定义
两个以上的线程叫多线程
代码:
继承Thread ( 父类 )
或
实现Runable 接口
Thread // 实现接口
Runnable //
public void run()
{
}
start() ; // 启动线程
需要重写run()方法
三种状态:
就绪 / 运行 / 阻塞
就绪状态多个, 运行状态一个
sleep(1000) ; //线程休眠1s
休眠时间长, 运行次数少; 休眠时间短, 运行次数多;
设置线程优先级别 :1-10
setPriority( 1 ) 优先级别最低
setPriority( 10 ) 优先级别最高
yield() 线程的礼让
其他方法:
启动线程: start() 方法
线程优先级:10, 5 ,1
网络延迟: sleep()方法
中止线程: stop()方法
判断线程是否消亡: isAlive()
礼让线程: yield()方法
可能得礼让,不是绝对的
A 已经获得了cpu资源,则可以运行
A 出让cpu资源,它自己终止,运行不了,自己到就绪状态
其他问题:
线程不安全:
多个线程并发, 一个cpu回答, 造成混乱现象
解决:谁先拿到黑板擦,cpu就回答
线程池:
创建(2s) 和 销毁线程(3s) 的时间大于运行程序(1s) 的时间
解决: 使用线程池,类似代理
创建线程: 线程池早已经做好线程, 无需创建;
运行程序: 仅仅找到相关的线程( 仅仅消耗该时间), 运行
销毁线程: 线程池自己慢慢的销毁线程
线程同步:
并发: 程序同时运行; 类似多个同学同时问老师问题; 双11秒秒杀
解决: 使用黑板擦,谁拿到黑板擦,就回答谁的问题
临界区
生产者-消费者问题:
生产者: 厨师
消费者: 消费的学生
问题:
生产者生产了产品, 但没人来吃 或 消费者来了,但饭没做好
解决:
等待 ( 消费者等待 ) -通知( 生产者通知消费者来消费 )
创建一个通知群
死锁
两个资源相互等待的结果
例如: 两人约好了,去玩; 你等我,我等你 ; 以为对方会打电话叫他 ,结果都没打
代码1
/**
实现 Runable 接口
*/
public class Runable implements Runnable
{
int pauseTime;
String name;
public Runable(int x,String n) // 构造方法
{
pauseTime =x;
name=n;
}
public void run() // run方法
{
while (true)
{
try
{
System.out.println(name+":"+new Date(System.currentTimeMillis()));
Thread.sleep(pauseTime);
}
catch (Exception e)
{
System.out.println(e);
}
}
}
public static void main(String[] args)
{
Thread t1=new TimePrinter(1000,"fast guy");
t1.start();
Thread t2=new TimePrinter(3000,"slow guy");
t2.start();
}
}
代码2:
/**
继承Thread 方法
*/
public class TimePrinter extends Thread
{
int pauseTime;
String name;
public TimePrinter(int x,String n)
{
pauseTime =x;
name=n;
}
public void run() // Thread类中的run()方法
{
while (true)
{
try
{
System.out.println(name+":"+new Date(System.currentTimeMillis()));
// 打印出name和当前时间的信息
// 创建了一个表示当前时间的Date对象
Thread.sleep(pauseTime);
}
catch (Exception e)
{
System.out.println(e);
}
}
}
public static void main(String[] args)
{
TimePrinter tp1=new TimePrinter(1000,"fast guy");
tp1.start(); // 启动了tp1对象
TimePrinter tp2=new TimePrinter(3000,"slow guy");
tp2.start();
}
}
结果:
常用工具类
final 修饰的类/方法为 终极类, 不被任何继承/ 重写
包:
java.lang 包中 String : lang包核心库,该包自动导入
String 对象的创建
String a=new String();
String a="a";
栈和堆
数据类型
equal方法
"cpu".equal("Gpu");
"cpu".equalsIgnoreCase("Gpu");
java.io 包: 文件读写
java.util 包: 工具类, 手钳
java.awt javax.swing 包: 开发小程序 界面 (不成气候 ,不会考这个 )
java.net 包: 网络功能类
System类:
Math类:
object 为所有类的 父类
进程: 每个进程包含多个线程
比较值 实则比较地址 --比较 hash表
基本类型包装类
包装类:
八大基本数据类型, 希望以包装的类型存在 , 对应包
装箱: 基本类型转换为 包装类
拆箱: 包装类 转换为 基本类型
泛型:
类似: 算命的话,说的比较笼统
GPU: 显卡,图形处理器
Collection 工具类
Arrays 工具类
集合框架
定义
数组中值都是清一色
集合框架: 任意类型数据都可以存 ( 都是面向接口的 ; 与数据打交道 )
问题:
无序性 , 可重复性 ( 类似书包, 找东西不好找 ; )
所以使用子接口
特点:
面向接口的编程
接口 对象名= new 接口对应的实现类 ;
数据临时性 ( 程序中数据 == 内存中数据, 重启没有 )
数组确定了大小,不能改变, 清一色的int 或 char等等 ; 连续性
集合框架无视数据类型 / 存储大小
作用:
存放数据
Collection 父接口
定义:
public interface Collection extends Iterator{ }
方法:
集合当中有没有包含集合: containsAll();
判断集合是否存放数据: isEmpty()
判断集合中是否存在某个对象: contains ()
转换集合对象为迭代器: iterator()
将集合转换为数组: toArray()
T[] ToArray( @NotNull T[] a )
add () 向集合添加一个元素
remove () 删除指定元素
size () 返回元素个数
get()
public class CollectionDemo
{
public static void main(String[] args)
{
Collection c=new ArrayList(); // Collection 父接口, 利用子接口list 的实现类,创建对象
c.add("java"); //添加数据
c.add("c#");
c.add(100);
System.out.println("c中包含"+ c.size()+"个元素");
Collection s=new HashSet(); // Collection 父接口, 利用子接口 set 的实现类,创建对象
s.add("javascript");
s.add("java");
System.out.println("c中是否完全包含s集合中的元素: "+c.containsAll(s)); // c集合中有没有包含s集合的元素
s.removeAll(c); // s 集合中去除c集合中元素
System.out.println("s 集合中的元素: "+s);
}
}
子接口
Set集合-子接口:
特点:
无序的 , 不可重复; 唯一值 ;
定义:
public interface Set extends Collection {}
实现类:
HashSet 继承 AbstractSet
TreeSet 继承 AbstractSet 实现 SortedSet
方法:
添加: add(object o)
删除: remove(object o)
遍历: iterator() ; 把set集合数据转移 返回迭代器对象
public class HashSetDemo
{
public static void main(String[] args)
{
Set<String> s=new HashSet<String>(); // Set 创建它的 实现类 Hashset
s.add("A");
s.add("b");
s.add("b");
s.add("b");
System.out.println(s); // 结果不允许冗余 b只能有一个
}
}
Queue(队列) 子接口:
特点: 排队; 先排到队头先处理
List列表 -子接口
特点:
有序, 可重复; 类似数组
方法:
按指定位置删除元素 : remove( index i)
根据下标找到对应的值并返回值 : get( index i ) ,类似数据下标
在指定位置添加元素: add(int index , object o) 将o数据添加到下标为index 中的位置
在指定位置增加一组元素: addAll();
List list = new ArrayLIst();
list.add(1); //添加数字1
list.add(""); // 添加双引号
list.add(new Student()); //添加对象
实现类:
Arraylist 子接口; 特点: 相当于线性表; -->继承abstractlist-->实现了list
// 代码
public class ArrayListDemo
{
public static void main(String[] args)
{
// 创建Arraylist ,限定类型为String
ArrayList<String> alist=new ArrayList<String >(); // 创建类的对象,只能用arraylist 的方法,不能调用list 方法
// add 方法添加元素
alist.add("ABC");
ArrayList<String> alist2 =new ArrayList<String>(); // new 正常创建类的对象2, 不能调用父接口List 方法
alist2.add("Hello");
alist2.add("world");
alist.addAll(0,alist2); // 向alist 集合的 0的位置,添加一个集合alist2
System.out.println(alist);
//remove 删除元素
alist.remove(2); //2号下标对应的值删除
alist.remove("ABC");
// toArray 方法 转为数组,遍历输出
String str[]=alist.toArray(new String[]{});
System.out.println("数组类型: ");
for( int i=0; i<str.length ; i++)
{
System.out.println(str[i]);
}
}
}
LinkedList 子接口 ; 特点: 类似(线性链表, 如自行车链子截断后的线条 )
定义:
public interface List extends Collection { }
方法:
addFirst() 链表开头添加元素
addLast() 链表结尾增加元素
removeFirst()
removeLast()
public class LinkList
{
public static void main(String[] args)
{
// 类似自行车链 ,链表
LinkedList<String> qu = new LinkedList<String>(); // 创建类的对象
qu.add("A"); // add 方法添加元素
qu.add("B");
qu.add("C");
System.out.println(qu);
qu.addFirst("头部"); // 链表头部添加头元素
qu.addLast("尾部"); // 链表尾部添加尾部元素
System.out.println(qu);
for (int i = 1; i < 6; i++)
{
System.out.println("第" + i + "个元素是: ");
System.out.println(qu.poll()); // poll方法作用: 获取并移除元素
}
}
}
Map映射-键值对(父接口)
特点:
k-v键值对,需要先配对 ; key 配对values 值 ;只要找到key 就能找到values
定义:
public interface Map
实现类:
SortedMap 类 ------ TreeMap (孙子类)
方法:
put(k,v): 添加数据
remove( key ) :删除数据: 根据指定的key 匹配到对应的方法删除
get( key) 根据key取得valuse值
keyset() ; 把Map所有的key组合
values(); 对值进行集合
hashCode() 判断当前集合中的哈希编码
size() : 返回集合长度
clear() : 把集合当中的元素清理掉:
public class MapDemo
{
public static void main(String[] args)
{
Map<String,Integer> hm=new HashMap<String,Integer>(); // map 创建了一个实现类
hm.put("1", 100);
hm.put("2", 90);
hm.put("3", 98);
System.out.println(hm);
System.out.println("hm中共有"+hm.size()+"个元素");
Set<String> set=hm.keySet(); // map中的 key值的集合 集合到set 框架中的set 对象中
System.out.println(" key 集合: "+ set);
System.out.println("key值为1 的value的值为: "+ hm.get("1"));
}
}
Iterator 迭代器(遍历) 父接口
作用:
迭代输出接口
定义:
Iterator 对象名 =Collection 接口对象名.iterator();
方法:
hasNext(): 判断是否有下一个值
public class IteratorDemo
{
public static void main(String[] args)
{
List<String> list=new ArrayList<String>(); // List 调用了实现类 ArrayList
list.add("A");
list.add("E");
list.add("B");
list.add("C");
list.add("D");
System.out.println(list); // 按敲的顺序显示
Iterator<String > iter=list.iterator();
while(iter.hasNext()) // hasNest()方法 作用 : 判断是否有下一个值
{
System.out.println(iter.next()+" ");
// next()方法的作用: 取出当前元素
}
}
}
泛型 e / E
定义
约束存放数据类型只能为 某个类型, 如Student对象,无需判断数据类型, 有利于遍历
代码
public class GenericDemo
{
public static void main(String[] args)
{
A<Integer> p1 = new A<Integer>();
A<String> p2 = new A<String>();
p1.setX(100);
p2.setX("abc");
System.out.println(p1.getX() + p2.getX());
}
}
class A<T> //T为定义的泛型
{
private T x;
public void setX(T x)
{
this.x = x;
}
public T getX()
{
return x;
}
}
栈与队列
栈
特点: 先进后出
方法:
返回第一个元素并将该元素pop出栈: pop()
队列
特点: 先进先出
其他
@NotNull 为注解
文件操作
文件操作输入输出流 (考)
基础
父类----Object 基类
子类---Inputstream/Outputstream/Reader/Writer 且为抽象类
内存区: 程序中运行的程序
数据流入: 从外存到内存, 入; 读文件 ( 读入数据 ,显示出来)
数据流出: 从内存到外存, 出;写文件 ( 写出数据, )
注意:
类/包名: 读入,写出的文件名不能和类名Reader / Writer 一致, 否则报错
路径: / 写一个; \\ 写两个
字符流(处理文本数据)
Reader 读 / Writer 写; 抽象基类 ;
读写完成null判断
Unicode 编码: 1个汉字, 两个字节, 16位
使用其孙子类:
FileWriter ; FileReader
Writer out=new FileWriter("文件目录");
// 写出文件
public class Write
{
public static void main(String[] args) throws IOException
{
Writer out=new FileWriter("D:\\A_temporaryd\\nihao\\Java\\output.txt");
String str="this is the test of writer and reader 等等等,,时间如,";
out.write(str);
out.close();
/*
写出文件 ,到 output.txt文件
*/
}
}
/**
* 读入文件
* 数据流
*/
public class ReaderExample
{
public static void main(String[] args) throws IOException
{
Reader in=new FileReader("D:\\A_temporaryd\\甘政法\\Java\\output.txt");
char c[]=new char[1024];
int len=in.read(c);
in.close();
System.out.println("内容为: "+new String(c,0,len));
/*
读入文件
在这段代码中，`new String(c, 0, len)
c: 转换为字符
0: 表示从字符数组`c`的索引0开始，
len: 表示要转换的字符数。这样的操作会创建一个新的String对象，其内容为从字符数组`c`中索引0开始的`len`个字符。这种用法可以实现
将字符数组转换为字符串，并且只包含数组中指定范围内的字符。
*/
}
}
字节流( 二进制 / 图片 / 文本文件 )
父类: InputStream 读 / OutputStream 写 ;
读写完成-1判断
子类:
创建对象,操作文件: FileInputStream / FIleOutputStrean
例如:
FileInputStream in =new FileInputStream (" 文件路径,及其文件名 ")
FIleOutputStrean out =new FIleOutputStrean( " 文件路径,及其文件名 " )
或
FileInputStream in =new FileInputStream ( new FIle( " 文件路径,及其文件名 " ) )
孙子类(接上in / out ):
DataInputStream / DataOutputStream
DataInputStream dataln= new DataInputStream( in ) ;
DataOutputStream dataOut=new DataOutputStream (out);
/**
* 图片输出流
*
*/
public class DataINputStream
{
public static void main(String[] args) throws FileNotFoundException, IOException
{
DataInputStream in = new DataInputStream(new FileInputStream("D:\\A_temporaryd\\nihao\\Java\\duotai.jpg"));
DataOutputStream out = new DataOutputStream(new FileOutputStream("D:\\A_temporaryd\\nihao\\Java\\duotai111.jpg"));
byte b[] = new byte[1024];
int a = 0;
while ((a = in.read(b)) != -1) // 循环, 判断是否为-1: 判断文件是否读取完毕
{
out.write(b);
}
in.close(); //关闭流
}
}
结果: 复制输出图片duotai111.jpg
追加不覆盖true
原本文件内容:abc
现将 def 写入到abc文件中
一种, 覆盖掉abc 为: def
另一种, 不覆盖, 跟到abc后面 为: abcdef
FileWriter fw =new FileWriter (" " , true ) ; // true 判断覆盖还是不覆盖 ; true 表示追加,不覆盖
FileReader fw =new FileReader (" " , true ) ;
/**
* 不覆盖文件,追加true
*/
public class filew
{
public static void main(String[] args) throws IOException
{
FileWriter fw=new FileWriter("D:\\A_temporaryd\\甘政法\\Java\\output.txt", true);
String str=" 追加文件 zhuijia file ";
fw.write(str);
fw.close();
}
}
// 读入显示文件
public class filer
{
public static void main(String[] args) throws IOException
{
FileReader fr = new FileReader("D:\\A_temporaryd\\甘政法\\Java\\output.txt");
char c[] = new char[1024];
int len = fr.read(c);
// 使用FileReader的read()方法将文件的内容读取到 数组'c'中
// 获取文件中字符长度并 存储在 len 中
fr.close();
System.out.println("内容为: " + new String(c, 0, len));
// 使用从文件中读取的字符（'c'数组）创建一个新的字符串，从索引0开始到'len'结束，并在打印之前将其与字符串"内容为: "连接起来。
}
}
待续、更新中
—————————————————————
以上就是今日博客的全部内容了
创作不易,若对您有帮助,可否点赞、关注一二呢,感谢支持.