java学习笔记第三周(一)

默萧756

已于 2022-02-28 19:28:21 修改

阅读量403

点赞数

文章标签： java 开发语言后端

于 2022-02-01 21:12:05 首次发布

本文链接：https://blog.csdn.net/qq_64557330/article/details/122722532

版权

java 专栏收录该内容

14 篇文章 0 订阅

订阅专栏

2.2 如何定义和使用接口(jdk8以前)

2.3 接口中定义静态方法和默认方法(jdk8以后)

一、抽象类和接口

1、抽象方法和抽象类

抽象方法：使用abstract修饰的方法，没有方法体，只有声明(public void s(); 没有{})。定义的是一种“规范”，就是告诉子类必须要给抽象方法提供具体的实现。

抽象类：包含抽象方法的类就是抽象类。通过abstract方法定义规范，然后要求子类必须定义具体实现。通过抽象类，我们就可以做到严格限制子类的设计，使子类之间更加通用。

package studyweek3;
//抽象类
abstract class Animal{
    abstract public void shout();
}
class Dog extends Animal{
    //子类必须实现父类的抽象方法，否则编译错误
    public void shout(){
        System.out.println("汪");
    }
    public void seeDoor(){
        System.out.println("看门中");
    }
}
//测试抽象类
public class study1 {
    public static void main(String[] args) {
        //Animal a=new Animal();//抽象类不能实例化，因此不能new对象。
        /*Animal b=new Dog();
        b.shout(); 正确，可以用向上转型new一个对象*/
        Dog a=new Dog();
        /*Animal c=new Dog();
        //c.seeDoor();//错误，编译的时候使用Animal类，而Animal类里面没有seeDoor方法，因此编译无法通过
        a.shout();
        a.seeDoor();
    }
}

抽象类使用要点：

注意：其实抽象类可以被实例化，只不过是通过父类引用指向子类对象来实例化子类来间接地实例化父类，当然也可以使用后面学到的匿名内部类。

2、接口interface(重点)

2.1 接口的作用

为什么需要接口？接口和抽象类的区别？

区别：

普通类：具体实现

抽象类：具体实现，规范(抽象方法)

接口：规范

2.2 如何定义和使用接口(jdk8以前)

声明格式：

[访问修饰符] interface 接口名 [] {

常量定义;//总是public static final修饰，不写也是。

方法定义;//总是public abstract

}

接口举例：

package studyweek3;
//接口(一般要带上大量注释)

//这是一个飞行的接口
public interface interface2 {
    /*飞行距离*/
    public static final int a=100;
    /*飞行方法*/
    void fly();
    /*停止方法*/
    void stop();
}



package studyweek3;

public class study2 implements interface2{
    @Override
    public void fly(){
        System.out.println("飞");
    }
    @Override
    public void stop(){
        System.out.println("停");
    }

