1.面向对象的概念
- 基于面向过程
- 面向过程:重视的是完成事情的过程
- 面向对象:重视是对象,调用对象的功能
- 构造方法:创建对象就是调用类中的构造方
- 构造方法定义格式的特点:
1.构造方法没有返回值类型,也没有返回值
2.构造方法名字必须和类名一模一样 - 构造方法的特点:
1.类中没有定构造方法:java会默认提供一个空参数构造方法 public Student(){}
2.类中提供了构造方法:java不会在提供默认空参数构造方法了,要使用空参数构造方法,必须手动写出
3.构造方法可以重载
2.this关键字
- this关键字
- this关键字代表本类对象的引用
- 哪个对象调用的方法,方法中的this就是哪个对象
- 作用:
- 当我们局部变量和成员变量重名的使用,使用this关键字可以进行区分
- this.变量名代表成员变量
3.匿名对象
- 匿名对象:没有名字的对象
- 在创建对象的时候,没有把对象赋值给某一个变量,只有创建对象的语句,叫匿名对象
- new Person(); new Scanner(System.in);
- 特点:匿名对象只能使用一次,使用完毕会被JVM在空闲的时候垃圾回收,可以节约内存
- 作用:当对象只使用一次的时候,就可以使用匿名对象
4.继承的概念
- 子类继承父类,子类就会自动拥有父类所有有的成员变量和成员方法
- 继承的好处:
1.可以提高代码的复用性(重复的使用)
2.继承是多态的前提 - 继承的注意事项
- 父类的构造方法子类是不能继承的,构造方法是创建本类对象使用的 父类使用父类的构造方法创建对象,子类使用自己的构造方法创建对象
- 父类的私有成员,子类是不能直接使用的 私有的只有本类可以使用,子类不能直接使用
- 方法重写是发生在子父类之间的关系。没有父类就没有方法重写
- 子类方重写父类方法，必须要保证权限大于等于父类权限。
- 子类方法重写父类方法，返回值类型、方法名和参数列表都要一模一样。
- 父类的私有方法,属于父类本身,子类不能重写
- 构造方法也不能重写,属于类本身
四大权限修饰符:
- public :公共的:本项目中的任意包,任意的类中都可以使用
- protected:受保护的:既能在本类中使用,又能在本包的其他类中使用,还能在不同包的子类中使用
- default默认(不写):既能在本类中使用,又能在本包的其他类中使用
- private:私有的:只能在本类中使用
- public>protected>默认>私有
super关键字:调用父类的构造方法
super();调用父类的空参数构造方法
super(参数);调用父类的带参数构造方法
注意:
1.子类的构造方法,没有写super,默认会有一个super(),调用父类的空参数构造方法
2.super();super(参数);必须写在子类构造方法的第一行
3.super()和this()不能一起使用,有冲突,都必须写在第一行
抽象方法
父类是根据子类共性抽取形成
共性的成员变量
共性的成员方法
每个子类工作的内容不同,只抽取方法声明,添加abstract关键字修饰,叫抽象方法
格式:
权限修饰符 abstract 返回值类型 方法名(参数列表);
public abstract void work():
包含抽象方法类,必须是一个抽象类,也需要被abstract修饰
- 抽象类无法直接创建对象使用
- 抽象类一般都包含抽象方法,抽象方法没有方法体,创建对象,调用方法没有意义
- 抽象类中，不一定包含抽象方法，但是有抽象方法的类必定是抽象类
- 需要定义子类,继承抽象父类,重写父类的抽象方法,创建子类对象使用
final关键字
- final修饰的类:是一个最终类,不能被继承
- final修饰的方法:是一个最终方法,子类可以继承使用,但是不能重写
- final修饰的变量:是一个常量,值不能改变
- 注意:局部变量唯一的修饰符就是final
static关键字
static是静态修饰符，一般修饰成员。被static修饰的成员属于类，不属于单个这个类的某个对象。
static修饰的成员被多个对象共享。static修饰的成员属于类，但是会影响每一个对象。被static修饰的成员又叫类成员，不叫对象的成员。
静态的成员属于类,所以我们通过类名可以直接使用，
- 类名.静态成员变量
- 类名.静态成员方法(参数);
接口
是引用数据类型的一种,是功能的集合
接口中不能定义变量,只能定义常量
定义接口使用也是.java文件;编译生成.class文件
定义接口使用关键字 interface
定义格式:
修饰符 interface 接口名{
抽象方法;(JDK7)
默认方法;(JDK8)
静态方法;(JDK8)
常量(很少使用)
}
注意:
接口中的抽象方法,修饰符固定为public abstract,可以省略不写,不写默认也是
类中的抽象方法的修饰符不能省略
抽象方法定义格式:
- public abstract 返回值类型 方法名(参数列表);
- abstract 返回值类型 方法名(参数列表);
- public 返回值类型 方法名(参数列表);
- 返回值类型 方法名(参数列表);
建议:都写上,增强代码的阅读性
-----------------------------------------------------------
1.接口中没有构造方法,也不能创建对象使用
2.定义一个实现类,实现接口,重写接口中的抽象方法,创建实现类对象使用
默认方法的定义格式:
修饰符 default 返回值类型 方法名(参数列表){
方法体;}
注意:
接口中默认方法的default关键字是不能省略的
含有默认方法的接口:定义实现类实现接口,选择性的重写默认方法
重写了默认方法:使用实现类重写后的
没有重写默认方法:使用继承自接口的
注意:
在实现类中重写默认方法,去掉default关键字
静态方法的定义格式:
修饰符 static 返回值类型 方法名(参数列表){
方法体;
}
注意:
1.接口中的静态方法static关键字不能省略
2.静态方法属于接口本身,通过接口名可以直接使用
注意:
接口中的静态方法,实现类不能继承,也不能重写
含有抽象方法接口的多实现
格式:
public class 实现类名 implements 接口1,接口2,...接口n{
重写所有接口中的抽象方法
}
注意:
多个接口中的抽象方法有重名的,不会冲突,抽象方法没有方法体
实现类重写一次同名的抽象方法就可以了,相当于重写所有的同名抽象方法
含有默认方法接口的多实现
格式:
public class 实现类名 implements 接口1,接口2,...接口n{
}
注意:
1.多个接口中的默认方法没有重复的,实现类可以选择性的重写
重写:使用重写后的
没有重写:使用继承自接口的
2.多个接口中默认方法有重复的,实现类[必须]重写这个重复的默认方法
有不确定性,实现不确定使用的是哪个接口中的默认方法，重写之后使用自己的
含有静态方法接口的多实现
类和接口之间:静态方法不能继承,也不能重写
类与类之间:静态方法可以继承,不能重写
类继承类的同时实现多个接口
格式:
public class 子类 extends 父类 implements 接口1,接口2,接口3...接口n{
}
注意:
1.子类必须重写父类和接口中所有的抽象方法
2.如果父类的普通方法和接口的默认方法重名,默认使用父类的
接口的多继承
1.类与类之间:单继承关系
public class 子类 extends 父类{ }
2.类与接口之间:实现关系
public class 实现类 implements 接口1,接口2...接口n{ }
3.接口与接口之间:多继承关系
public interface 子类接口 extends 接口1,接口2...接口n{ }
注意:
接口继承多个接口,相当于求接口的并集,子接口包含父接口中所有的抽象和默认方法
父接口中的默认方法有重名的,子接口必须重写,有不确定性,不确定使用哪个父接口的重复方法
重写之后使用自己的
1.接口中，无法定义成员变量，但是可以定义常量，其值不可以改变
2.接口中，没有构造方法，不能创建对象。
3.接口中，没有静态代码块
多态
概念:
父类的变量指向子类的对象
接口的变量指向实现类对象
格式:
父类类型 变量名 = new 子类对象();
接口类型 变量名 = new 实现类对象();
特点:
1.多态调用的是子类重写后的方法,如果没有方法重写,多态没有意义
2.多态指向哪个子类对象,就调用哪个子类对象重写后的方法
多态的好处和弊端
好处:扩展性强
父类的引用变量可以赋值不同的子类对象,而调用不同子类重写后的方法
弊端:无法使用子类特有的成员
多态的转型
1.向上转型:多态本身就是向上转型,把子类对象赋值给父类
好处:扩展性强,赋值不同的子类对象,调用不同子类重写后的方法
弊端:无法使用子类特有的功能
格式:
父类类型 变量名 = new 子类对象();
int a = 10;
double d = a;
2.向下转型:把多态的父类变量,强制转换为子类类型
好处:把父类类型转换为子类类型,就可以使用子类特有的功能
弊端:扩展性性差
格式:
子类类型 变量名 = (子类类型)父类变量名;
double d = 10;
int a = (int)d;
前提:
向下转型的前提必须是多态,直接创建父类对象,不能转型的
instanceof关键字
向下转型的时候,类型书写错误,容易引发类型转换异常
作用: 判断某个对象是否属于某种数据类型,可以在向下转型之前先判断
格式:
boolean b = 对象 instanceof 数据类型;
如果对象属于对应的数据类型,返回true
如果对象不属于对应的数据类型,返回false
注意:
对象是根据类创建对象,对象所属的类要判断的数据类型之间必须有继承或者实现关系,才能判断
内部类:定义在其他类内部的类
成员内部类:把类定义在其他类的成员位置(类中方法外)
局部内部类:把类定义在其他类的方法中
成员内部类:我们很少自己定义,但是在看java底层源码时可见(迭代器)
定义格式:
public class 外部类名{
public class 成员内部类名{
成员内部类的成员变量
成员内部类的成员方法
}
}
使用格式: 通过外部类找到内部类使用
外部类名.内部类名 变量名 = new 外部类().new 内部类();
注意:
1.在内部类中可以直接使用外部类的成员
2.内部类只是定义在其他的类的内部,其他使用方式不变,也可以继承父类,实现接口
局部内部类
把类定义在其他类的方法中
定义格式:
public class 外部类名{
修饰符 返回值类型 外部类方法名(参数){
(final)class 局部内部类名{
局部内部类的成员变量
局部内部类的成员方法();
}
局部内部类名 变量名 = new 局部内部类名():
变量名.局部内部类的成员变量
变量名.局部内部类的成员方法();
}
}
使用格式:局部内部类和局部变量一样,作用域只在方法中有效,出了方法类就消失了
所以我们需要在方法中定义完局部内部类之后,理解创建对象使用
匿名内部类
匿名:没有名字
内部类:写在方法中就是局部内部类,写在成员位置就是成员内部类
匿名内部类作用:简化代码
把定义子类继承父类,重写父类的方法,创建子类对象合成一步完成
把实现类实现接口,重写接口中的方法,创建实现类对象合成一步完成
格式:
new 父类|接口(){
重写父类|接口中的方法}
代码块:被{ }包裹起来的一段代码
- 局部代码块:写在方法中的代码块
- 构造代码块:写在成员位置(类中方法外)的代码块
- 静态代码块:写在成员位置(类中方法外),被static修饰的代码块
1.局部代码块:写在方法中的代码块
变量的作用域:变量的作用域在变量所在的{ }的范围内有效
作用:
可以降低变量的作用域,可以提高程序的效率
如果变量只想在局部使用,使用完毕想立即销毁,就可以使用局部代码块
2.构造代码块:写在成员位置(类中方法外)的代码块
特点:
优先于构造方法执行,每创建一次对象,都会执行一次构造代码块中的代码
作用:
1.可以给成员变量赋值
2.可以把构造方法中共性的内容放在构造代码块中,提高代码的利用率(复用性)
3.静态代码块:写在成员位置(类中方法外),被static修饰的代码块
特点:
1.static修饰的成员,不属于某一个对象,被所有对象所共享,属于类
静态代码块属于类,不属于某一个对象,无论创建多少次对象,只执行一次
2.静态的成员优先于非静态的成员加载到内存中
静态代码块优先执行,优选于构造代码块和构造方法
总结:静态代码块优先执行,只执行一次
作用:
1.可以给静态的成员变量赋值
2.优先执行,只执行一次,可以做一些项目的初始化{数据库==>jdbc}
包装类:使用一个类把基本数据类型的数装起来,这个类叫包装类
基本数据类型:
byte short int long float double char boolen
对应的包装类:
Byte Short Integer Long Float Double Character Boolen
String类中常用的成员方法
- String concat(String str) 将指定字符串连接到此字符串的结尾。 把两个字符串连接到一起
- boolean contains(String s) 判断字符串中是否包含指定的字符串;包含返回true,不包含返回false
- boolean endsWith(String suffix) 判断字符串是否以指定的字符串结尾;是返回true,不是返回false
- boolean startsWith(String prefix) 判断字符串是否以指定的字符串开头;是返回true,不是返回false
- int indexOf(String str) 从前往后在字符串中查找另外一个字符串,找到了返回字符串对应的索引,找不到返回-1
- int lastIndexOf(String s) 从后往前在字符串中查找另外一个字符串,找到了返回字符串对应的索引,找不到返回-1
- String replace(String target, String replacement) 把大的字符串中所有的目标字符串,替换为新的字符串，目标字符串:String target，替换的新字符串:tring replacement
- String substring(int beginIndex) 从开始索引beginIndex截取字符串到字符串的末尾
- String substring(int beginIndex, int endIndex) 从开始索引beginIndex到结束索引endIndex截取字符串;包含头,不包含尾
- char[] toCharArray() 将此字符串转换为一个新的字符数组。
- byte[] getBytes() 查询系统默认的编码把字符串转换为字节数组
- String toLowerCase() 把字符串中所有的英文字符转换为小写
- String toUpperCase() 把字符串中所有的英文字符转换为大写
- String trim() 去掉字符串两端的空格
- String[] split(String regex) 根据自定的字符串对字符串进行切割,把一个字符串切割为几部分字符串,放在一个数组中返回
- boolean equals(String str) 比较两个字符串的内容是否相同,区分大小写
- boolean equalsIgnoreCase(String anotherString) 比较两个字符串的内容是否相同,不区分大小写
- char charAt(int index) 返回字符串指定索引处的字符
- int length() 返回此字符串的长度。
基本数据类型:4类8种 byte short int long float double char boolen
引用数据类型:数组,接口,String类,集合,自定义类型(Person,Student)
基本数据类型使用的是值
int a = 10; double d = 1.1;
引用数据类型:引用的都是堆内存中对象的地址值
集合与数组的区别
数组:
- 是引用数据类型的一种
- 可以存储多个元素
- 数组的长度是固定的
- 数组即可以存储基本类型的数据,又可以存储引用数据类型的数据
集合:
- 是引用数据类型的一种
- 可以存储多个元素
- 集合的长度是可以变化的
- 只能存储引用数据类型的数据
Collection集合的常用功能
public boolean add(E e) ： 把给定的对象添加到当前集合中 。
public boolean remove(E e) : 把给定的对象在当前集合中删除。
public boolean contains(Object obj) : 判断当前集合中是否包含给定的对象。
public boolean isEmpty() : 判断当前集合是否为空。
public int size() : 返回集合中元素的个数。
public Object[] toArray() : 把集合中的元素，存储到数组中
public void clear() :清空集合中所有的元素
迭代器对集合进行取元素
1.创建集合对象,往集合中添加元素
Collection<String> coll = new ArrayList<>();
coll.add();
2.使用Collection接口中的方法iterator,获取迭代器的实现类对象
Iterator<String> it = coll.iterator();
3.使用迭代器对象Iterator中的方法hasNext和next遍历集合
while(it.hasNext()){
String s = it.next();
System.out.println(s);
}
注意:迭代器只能使用一次,想再次使用迭代器,必须重新获取迭代器对象
增强for循环遍历集合和数组
for(集合|数组中元素的数据类型 变量名: 集合|数组){
sout(变量名);
}
泛型上下限
泛型的上限限定: ? extends E ==>传递的未知类型?只能是E的子类或者本身
泛型的下限限定: ? super E ==>传递的未知类型?只能是E的父类或者本身
泛型的通配符: ? 可以接收任意的数据类型
定义格式:泛型定义在修饰符和返回值类型之间
修饰符 <泛型> 返回值类型(使用泛型) 方法名(参数列表==>使用泛型){
方法体;
}
数据类型
1.数据结构_栈:先进后出
2.数据结构_队列:先进先出
3.数据结构_数组:查询快,增删慢
4.数据结构_链表:查询慢,增删快
java.util.Collections类:是操作集合的工具类
里边的方法都是静态的,通过类名可以直接使用
常用的方法:
static void sort(List<T> list) 根据元素的自然顺序 对指定集合按[升序]进行排序。
static void shuffle(List<?> list) 随机打乱集合中元素的顺序
static <T> void sort(List<T> list, Comparator<? super T> c) 根据指定[比较器产生的顺序]
对指定集合进行排序。
注意:
以上三个静态方法的参数类型是List接口,所以只能传递List接口下边的实现类(ArrayList,LinkedList)
不能传递Set接口下的集合(HashSet,LinkedHashSet)
Comparator比较器
强行对某个集合进行整体排序的比较函数。
成员方法:int compare(T o1, T o2) 比较用来排序的两个参数。
参数:T o1, T o2:会依次获取到集合中相邻的两个元素
排序的规则:
- o1-o2:升序排序
- o2-o1:降序排序
- o1==o2:两个元素相等
Collections.sort(list01, new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
//降序排序:o2-o1
return o2-o1;
}
});
多线程
- 多线程程序创建的第一种方式:继承Thread类
- 多线程程序创建的第二种方式:实现Runnable接口
- 多线程程序创建的第三种方式:实现Callable接口
- 多线程程序创建的第四种方式:线程池
获取线程的名称
- 可以使用Thread类中的方法getName获取
- 可以先static Thread currentThread() 返回对当前正在执行的线程对象的引用，再通过线程中的方法getName获取线程
- 注意:getName方法只能在Thread类的子类中使用
- 注意:currentThread是静态方法,在任意的地方都可以使用
java.util.concurrent.Executors:是一个生产线程池的工厂类
static ExecutorService newFixedThreadPool(int nThreads) 创建一个可重用固定线程数的线程池
常用方法:
- Future<?> submit(Runnable task) 提交一个 Runnable 任务用于执行，并返回一个表示该任务的Future。
- Future<?> submit(Callable<T> task) 提交一个返回值的任务用于执行，返回一个表示任务的未决结果的 Future。
- submit方法会从线程池中获取一个线程,执行这个线程任务,执行完毕把线程在归还给线程池
- 返回值:Future<?>:用来接收Callable线程任务中执行的call方法的返回值
- void shutdown() 用于销毁线程池
Lambda表达式
Lambda表达式使用前提:只能对象函数式接口(有且仅有一个抽象方法的接口)的匿名内部类进行简化
Lambda表达式是可推导可以省略的，省略就是重写唯一的抽象方法
格式:
(参数列表)->{重写抽象方法的方法体}
简化:
- 1.(参数列表):参数列表中的数据类型可以省略不写
- 2.(参数列表):参数列表中只有一个参数,那么小括号()也可以省略不写,但是如果没有参数,小括号必须写
- 3.{重写抽象方法的方法体}:无论方法是否有返回值,如果方法体只有一行代码,省略return和{ }和这行代码结束的分号;
- 注意:这个部分必须一起省略
函数式接口的定义
函数式接口:接口中有且仅有一个抽象方法
注解:
@FunctionalInterface:检查接口是否为函数式接口
@Override:检查方法是否为重写的方法
Stream
获取Stream流的方式
- 在JDK1.8版本之后Collection接口,里边定义了一个方法叫stream,用于把集合转换为Stream流
- default Stream<E> stream() 返回一个序列 Stream与此集合作为其来源。
- Collection接口下所有的实现类都可以使用stream方法
- 在JDK1.8版本之后,定义Stream接口,在接口定义了一个方法叫of,可以把可变参数(数组)转换为Stream流
- java.util.stream.Stream<T>接口
- static <T> Stream<T> of(T... values) 方法参数传递可变参数,也可以传递数组
函数拼接与终结方法
- 凡是返回值仍然为 Stream 接口的为函数拼接方法，它们支持链式调用；
- 而返回值不再为Stream 接口的为终结方法，不再支持链式调用。
forEach:遍历
count:统计个数
filter:过滤
limit:获取前n个
skip:跳过前n个
map:映射,把一种数据类型转换为另外一种数据类型
concat:组合 把两个流组合为一个流
将流中的内容收集到集合和数组中
List<String> list = stream.collect(Collectors.toList());
Set<String> set = stream.collect(Collectors.toSet());
Object[] arr = stream.toArray();
File类
- 构造方法
- public File(String pathname) ：通过将给定的路径名字符串转换为抽象路径名来创建新的 File实例。
- public File(String parent, String child) ：从父路径名字符串和子路径名字符串创建新的 File实例。
- public File(File parent, String child) ：从父抽象路径名和子路径名字符串创建新的 File实例。
- 常用方法
- public String getName() ：获取构造方法中路径的名称(末尾部分)
- public String getAbsolutePath() : 获取构造方法中路径的绝对路径
- public long length() ：获取文件的大小,单位是字节
- public boolean isDirectory() ：是否为目录(文件夹)。
- public boolean exists() ：判断构造方法中传递的路径是否存在
- public boolean createNewFile() ：当且仅当具有该名称的文件尚不存在时，创建一个新的空文件。
- public boolean mkdir() ：创建单级文件夹
- public boolean mkdirs() ：即可以创建单级文件夹,又可以创建多级文件夹
- public boolean delete() ：删除文件和文件夹,不走回收站
- 遍历文件夹
- public String[] list() ：遍历构造方法传递的文件夹,获取文件夹中每一个文件|子文件夹的名称,把多个名称存储到一个String类型的数组中返回
- public File[] listFiles() ：返回一个File数组，表示该File目录中的所有的子文件或目录。遍历构造方法传递的文件夹,获取文件夹中每一个文件|子文件夹,把文件|子文件夹封装为File对象,多个File对象存储到一个File类型的数组中返回
递归:方法自己调用自己
分类:
1.直接递归
2.间接递归
注意事项:
1.递归必须有结束的条件,保证方法自己调用自己能停止下来,否则会抛出栈内存溢出的错误
2.递归有结束的条件,但是递归的次数也不能太多了,否则会抛出栈内存溢出的错误
3.构造方法禁止递归
扫一扫
7057
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
