第四周知识点总结

Sherry_helloworld

已于 2022-09-02 19:22:23 修改

阅读量172

点赞数

文章标签： java jvm servlet

于 2022-09-02 17:57:01 首次发布

本文链接：https://blog.csdn.net/m0_69943999/article/details/126309852

版权

第四周知识点总结

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(任意类型数据):添加任何类型数据到字符串缓冲区中

                 返回值字符串缓冲区本身

1. public StringBuffer insert(int offset,String xx):插入:在指定位置的前面插入一个新的字符序列
1. public StringBuffer reverse():将字符串缓冲区字符序列反转
1. 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;//有返回值类型
    }
}

Sherry_helloworld

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
第四周知识点总结

形式形式参数是抽象类–实际参数new的就是子类对象方法的形式参数是接口–实际参数new的就是子实现类对象返回值问题返回引用类型-具体类：一定要return当前这个具体类的类对象，或者是用匿名对象的格式返回引用类型-抽象类：一定要return当前这个抽象类的子类对象（new），或者是用匿名对象的格式返回引用类型-接口：一定要return当前这个接口的子实现类（new），或者是用匿名对象的格式.关于默认修饰符,私有修饰符private,protec
复制链接

扫一扫