java自学杂记<一>
构造方法:构造方法名称与类同名,一个类可以有多个构造方法
变量:
局部变量(方法/构造方法/语句块中的)成员变量(定义在类中,方法体之外,创建对象的时候实例化)类变量(类中的,方法体之外,static类型)
基本数据类型:
a: 内置数据类型(六种数字类型(四个整数型,两个浮点型),一种字符类型,还有一种布尔型)
byte(空间是int的四分之一) short(空间是int的二分之一) int long(用在较大整数) float double boolean char(任何字符串)
b: 引用数据类型
常量: final修饰
变量:
类变量(独立于方法外,static修饰) 实列变量(独立方法外) 局部变量(类中方法中的)
a:局部变量:没有默认值,必须初始化;访问修饰符不可用
b:实列变量:至少被一个方法/构造方法或语句块引用,是的外部能通过这些方式获取实例变量;访问修饰符可用;public对子类可见,private对子类不可见
c:类变量(静态变量 static) 经常被声明为常量,初始化后不可改变;被声明为public static final类型时,名称用大写
修饰符:
a:访问修饰符
default private public protected(对其所在类的子类可见)
b:非访问修饰符
static final
abstract:
A. 抽象类
1)抽象类不能实例化,为了将来对该类扩充
2)一个类包含抽象方法,该类一定要声明为抽象类
3)可以包含抽象方法和非抽象方法
B. 抽象方法
1)没有任何实现的方法,该方法的具体实现由子类提供
2)不能被声明为final static
3)任何继承抽象类的子类必须实现父类的所有抽象方法,除非该子类也是抽象类
4)如果一个类包含若干个抽象方法,那么该类必须声明为抽象类。抽象类可以不包含抽象方法
Character类:
对单个字符进行操作
isLetter() 是否是一个字母
isDigit()是否是 一个数字字符
数组:
声明:double[] list = new double(10) 或 double list = {1,2,3}
for-each循环:
for(double element: list) { // do sth.}
StringBuffer/StringBuilder类:
对字符串进行修改时用
日期时间:
日期比较: before() / after() / equals()
格式化日期: new SimpleDateFormat(“yyyy-MM-dd hh:mm:ss”).format(要格式化的时间)
sleep() 使当前线程进入停滞状态(阻塞当前线程)
异常处理:
类型: 用户输入非法数据/要打开的文件不存在/网络通信终端或内存溢出
检查性异常:用户错误或问题引起的,无法预见的,编译时不能被简单忽略
运行时异常:可避免的,可在编译时忽略
错误:不是异常,而是脱离控制的问题
Exception类:
所有异常类时从java.lang.Exception类继承的子类
Exception是Throwable类的子类。Throwable类还有一个子类Error(用于运行时环境发生的错误)
Exception类的子类为:IOException / RuntimeException
继承:不支持多继承但支持多重继承
关键字:
①extends->只能继承一个类
②implements-> 多继承 public class C implements A,B {…} C继承A和B(使用该范围为类继承接口的情况,可同时继承多个接口)
③super:对父类成员的访问 super.父类的方法()
④final:声明的类不能被继承,修饰的方法
构造器:
子类不继承父类的构造器(构造方法或构造函数),只是调用,初始化父类成员属性。若父类的构造器带有参数,则必须再子类的构造器中显示的通过super调用父类的构造器并传参数。
若父类构造器没有参数,子类的构造器用不需要用super调父类的构造器,系统会自动调父类的无参构造器。
构造器-what:
名称与类名相同,没有返回值,不能写void
可以重载
若没有手动添加,会有默认的无参构造器
若手动添加了,默认的会消失
构造器-作用:为正在创建的对象的成员变量赋初始值
构造方法在创建对象时调用,具体调用哪一个是参数决定的
public class Student {
public Student() { // 无参构造器}
public Student(int a) { // 一个参数构造器} ->可以在构造函数中给Student的成员变量赋值
public Student(int a, String s) { // 两个参数构造器}
}
调用:
Student s1 = new Student() // 无参构造器
Student s2 = new Student(15) // 调一个参数构造器
Student s3 = new Student(15, ‘aa’) // 调两个参数构造器
构造方法-this:表示刚刚创建的对象,可访问对象属性,实例方法,调用重载的其他构造方法(只能在第一行)
public class Student {
public int age
public Student() {
this(15) -> 调用了具有int类型参数的构造器,重载构造器不可同时相互调用,避免陷入死循环
}
public Student(int a) {
thia.age = a
}
}
重写(overide)/重载(overload)
重写:子类对父类的允许访问的方法重新编写,返回值和形参都不能改变。外壳不变,核心重写。
子类根据需要实现父类的方法
重写不能抛出新的检查异常或比原先更加宽泛的异常
重写规则:
声明为final的方法不可重写
声明static的方法不可重写,但能再次声明
子类和父类在同一个包中,子类可重写父类所有方法,除private和final的
子类和父类不在同一个包中,子类只能重写父类声明为public和protected的非final方法
重写的方法可抛出任何非强制异常,无论被重写的方法是否抛出异常,但是,重写的方法不能抛出新的强制性异常,或者比原先更广泛的强制性异常
构造方法不能被重写
如果不能继承一个类,则不能重写该类的方法
super的使用:需要在子类中调用父类的被重写方法时用
重载:在一个类里,方法名称相同,参数不同。返回类型可相同或不同
每个重载的方法必须有独一无二的参数
最常见的是构造器重载
重载规则:
被重载的方法必须改变参数(个数或类型不一样)
被重载的方法可改变返回类型
被重载的方法可改变访问修饰符
被重载的方法可声明新的或更广的检查异常
方法能在同一个类中或一个子类中被重载
无法以返回值类型作为重载函数的区分标准
重写和重载的区别:重写是子类与父类的一种多态性表现;重载是一个类的多态性表现
参数:必须修改/一定不能修改
返回类型:可修改/一定不能修改
异常:可修改/可减少或删除,一定不能抛出新的或更广的异常
访问:可修改/一定不能做更严格的限制,可降低限制
多态:
三个必要条件:继承,重写,父类引用指向子类对象:Parent p = new Child()
public class Test {
public static void main(String[] args) {
show(new Cat()); // 以 Cat 对象调用 show 方法
show(new Dog()); // 以 Dog 对象调用 show 方法
Animal a = new Cat(); // 向上转型
a.eat(); // 调用的是 Cat 的 eat
Cat c = (Cat)a; // 向下转型
c.work(); // 调用的是 Cat 的 work
}
public static void show(Animal a) {
a.eat();
// 类型判断
if (a instanceof Cat) { // 猫做的事情
Cat c = (Cat)a;
c.work();
} else if (a instanceof Dog) { // 狗做的事情
Dog c = (Dog)a;
c.work();
}
}
}
abstract class Animal {
abstract void eat();
}
class Cat extends Animal {
public void eat() {
System.out.println(“吃鱼”);
}
public void work() {
System.out.println(“抓老鼠”);
}
}
class Dog extends Animal {
public void eat() {
System.out.println(“吃骨头”);
}
public void work() {
System.out.println(“看家”);
}
}
总结:根据传入的对象类型实例化对应类型的对象,再调用此对象的方法
当子类对象调用重写的方法时,调用的是子类的方法,而不是父类中被重写的方法
若想调用父类中被重写的方法,用super
多态的实现方式:重写/接口(一些方法特征的集合,但没有方法的实现)/抽象类和抽象方法
抽象类:不能实例化对象,必须被继承才能使用
public abstract class Studeng{ … }
抽象方法:只有方法名,没有方法体
如果一个类有抽象方法,该类必须是抽象类
继承抽象方法的子类必须重写该方法,否则,该子类也必须声明为抽象类
总结:
抽象类不能实例化
抽象类中不一定包含抽象方法,但是又抽象方法的类一定是抽象类
抽象类中的抽象方法只是声明,没有方法体
构造方法,类方法(用static修饰的方法)不可声明为抽象方法
抽象类的子类必须给抽象类中的抽象方法的具体实现,除非该子类也是抽象类
封装
接口:抽象类型,是抽象方法的集合。不是类
接口不能实例化
接口没有构造方法
接口中所有方法必须是抽象方法
接口不能包含成员变量,除了static和final变量
接口不是被类继承,而是要被类实现
接口支持多继承
抽象类和接口的区别:
抽象类中的方法可有方法体,接口中的不行
抽象类中的成员变量可以是各种类型的,接口中的成员变量只能是public static final类型的
接口中不能有静态代码块及静态方法(用static修饰的方法),抽象类是可以有的
一个类只能继承一个抽象类,但一个类可实现多个接口
public class 类名 implements 接口名{ … }
标记接口:没有任何方法和属性的接口,
枚举enum
enum Color { RED, GREEN, BLUE }
迭代:
for(Color val: Color.values()) {
Synstem.out.println(val)
}
values() 返回枚举类中所有值
ordinal()找到每个枚举常量的索引
valueOf()返回指定字符串值得枚举常量
枚举可以用变量,方法(具体or抽象)和构造函数,构造函数只能用private,如果有抽象方法,每个实例都必须实现它
实例
Color c1 = Color.RED
包package
ArrayList类:可动态修改的数组
引入 import java.util.ArrayList
ArrayList list = new ArrayList()
add(‘xx’)添加元素
get(索引) 获取元素
set(索引,值) 修改元素
remove(索引) 删除元素
size()获取长度
sort() 排序 要引入Collections类(import java.util.Collection) Collection.sort(list)
迭代:
for循环或for-each:
for (String i: list) {
…
}
链表LinkedList:
单选链表:包含当前节点的值和一个指向下一个节点的链接
双向链接:包含数值,向后的节点链接,向前的节点链接
增加和删除比ArrayList的效率高,查找和修改效率低
使用ArrayList的情况:
频繁访问列表中的某个元素
只需要在列表末尾进行添加和删除元素
使用LinkedList的情况:
需要通过循环迭代访问列表中的某些元素
需要频繁在列表开头,中间,末尾进行添加和删除元素
import java.util.LinkedList
LinkedList list = new LinkedList()
addFirst(值) 头部添加元素
addLast(值) 尾部添加元素
removeFirst() 移除头部元素
removeLast() 移除尾部元素
getFirst() 获取头部元素
getLast() 获取尾部元素
size() 获取数量
迭代同ArrayList
HashSet: 不允许又重复元素的集合
可以又null, 不会记录插入的顺序
add(‘xx’)添加元素
remove(值) 删除元素
clear() 删除所有元素
size() 获取数量
contains(值) 判断是否存在
迭代:for-each
HashMap: 键值对
最多允许一条记录键为null,不会记录插入的顺序
put(键, 值) 添加
get(键) 获取
remove(键) 删除
clear() 删除所有
size() 获取数量
迭代:for-each
for(Integer i: list.keySet()) {
// i为key
}
for(Integer value: list.values()) {
//value为值
}
迭代器Iterator: 不是集合,是用于访问集合的方法,可用于迭代ArrayList和HashSet
it.next() 返回迭代器的下一个元素
it.hasNext() 检查集合中是否还又元素
it.remove() 将迭代器返回的元素删除
获取一个迭代器:
ArrayList list = new ArrayList()
Iterator it = list.iterator()
循环:
white(it.hasNext()) {
// 可输出每个元素 it.next()
}
Object类:是所有类的父类
上一篇: python 中的 import
下一篇: JAVA杂记