    public static void main(String[] args) {
        study2 a1=new study2();
        a1.fly();
        a1.stop();
    }

}

传参时直接传入接口进行调用，实现方便管理。

2.3 接口中定义静态方法和默认方法(jdk8以后)

默认方法：

interface A{
    default void moren(){
        System.out.println("接口中的默认方法")            
    }
}

静态方法：

public class Test{
    public static void main(String[] args){
    }
}

interface A{
public static void st(){
        System.out.println("a的静态方法");
    }
}
class test_a implements A{
    public static void st(){
        System.out.println("test_a的静态方法");
    }
}

2.4 接口的多继承

接口可以支持多继承。

语法：

interface A extends b,c;

extends只能单继承，而使用接口可以实现多继承

二、字符串String类详解

1、String基础

2、字符串判断相等

package studyweek3;
//String类详解
public class study3 {
    public static void main(String[] args) {
        String str1=new String("abcde");
        String str2="abcde";
        System.out.println(str1==str2);//"abcde"存在常量区，str1指向new的对象的地址，而对象的地址再指向常量区地址吗，str2直接指向常量区里的“abcde”的地址
        System.out.println(str1.equals(str2));
    }
}

因此，再涉及到字符串比较的时候，都使用equals方法。

str1.equals(str2)；

3、String类常用方法(要掌握)

package studyweek3;

import java.util.Locale;

//String类详解
public class study3 {
    public static void main(String[] args) {
        String str1=new String("abcde");
        String str2="abcde";
        String str3="abcdE";
        String str4="abc";

        System.out.println(str1==str2);//"abcde"存在常量区，str1指向new的对象的地址，而对象的地址再指向常量区地址吗，str2直接指向常量区里的“abcde”的地址
        System.out.println(str1.equals(str2));

        //String练习
        System.out.println(str1.length());//返回字符串长度
        System.out.println(str2.charAt(0));//返回第0个字符
        System.out.println(str2.charAt(4));//返回第6个字符。str2.length()-1;

        System.out.println(str2.equals(str3));//false
        System.out.println(str2.equalsIgnoreCase(str3));//true忽略大写

        System.out.println(str2.indexOf(str4));//从头开始查找子串，返回第一个子串的首字母的下标 0
        System.out.println("Aabcdefabca".indexOf("abc"));//1
        System.out.println("abc".indexOf("A"));//未找到则返回-1

        System.out.println("Aabcdefabca".lastIndexOf("abc"));//从末尾开始查找字串，返回第一个找到的字串的首字母下标 7
        System.out.println("abc".lastIndexOf("A"));//未找到则返回-1

        //字符串替换
        String str5="abcdbcd";
        String str6=str5.replace('a','A');//把所有的d替换成D
        System.out.println(str6);
        String str7="abcdeee".replace("eee","EEE");
        System.out.println(str7);

        System.out.println("javaccc".startsWith("java"));//判断是否以字符串开头  true
        System.out.println("javaccc".endsWith("java"));//判断是否以字符串结尾 false

        //截取子字符串(包头不包尾)
        String str8="abcdefghi".substring(5);//返回一个新字符串，从截取位置到串尾。 fhgi
        System.out.println(str8);
        String str9="abcdefghijk".substring(5,8);//返回一个新字符串，从截取位置后一个截取位置-1位置结束。 fgh(下标5到7)
        System.out.println(str9);

        System.out.println("abcDe".toUpperCase());//字符串变大写
        System.out.println("ABCDe".toLowerCase());//字符串变小写

        //去除首尾空格，中间一般不去
        String str10="  a b  ";//长度为7
        String str11=str10.trim();
        System.out.println(str11.length());
        System.out.println(str11);
        //如果要去中间的空格：
        System.out.println(str10.replace(" ",""));
        System.out.println(str10);//无变化

    }
}

注意：String时不可变字符序列，所有的替换、截取子字符串、去空格、转换大小写等都是生成新的字符串

引用他人文章对此部分进行细分https://blog.csdn.net/qq_35046158/article/details/80273010

三、内部类

1、内部类

package studyweek3;
//外部类
public class study4 {
    private int age=10;
    private void show(){
        System.out.println("展示");
    }
    //内部类
    public class Inner{
        private String name="tony";
        private int age=20;

        public void showInner(){
            System.out.println("Inner展示");
            System.out.println(age);
            System.out.println(study4.this.age);//当外部类属性和内部类属性发生重名时，可以通过外部类名.this.成员名调用
            show();//内部类可以直接使用外部类的成员
        }
    }

    public static void main(String[] args) {
        study4.Inner inner01=new study4().new Inner();
        inner01.showInner();

        study4 out02=new study4();

1.1 非静态内部类

1.2 静态内部类

定义方式：static class ClassName{

类体

}

使用要点：

1.静态内部类可以访问外部类的静态属性，不能访问外部类的普通成员。

2.静态内部类看作外部类的一个静态成员。

1.3 匿名内部类

适合那种只需使用一次的类。比如：键盘监听操作等等。在安卓开发、awt、swing开发中常见。

语法：new 父类构造器(实参类表）\实现接口(){

匿名内部类类体

}

package studyweek3;
public class study5 {
    public void run(jiekou a){
        a.show();
    }
    public static void main(String[] args) {
        study5 b = new study5();
       /* AA c=new AA();
        b.run(c);*///传参传类名
        b.run(new jiekou(){//匿名内部类，每次使用都要调用新的。注意格式：这里传参传接口，
            @Override
            public void show() {
                System.out.println("run");
            }
        }
        );
    }
}

//有名字的类，可以反复使用。
class AA implements jiekou{
    @Override
    public void show(){
        System.out.println("run");
    }
}
interface jiekou{
    void show();
}

匿名内部类转载https://blog.csdn.net/qq_35394434/article/details/111695348

默萧756

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java学习笔记第三周(一)

一、抽象类和接口1、抽象方法和抽象类抽象方法：使用abstract修饰的方法，没有方法体，只有声明(public void s(); 没有{})。定义的是一种“规范”，就是告诉子类必须要给抽象方法提供具体的实现。抽象类：包含抽象方法的类就是抽象类。通过abstract方法定义规范，然后要求子类必须定义具体实现。通过抽象类，我们就可以做到严格限制子类的设计，使子类之间更加通用。package studyweek3;//抽象类abstract class Animal{ abst.
复制链接

扫一扫

专栏目录