第四周知识点总结
day17-day21
接口和抽象类的区别：
1.成员的区别
- 成员变量:接口只能是常量,存在默认修饰符 public static final ,可以省略 不写 抽象类:可以是变量,也可以自定义常量
- 成员方法:接口:只能是抽象方法, 默认修饰符:public abstract ,可以省略不 写 抽象类:既可以存在抽象方法,也可以存在非抽象方法, 如果是抽象方 法,abstract不能省略;
- 构造方法:接口:没有构造方法, 通过接口多态实例化,通过具体的子实现类对象 的创建 抽象类:无参/有参构造方法, (抽象类不能实例化,需要靠具体的子类 实例化)分层初始化,先父类初始化,然后在子类初始化
2.关系区别
- 类与类: (类:包含具体类或者抽象类), 继承关系 extends, 可以单继 承,不能多继承,可以多层继承;
- 类与接口:实现关系 implements,一个类继承另一个类的同时,可以实现多 个接口
- 接口与接口:继承关系:extends,可以支持单继承,也可以多继承以及多层 继承
3.设计理念的区别
- 接口:体现出的这个事物本身不具备的功能,一种额外功能; 是一种"like a"的关系
- 抽象类: 由于不能实例化,需要具体的子类实例化,体现的是一种"is a"的关系 A类是B类的一种,或者是B是A的一种；
形式参数:类,具体类或者抽象类 接口以及返回值问题—>具体类/抽象类/接口类型 (重点)
方法的形式参数是具体类：–实际参数new的就是这个具体类对象，或者方式二使用匿名对象进行传递
方法的形式参数问题:
* 基本类型:简单 (形式参数的改变不影响实际参数),要什么基本类型,实际参数直接传递具体的数据值 (比如int)
* 引用类型: Java玩的就这个类型;
* 如果是具体类,在调用该方法,那么实际参数如何传递?
* 实际参数需要这个具体类的对象;
*
class Student{
public void study(){
System.out.println("学习JavaEE之JavaSE基础");
}
}
class StudentDemo{
public void method(Student student){//形式参数一个引用类型:具体类,调用该方法,实际参数需要一个学生对象
student.study() ;
}
}
//测试类
public class ArgsDemo1 {
public static void main(String[] args) {
//调用StudentDemo类的method方法
//创建StudentDemo类对象
StudentDemo sd = new StudentDemo() ;
//调用该方法,实际参数需要一个学生对象
Student s = new Student() ;
sd.method(s); //实际参数s
}
}
方法的形式形式参数是抽象类–实际参数new的就是子类对象
/**
* 方式的形式参数是引用类型:
如果是抽象类,调用该方法,实际参数如何传递?
实际参数需要该抽象类的具体的子类对象; 抽象类多态
*/
abstract class Person{//人类
public abstract void work(); //工作
}
class PersonDemo{
//成员方法
public void show(Person p){//形式参数是一个抽象类,抽象类不能实例化,需要new 它的子类对象 抽象类多态
p.work() ;
}
}
//只能现在提供抽象类的具体的子类
class Worker extends Person{
@Override
public void work() {
System.out.println("爱生活,爱工作,爱高圆圆");
}
}
//测试类
public class ArgsDemo2 {
public static void main(String[] args) {
//要访问PersonDemo类里面的show方法
PersonDemo pd = new PersonDemo() ;
//创建Person对象
//Person p = new Person();
// pd.show(p);
//抽象类多态
Person p = new Worker() ;
pd.show(p);
System.out.println("-----------------------------------------");
//匿名对象
pd.show(new Worker());
}
}
方法的形式参数是接口–实际参数new的就是子实现类对象
/**
*方式的形式参数是引用类型:
* 如果是接口,调用该方法,实际参数如何传递?
* 实际参数:需要传递该接口的子实现类对象 接口多态的形式
*/
interface Love{
void love() ;
}
class LoveDemo{
public void function(Love lo){ //方法形式参数是一个接口类型,接口new不了
lo.love();
}
}
//需要提供具体的子实现类
class LoveImpl implements Love{
@Override
public void love() {
System.out.println("love loveImpl...");
}
}
//测试类
public class ArgsDemo3 {
public static void main(String[] args) {
//调用LoveDemo类的中的function方法
//创建LoveDemo类对象
LoveDemo ld = new LoveDemo() ;
//创建Love对象
//Love love = new Love() ;//接口不能实例化,肯定需要接口的子实现类
//ld.function(love);
//接口多态的方式:接口名 对象名 = new 具体的子实现类名() ;
Love love = new LoveImpl() ;
ld.function(love);
}
}
返回值问题
返回引用类型-具体类：一定要return当前这个具体类的类对象，或者是用匿名对象的格式
/**
* 返回值问题的研究(引用类型重点)
* 返回基本类型:简单, 比如 返回int---->谁调用这个方法,调用者就必须使用int类型接收
* 返回引用类型:
* 方法的返回值,返回的是一种具体类型的情况,方法如何结束呢?
* 一定要返回当前这个具体的类的对象 ;
*/
class Demo{
public int getMax(int a,int b){//方法的返回值是基本类型
if(a>b){
return a;
}else{
return b ;
}
}
}
//学生类
class Student{
public void study(){
System.out.println("正在学习JavaEE");
}
}
//StudentDemo
class StudentDemo{
public Student method(){//这个的返回值是一个引用类型,具体类---方法结束,必须返回一个当前类的具体类对象
// 如何结束???
//return Student;
//方式1 :
/*Student s = new Student() ;
return s;*/
//方式2:匿名对象的格式
return new Student() ;
}
}
//测试
public class ReturnDemo1 {
public static void main(String[] args) {
//调用Demo类的getMax方法
Demo demo = new Demo() ;
int result = demo.getMax(10,20) ; //调用者
System.out.println(result);
System.out.println("---------------------------------------------") ;
//调用StudentDemo这个类里面的method方法
StudentDemo sd = new StudentDemo() ;
Student s = sd.method(); // 这个方法的本质: new Student();
s.study() ;
}
}
返回引用类型-抽象类：一定要return当前这个抽象类的子类对象（new），或者是用匿名对象的格式
/**
* 返回引用类型:
* 方法的返回值,返回的是一种抽象类情况,方法如何结束呢?
* 要提供抽象类的子类对象
//抽象类
abstract class Person{
public abstract void work();
}
class PersonDemo {
public Person show(){ //方法的返回值是一个抽象类,必须要提供抽象类子类
//??
/* Person p = new Person() ;//抽象类不能new
return p ;*/
//return new Person() ;
//需要抽象类的子类对象:抽象类多态
//方式1:抽象类多态
/* Person p = new Programmer() ;
return p;*/
//方式2:匿名对象
return new Programmer() ;
}
}
//定要一个子类:抽象类的子类
class Programmer extends Person{
@Override
public void work() {
System.out.println("不断的去完成项目开发...");
}
}
//测试类
public class ReturnDemo2 {
public static void main(String[] args) {
//调用PersonDemo的show方法
PersonDemo pd = new PersonDemo() ;
Person person = pd.show(); //show方法本质 new Programmer() ;
person.work();
}
}
返回引用类型-接口：一定要return当前这个接口的子实现类（new），或者是用匿名对象的格式
/**
* 返回值问题情况3:
* 如果方法的返回值是一个接口,这个方法结束的时候如何返回?
*/
//定义一个接口
interface Mary{
void mary() ;
}
//定义一个类
class MaryDemo{
public Mary method(){ //方法的返回值是接口类型,接口实例化不了的!
//??
//Mary mary = new Mary() ;
// return mary ;
//return new Mary() ;
//方式1:接口多态
// Mary mary = new WeddingCompany() ;
//return mary ;
//方式2:匿名对象
return new WeddingCompany() ;
}
}
//需要接口的子实现类
//婚庆公司
class WeddingCompany implements Mary{
@Override
public void mary() {
System.out.println("婚庆公司布置婚礼现场!");
}
}
//测试类
public class ReturnDemo3 {
public static void main(String[] args) {
//调用MaryDemo类名的method方法
MaryDemo maryDemo = new MaryDemo() ;
Mary m = maryDemo.method();//method方法本质:创建子实现类对象 new WeddingCompany() ;
m.mary();
}
}
.关于默认修饰符,私有修饰符private,protected,public的范围?
private范围最小:仅仅在当前类中 默认修饰符:同一个包下都能访问 大于private
protected:同一个包下或者不同包的子类 大于默认修饰符 public:访问权限最大
范围：private<默认修饰符<protected<public
匿名内部类是局部内部类的一种简化格式(重点)
匿名内部类:就是没有名字的类
* 格式 **
* 抽象类或者接口的匿名内部类
* * new 类名或者是接口名(){ //类:一般都是抽象类 ,具体类也可也,但是不推荐 ** 重写方法() {
* * ... *
* }
* };
* * 场景范围:就是在方法的形式参数以及返回值是抽象类或者接口的情况下,是一种简 化格式
* 匿名内部类的本质:
* 就是继承该类(抽象类)或者实现了给接口的子类对象;
匿名内部类在开发中的使用 (形式参数是一个抽象类)
/*** 匿名内部类在开发情况的使用
** 方法的形式参数如果是抽象类的情况,调用该方法,实际参数需要传递当前抽象类的 子类对象
** 匿名内部类的本质:
* 代表继承了 该类(抽象类)或者实现该接口的子类对象
匿名内部类在开发中的使用 (形式参数是一个接口)
本质：代表着实现该接口的子类对象
interface Love{
void show() ;
void show2() ;
}
/*
class LoveImpl implements Love{ //类名 LoveImpl
@Override
public void show() {
}
@Override
public void show2() {
}
}
*/
//外部类
class Outer2{
public void method(){
//没有使用匿名内部类之前
/* class Inner2{
public void show(){
System.out.println("show Inner...");
}
public void show2(){
System.out.println("show2 Inner... ");
}
}
//创建Inner对象
Inner2 inner = new Inner2() ;
inner.show();
inner.show2() ;*/
/*
new 类名或者是接口名(){
* 重写方法() {
...
}
};
*/
//匿名内部类格式:简化书写格式
/* new Love(){
@Override
public void show() {
System.out.println("show Love");
}
@Override
public void show2() {
System.out.println("show2 Love");
}
}.show();
new Love(){
@Override
public void show() {
System.out.println("show Love");
}
@Override
public void show2() {
System.out.println("show2 Love");
}
}.show2();*/
//上面这个格式在访问方法上面比较麻烦
//优化:
//给匿名内部类 new 类名或者接口名(){...重写方法} 起一个对象名字
Love l = new Love(){
@Override
public void show() {
System.out.println("show Love");
}
@Override
public void show2() {
System.out.println("show2 Love");
}
} ;
l.show();
l.show2();
}
}
//测试类
public class NoClassDemo {
public static void main(String[] args) {
Outer2 outer2 = new Outer2() ;
outer2.method();
}
}
/**
* 匿名内部类:就是没有名字的类
*
* 匿名内部类只是内部类的一种简化格式;
* 格式
*
* 抽象类或者接口的匿名内部类
* new 类名或者是接口名(){ //类:一般都是抽象类 ,具体类也可也,但是不推荐
*
* 重写方法() {
* ...
* }
* };
* 场景范围:就是在方法的形式参数以及返回值是抽象类或者接口的情况下,是一种简化格式
* 匿名内部类的本质:
* 就是继承该类(抽象类)或者实现了给接口的子类对象;
*
*
*/
匿名内部类,在方法的返回值的用法(返回值是抽象类)
/**
* 匿名内部类在开发情况的使用
*
* 方法的形式参数如果是抽象类的情况,调用该方法,实际参数需要传递当前抽象类的子类对象
*
* 匿名内部类的本质:
* 代表继承了 该类(抽象类)或者实现类该接口的子类对象
* new 抽象类名或者接口名(){
*
* 重写抽象方法...
* } ;
*/
abstract class Person{
public abstract void work() ;//工作
}
class PersonDemo{
public void method(Person p){ //抽象类 作为形式参数,抽象类不能实例化
p.work();
}
}
//定义子类 继承自Person类,重写work
/*class Worker extends Person{
@Override
public void work() {
System.out.println("日日夜夜敲代码...");
}
}*/
//测试类
public class Test {
public static void main(String[] args) {
//调用PersonDemo类的method 方法
/* PersonDemo pd = new PersonDemo() ;
//抽象类多态:
Person p = new Worker() ;
pd.method(p)*/; // ---->p.work();
//方式2:匿名内部类
PersonDemo pd = new PersonDemo() ;
// new 抽象类名或者接口名(){
// *
// * 重写抽象方法...
// * } ;
pd.method(new Person(){
@Override
public void work() {
System.out.println("日日夜夜敲代码");
}
});
}
}
匿名内部类,在方法的返回值的用法(返回值是接口)
/**
* 方法的形式参数如果是一个接口,调用方法,实际参数需要传递该接口子实现类对象
* 或者传递接口的匿名内部类
*/
//飞的接口
interface Fly{
void fly() ;
}
class FlyDemo{
public void method(Fly fly){//方法的形式参数是一个接口,调用方法,需要接口的子实现类对象
fly.fly();
}
}
//定义一个子实现类 实现Fly接口
class Bird implements Fly{
@Override
public void fly() {
System.out.println("鸟会飞了...");
}
}
//测试列
public class Test2 {
public static void main(String[] args) {
//调用FlyDemo类的method方法
FlyDemo fd = new FlyDemo() ;
//接口多态
Fly fly = new Bird() ;
fd.method(fly); //----->fly.fly();
System.out.println("------------------------------------------");
//直接 匿名内部类
/**
* new 类名或者接口名(){
* 重写方法
* } ;
*/
FlyDemo fd2 = new FlyDemo() ;
fd2.method(new Fly(){
@Override
public void fly() {
System.out.println("会飞了...");
}
});
}
}
面试题
面试题:
jdk版本7的版本,局部内部类访问的外部类的成员方法的局部变量,这个局 部变量有什么特点?为什么?
-
- jdk7的版以及以前:int num = 20 ; 立即报错:必须被final修饰!
-
- jdk8已经优化了,通过反编译查看, num已经被final修饰符
** 为什么?
-
- 因为局部变量的生命周期,随着方法的调用而存在,随着方法调用结束而 消失,下面这个代码show(),调用完毕,num应该就被是释放了 ** 但是,show方法里面创建的局部内部类对象,对象里面的成员方法在间接 的使用局部变量,此时不能让num立即释放,必须为final修饰符 * 最终的,无法更改的,是一个常量!
代码展示：
/**
* 看程序,补全代码 控制台输出,30,20,10
*
* 内部类和外部类就没有继承关系
*/
class Outer4{
int num = 10 ;
//成员内部类
class Innter4{
int num = 20 ;
//成员内部类的成员方法
public void show(){
int num = 30 ;
//补全代码
System.out.println(num);//遵循就近
System.out.println(this.num); //this:代表当前类对象的地址值引用 Inner4这个类的方法
// System.out.println(new Outer4().num); //new Outer4().num :外部类对象访问
System.out.println(Outer4.this.num) ; //外部类名.this.变量名: 外部类的this限定
}
}
}
//测试类
public class Test {
public static void main(String[] args) {
Outer4.Innter4 oi = new Outer4().new Innter4() ;
oi.show();
}
}
Java的常用类：Object,String，StringBuffer,Character,Random,System,Date
Object:重点类 所有的类的父类:几乎的成员方法都需要被任何子类重写 toString()/hashCode()/equals()...
String类:重点类(开发中使用最多的)--因为前后端交互，前端返回的一半都是字符串类型
掌握常用类里的常用功能
Object
/**
* Object:所有Java类的父类(自定义的类或者jdk提供的类),也称为"超类"
* 任何类默认继承自Object
*
* 常用的功能:
* public String toString():本身的含义 :返回对象的字符串表示形式(直接输出对象的名称,就是地址值)
* 结果应该是一个简明扼要的表达，容易让人阅读。 建议所有子类覆盖此方法
*
* idea工具自动生产
* alt+fn+ins---->toString()--->ok
*
*
常用功能
/**
* Object类的常用功能:
* 常用的功能:
* public String toString():本身的含义 :返回对象的字符串表示形式(直接输出对象的名称,就是地址值)
* 结果应该是一个简明扼要的表达，容易让人阅读。 建议所有子类覆盖此方法
*
* public final Class getClass():使用对象名调用getClass():获取正在运行的类或者接口(字节码文件对象)
* 也称为"Class类对象"
* public int hashCode() (了解:哈希算法---提供哈希表) 返回对象的哈希码值 (理解为 "地址值",不是实际意义的地址值)
* 每一个对象的哈希码值不同的
*
*
* 面试题:
* 获取一个了类的字节码文件对象有几种方式: (三种方式之一)
* public final Class getClass(): Object类的
*/
Object类的equals
/**
* Object类的equals
* public boolean equals(Object obj):比较两个对象是否相同
* ==和equals区别
*
* ==:
* 基本类型:比较的是数据值是否相同
* 引用类型:比较的是地址值是否相同
* equals():Object类的方法
* public boolean equals(Object obj) {
* return (this == obj); //this--->就是p obj---->向上转型 p2 ==:比较是两个对象地址值
* }
*
* 本身默认比较的是两个对象的地址值是否相同;当多个对象的成员信息是相同,认为是同一个人,所以
* Object类需要建议所有的子类要重写equals(),比较的是对象的成员信息是否相同!
*
* alt+fn+ins---->eauals and hachcode()--->ok
*
* 几乎jdk中的所有类都基本重写equals()方法,所以比较的是这些类的成员内容是否相同!
public class ObjectDemo {
public static void main(String[] args) {
//创建一个学生
Student s = new Student("高圆圆",43,"女") ;
//直接对象名称,直接默认访问的就是Object类的toString()---->打印出来的地址值
System.out.println(s) ;//com.qf.object_03.Student@1540e19d 直接输出对象名:地址值 没有意义
System.out.println(s.toString());
//重写Object的toString()---->显示让人容易读懂的信息表达式 ---这个事物的具体信息
}
}
代码展示
//学生类
public class Student extends Object{ //默认继承Object 隐藏了extends Object:不用写
private String name ;//姓名
private int age ;//年龄
private String gender ;//性别
//无参
public Student() {
}
//有参
public Student(String name, int age,String gender) {
this.name = name;
this.age = age;
this.gender = gender;
}
//setXXX()/getXXX()
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;
}
//自己手动方式重写Object类的toString
/* @Override
public String toString() {
return "学生的姓名是"+name+",年龄是:"+age+",性别是,"+gender ;
}*/
//idea自动生成
//alt+fn+ins--->属性全选--->ok
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
", gender='" + gender + '\'' +
'}';
}
}
String类–常用功能要记住
/**
* String类: 后端 字符串的功能是最频繁的
*
* 因为前端出来数据(地址栏上的数据都是String)
* String类: 代表字符串,字符串是一个常量,一旦被创建,其值不改变(地址不变,除非重新赋值) ;
*
* 常用的String类的构造方法
* public String() :空参构造
* public String(char[] value):将字符数组构造出字符串 (如果已知字符数组char[],----构造方法---String) (重点)
* public String(char[] value,int index,int length):将一部分字符数组转换成字符串
* public String(byte[] bytes) :将字节数组构造字符串 (如果已知字节数组byte[]-----String) (重点)
* public String(String original):将一个字符串值存储进去,构造成一个字符串对象
*
* 面试题:
* 数组中有没有length()?字符串String类中有没有length()/集合中有没有length()方法?
*
* 数组没有length(),只有length属性
* String的length():获取字符串长度
* 集合没有, size():获取集合长度
*
*/
public class StringDemo {
public static void main(String[] args) {
//测试:空参构造
String s = new String();
System.out.println("s:"+s);
System.out.println(s.length());
System.out.println("---------------------------------") ;
//public String(char[] value):将字符数组构造出字符串
//已知字符串数组
char[] chs = {'我','爱','高','圆','圆'} ; //new char[]{'我','爱','高','圆','圆'}
String s2 = new String(chs) ;
System.out.println("s2:"+s2);
System.out.println(s2.length());
System.out.println("---------------------------------") ;
// public String(char[] value,int index,int length):将一部分字符数组转换成字符串
String ss = new String(chs,1,4);
System.out.println("ss:"+ss);
System.out.println(ss.length());
System.out.println("----------------------------------");
//public String(byte[] bytes) :将字节数组构造字符串
byte[] bytes = {97,98,99,100,101} ;
String s3 = new String(bytes) ; //在ASCII码表中寻找字符值
System.out.println("s3:"+s3) ;
System.out.println(s3.length());
System.out.println("----------------------------------");
// public String(String original):将一个字符串值存储进去,构造成一个字符串对象
String s4 = new String("helloworld") ; //创建一个"helloworld"字符串对象
System.out.println("s4:"+s4) ;
System.out.println(s4.length());
}
}
String常用功能：
String类型作为方法形式参数的特点
String类作为引用类型,当成为方法的形式参数,和基本类型的效果一致:
形式参数的改变,不影响实际参数
String是最为特殊的一种引/用类型， 其他的引用类型,
都是形式参数改变直接影响实际参数! l比如StringBuffer
String 类常用的获取功能以及判断功能
/*
1）public char charAt(int index): 获取指定索引处的字符；
2） public String concat(String str): 字符串拼接功能；
3）boolean contains(String s): 判断宇符串中是否包含指定的某个字符或者某个子字符串(按照第一个字符 判断)；
4） public boolean endsWith(String suffix): 判断此字符串是否- -指 定的字符串结居；
5） public boolean startsWdith(String prefix): 判断此字符串是否一指定的字符串开头；
6） public boolean equals(Object on0bject): 比较是两个字符串的内容是否相同；
7） public boolean equalsIgnoreCase (String aqotherString): 比较两个字符串内容是否相同,忽略大小写；
8） public boolean isEmpty()–判断是否为空（指的是空内容）
String str1=null;//指的是空对象，没有空间地址值
String str2="";//指的是空字符串，有对象有地址值，但是空内容
//控制台如果出现NoPointerException--解决方法就是在操作之前加入判断语句
9） int Length(): 获取字符串长度；
10） public int index0f(int ch): 查询字符串中某个字符第一次出现的索引值
String类的常用的转换功能
1）public char[] toCharArray(): 将字符串转换成字符数组
2） byte[] getBytes() : 使用平台默认的字符集(idea:utf-8:- 一个中文三个字节)
将字符串,数据—变成字节数组(编码)
3） public String[] split(String regex): 使用分割符号—拆分成字符串数组(分割功能)
4） public String toLowerCase(): 将宇符串转换成小写
5） public String toUpperCase(): 将字符串转换成大写
6） public static String valueOf(int i) :这个方法参数可以是任意的Java类型:基本类型或者0bject
万能方法:将任何类型转换成String
String类的截取功能
1） public String substring(int beginIndex): 从指定位置处开始截取,默认截取到末尾
2） public String substring(int beginIndex, int endIndex): 从指定位置开始截取,到指定位置结束.(包左不包右)
//一步走:链式编程
String result = line. substring(0, 1) . toLowerCase() . concat(line . substring(1) . toUpperCase());
System. out . printIn(result);
String.类的其他功能(有一个功能 重点:考察源码:按照字典顺序比较)
1）public string replace(char oldChar, char newChar): 替换功能替换 字符
2） public String replace(String oldStr, String newStr): 替换功能替换字符串
3） public String trim(): 去除字符串的前后端的空格
(数据以后在网络中传输,可能携带一些空字符,需要真是数据,需要将网络中的数据前后两端的空格)
4） kpublic int compareTo(String anotherString) :
按照字典顺序比较如果有字符相同的从 – -翻阅源码
*/
面试题 StringBuffer和String的区别?
String的特点:字符串常量,一旦创建,其值不改变; 不支持可变的字符序列
StringBuffer:支持的可变的字符序列,而且线程安全的,---执行效率低,多线程环境会 用,单线程环境下用的StringBuilder这个类;
方法的形式参数:
String和基本类型效果一样;形式参数的改变不影响实际参数
StringBuffer:作为方法的形式参数,形式参数的改变,直接影响实际参数;
实际开发中:需要把A类型–B类型,然后B类型转换成A类型?
A类型—>B类型,目的是为了使用B类型的特有功能,但是结果类型可能A类型, 所有B类型的功能使用完之后,然后在转换A类型; 只要牵扯类型转换,必须记住常用的转换
自动拆装箱
package com.qf.Integer_03;
/**
*
* jdk5以后:自动拆装箱
*
*基本类型:四类八种 自动装箱 引用类型(基本类型的包装类类型)
* byte <--> Byte
* short <--> Short
* int <--> Integer(重点类)
* long <--> Long
* float <--> Float
* double <--> Double
* char <--> Character(重点类)
* boolean <--> Boolean
*
* 代码的方式获取内容:
* 想知道int类型的取值范围? public static final int MAX_VALUE /public static final int MIN_VALUE
* 想知道整数值100对应的二进制,八进制,十六机制 ?
public static String toBinaryString(int i) :将整数值传进去,获取它二进制的字符串形式
public static String toOctalString(int i):将整数值传进去,获取它八进制的字符串形式
public static String toHexString(int i) :将整数值传进去,获取它十六进制字符串形式
*/
public class IntegerDemo {
public static void main(String[] args) {
//想知道int类型的取值范围?
System.out.println(Integer.MIN_VALUE);//-2147483648
System.out.println(Integer.MAX_VALUE);//2147483647
System.out.println(Integer.toBinaryString(100));
System.out.println(Integer.toOctalString(100));
System.out.println(Integer.toHexString(100));
}
}
int和String的相互转换
package com.qf.Integer_03;
/**
* 基本数据类型:八种 如何转换String
* String---->基本类型
* 使用 int举例
*
* int---->String :Integer.valueOf(int类型的值)
* String---->int :Integer.parseInt(数字字符串)
*/
public class IntegerDemo3 {
public static void main(String[] args) {
//int---->String
int i = 10 ;
//方式1:字符串拼接 符号+
System.out.println(i+"");//"10"
//方式2:int---->Integer:装箱---->String
//Intege(int i)
Integer ii = new Integer(i) ;
//Integer---->String :public String toString()
String s = ii.toString();
System.out.println(s) ; //"10"
//方式3:Integer类的静态方法:public static String toString(int i) (推荐)
String s2 = Integer.toString(i);
System.out.println(s2);
System.out.println("---------------------------------") ;
//String --->int
String str = "100" ;// 数字字符串
//方式1:推荐 Integer 静态方法 public static int parseInt(String str): "最常用的"
int number = Integer.parseInt(str);
System.out.println(number); //100
//方式2:String---->Integer--->int
//Integer(String s)
Integer integ = new Integer(str) ;
//public int intValue()
int number2 = integ.intValue();
System.out.println(number2) ;
}
}
StringBuffer类
1.定义：StringBuffer:线程安全的可变的字符串缓冲区,支持可变的字符序列
常用的构造方法:
StringBuffer():空参构造:创建一个支持缓冲区对象StringBuffer(String str):将指定的字符串存储在字符串缓冲区中 (将String---StringBuffer)这个类的部分功能和String :int length(): 获取字符串缓冲区的长度public int capacity():获取字符串缓冲区的容量 默认容量 16个字符,超过这个容量,会自己分配,使用的新的字符串的长度+16
*/
常用功能
StringBuffer常用的功能
1. public StringBuffer append(任意类型数据):添加任何类型数据到字符串缓冲区中返回值字符串缓冲区本身-
- public StringBuffer insert(int offset,String xx):插入:在指定位置的前面插入一个新的字符序列
-
- public StringBuffer reverse():将字符串缓冲区字符序列反转
-
- public int capacity():获取字符串缓冲区的容量 默认容量 16个字符,超过这个容量,会自己分配,使用的新的字符串的长度+16
*/
- public int capacity():获取字符串缓冲区的容量 默认容量 16个字符,超过这个容量,会自己分配,使用的新的字符串的长度+16
类型转换
/**
- 类型转换
- StringBuffer和String的类型转换
- String---->StringBuffer,目的为了StringBuffer的特有功能
- StringBuffer—>String,结果需要是String类型
*/
public class StringBufferDemo3 {
public static void main(String[] args) {
//String----StringBuffer
//有一个字符串
String s = "hello" ;
//StringBuffer sb = s;
//方式1:利用StringBuffer()无参构造方法+append(String str)
//创建一个字符串缓冲区对象
StringBuffer sb = new StringBuffer() ;
sb.append(s) ;
System.out.println(sb); //字符串缓冲区存储的数据内容 "hello",类型是StringBuffer
System.out.println("----------------------------------");
//方式2:利用StringBuffered的有参构造方法StringBuffer(String str)
StringBuffer sb2 = new StringBuffer(s) ;
System.out.println(sb2);
System.out.println("-----------------------StringBuffer转换成String-----------------------");
//StringBuffer --->String
StringBuffer buffer = new StringBuffer("helloworld") ;//字符序列是helloworld,外面的类型StringBuffer
//方式1:public String(StringBuffer buffer) ;String类的构造方法
String str = new String(buffer) ;
System.out.println(str) ; //内容"helloworld",类型String
System.out.println("-------------------------------------");
//方式2:public String toString() 显示的应该是字符串缓冲区中的实际的字符序列内容
String str2 = buffer.toString();
System.out.println(str2);
/*int i = 100 ;
String s4 = "100" ;*/
}
}
public class StringBufferDemo {
public static void main(String[] args) {
//StringBuffer():空参构造:创建一个支持缓冲区对象
StringBuffer sb = new StringBuffer() ;
System.out.println(sb);
System.out.println(sb.length());
System.out.println(sb.capacity());
System.out.println("------------------------------------");
//StringBuffer sb2 = "helloworld" ; //后面String类型,前面StringBuffer
String s = "helloworld" ;
//StringBuffer(String str):将指定的字符串存储在字符串缓冲区中
StringBuffer sb2 = new StringBuffer(s) ;
System.out.println(sb2) ;//"helloworld"
System.out.println(sb2.length());
System.out.println(sb2.capacity());
}
}
Character类:char 类型 包装类型
构造方法:
1.Character(char value) : 将一个char类型的字符值构造成Character类对象
常用成员方法:
判断字符是否为大写字母字符
1. public static boolean isUpperCase(char ch)
判断字符是否为小写字母字符
2.public static boolean isLowerCase(char ch)
判断字符是否为数字字符
3. public static boolean isDigit(char ch)
Random类随机数
构造方法:
创建随机数生成器对象
1. Random()创建对象之 后,调历nextInt()/nextInt(int n): 每次随机数数字不一-样的
2.public Random(long seed) : 调用nextInt()/nextInt(int n): 每次随机数数字-一样的 不推荐用这个
成员方法
1. int nextInt():int类型的范围获取
2.int nextInt(int n):[0,n) :范围0-n之间的int类型的数字
java. util. Date :Date表示特定的时间
构造方法:
1. public Date(): 无参构造方法: 创建日期对象,获取当前系统时间的日期格式: 包含星期年份月份月中的日期...
2. public Date(long date): 创建日期对象，和1970年1月1日时间有关系
Date重点:日期文本格式和Date如何转换?
使用中间桥梁:DateFormat类 是一个抽象类,不能实例化,jdk提供更具体的子类:SimpleDateFormat
构造方法
1. public SimpleDateFormat(String pattern)
yyyy:年 MM:月 dd:月中日期 HH:小时 mm:分钟 ss:秒
Date---->String public String foramt(Date date) :格式化
String--->Date: public Date parse(String dateStr) throws ParseException: 解析
String s= "2022年12月23日";
2. SimpleDateFormat sd = new SimpleDateFormat("yyyy年MM月dd日");
Date parse = sd.parse(s);
System.out.println(parse);
String format = sd.format(parse);
System.out.println(format);
成员方法:
3. getTime() 获取时间毫秒值
System.类的一些常用功能:
1.public stotic void exit(int status) : 参数为,退出Jvm(正常终止:)
2. public static Long currentTimeMillis(): 获取当前系统时间亳秒值
场景: 后面使用I0流传输文件的耗时时间
3. public static void gc(): 手动开启垃圾回收器,回收没有更多引用的对象
会调用0bject类的finalize()方法
4. public static void arraycopy(object srC,数据源(举例:原数组)--->赋值数组的一部分内容
int srcPos,原数组中某个位置
Object dest,目的数据(目标数组)
int destPos,目标数组的某个位置
int Length),复制的长度
扩展： ### java. util. Arrays---->public static String toString(任意类型数组):将任何类型数组转换成字符串
面试题
集合和数组有什么区别?
1)长度的区别
数组长度:固定
集合长度:可处
2)存储数据类型的区别:
数组既可以存储基本数据关型， 也可以在储引用数据类型
int[] arr = {1,2.3} ;
Student[] students = new Student[5J ;
集合:只能存储引用数据类型
List< Student>:集台列表
3)存储元案的区别:
数组只能行储同种类型的元离
集合本质可以存储任意引用类型的元素(多种引用类型
Collection</>.父接口:
代表所有的单列集合,只能存储一-种引用类型的接口
两个子接L List/Set
ArrayList:经常默认使用的集合(效率高)
基本功能:
1. boolean add(E e): 添加任何类型元素E----> 理解为0bject类型元素
2.* boolean contains(0bject o): 判断集合中是否包含指定的元素
3. * boolean isEmpty(): 判断集合是否为空
4. boolean remove(0bject o): 移出集合中的元素
5. void clear() :清空集合
6. int size(): 获取集合的元素数
Collection高级功能:
集合有6种遍历方法–常用增强for循环
1. Object[] toArray() : 将集合转换成对象数组
2. Iterator iterator() :Collection的专有遍历方式 (迭代器!)
3. 方式3:使用获取元素数以及List集合特有功能 Object getIndex(int index)
4. 方式4:List集合的专有迭代器:ListIterator listiterator()
5. 方式5:增强for循环
代码体现
package com.xy.edu.list_03;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
/** List<Student> :存储5个学生,遍历学生的信息(姓名和年龄):5种方式
*/
public class ListTest {
public static void main(String[] args) {
//创建list集合对象
List<Student> list=new ArrayList<>();
//创建6个学生对象
Student s1=new Student("席琳迪翁1",31);
Student s2=new Student("席琳迪翁2",32);
Student s3=new Student("席琳迪翁3",33);
Student s4=new Student("席琳迪翁4",34);
Student s5=new Student("席琳迪翁5",35);
Student s6=new Student("席琳迪翁6",36);
//将6个学生对象添加到list集合当中
list.add(s1);
list.add(s2);
list.add(s3);
list.add(s4);
list.add(s5);
list.add(s6);
方式1:使用Collection集合的Object[] toArray()
System.out.println("方式1:使用Collection集合的Object[] toArray()");
Object[] obj= list.toArray();
for (int i = 0; i < obj.length; i++) {
Student student= (Student) obj[i];//强转
System.out.println(student.getName()+student.getAge());
}
//方式2:使用Collection的迭代器 Iterator iterator()
System.out.println("//方式2:使用Collection的迭代器 Iterator iterator()\n");
Iterator<Student> i=list.iterator();//带上泛型
while (i.hasNext()){
Student st= i.next();
System.out.println(st.getName()+st.getAge());
}
//方式3:使用获取元素数以及List集合特有功能 Object getIndex(int index)
System.out.println("//方式3:使用获取元素数以及List集合特有功能 Object getIndex(int index)\n");
for (int x = 0; x < list.size(); x++) {
Student stu= list.get(x);
System.out.println(stu.getName()+stu.getAge());
}
//方式4:List集合的专有迭代器:ListIterator listiterator()
System.out.println("//方式4:List集合的专有迭代器:ListIterator listiterator()\n");
ListIterator<Student> iter= list.listIterator();
while (iter.hasNext()){
Student stu= iter.next();//获取
System.out.println(stu.getName()+stu.getAge());
}
//方式5:增强for循环
System.out.println("//方式5:增强for循环\n");
for(Student s:list){
System.out.println(s.getName()+s.getAge());
}
}
}
选择排序
package com.xy.edu.selectsort;
import java.util.Arrays;
/**创建一个数组
* int[] arr = {24,69,87,56,13} ;
* 对这个数组首先遍历,在去排序(只是排序),再次遍历,展示排序后的数组内容!
*/
public class SelectSortDemo {
public static void main(String[] args) {
//创建一个数组
int[] arr = {24, 69, 87, 56, 13};
System.out.println("排序前:");
//调用遍历数组的功能
//printArray(arr);
//数组工具类:Arrays.toString(任意类型的数组)---转成String
System.out.println(Arrays.toString(arr));//调用这个方法就不用写之前写的那种遍历for循环，本质是一个东西
//将上面的代码进行优化,因为上面的代码冗余度太大了
//外层循环:比较的次数:比较次数数组长度-1次
/* for (int x = 0; x < arr.length - 1; x++) {
for (int y = x + 1; y < arr.length; y++) {//元素比较,要进行判断,前面的元素和后面元素比较
if (arr[x] > arr[y]) {
int temp = arr[x];//定义中间变量
arr[x] = arr[y];
arr[y] = temp;
}
}
}
//排序后
System.out.println("排序后");
System.out.println(Arrays.toString(arr));
System.out.println("--使用方法改进,返回排序后的数组对象\n----");*/
//调用方法
selectSort(arr);//调用方法
System.out.println(Arrays.toString(arr));
//System.out.println(arr1);
}
//把排序的代码放在一个方法中，然后在main方法中进行调用
public static void selectSort(int[] arr){
for (int x = 0; x <arr.length-1 ; x++) {
for (int y = x+1; y <arr.length ; y++) {
//元素比较,要进行判断,前面的元素和后面元素比较
if(arr[x]>arr[y]){
int temp=arr[x];//定义一个中间变量
arr[x]=arr[y];
arr[y]=temp;
}
}
}
// return arr;//有返回值类型
}
}
本文含有隐藏内容，请 开通VIP 后查看