Java重新来过六（接口和继承，数字和字符串，日期，Java书籍推荐）

最新推荐文章于 2022-06-29 23:25:31 发布

DH2264664169

最新推荐文章于 2022-06-29 23:25:31 发布

阅读量312

点赞数

分类专栏： javaBasics

本文链接：https://blog.csdn.net/DH2264664169/article/details/86478114

版权

javaBasics 专栏收录该内容

12 篇文章 0 订阅

订阅专栏

一，接口和继承

1，接口：接口就像是一种约定在学习了多态之后就能进一步加深理解。

2，对象转型：

向上转型（即子类转父类）：把右边的当作左边来用（即将子类对象当成父类对象来用）

向下转型（即父类转子类）：强制转换有风险

没有继承关系的两个类，互相转换，一定会失败

向上转型（实现类转换为接口）：接口中有的方法，实现类中一定是有的，可以转换成功。

向下转型（接口转换为实现类）：有风险

instanceof Hero判断一个引用所指向的对象，是否是Hero类型，或者Hero的子类System.out.println(h1 instanceof Hero);

3，方法重写：又叫方法覆盖，子类可以继承父类的对象方法，在继承后，重复提供该方法。

如图4所示，多态：都是同一个类型，调用同一个方法，却能呈现不同的状态

类的多态
父类引用指向子类对象（调用方法，执行的是对应子类中的方法）

要实现类的多态，需要如下条件
1。父类（接口）引用指向子类对象
2。的调用方法有重写

package charactor;
 
import property.Item;
import property.LifePotion;
import property.MagicPotion;
   
public class Hero {
    public String name;
    protected float hp;
 
    public void useItem(Item i){
        i.effect();
    }
 
    public static void main(String[] args) {
         
        Hero garen =  new Hero();
        garen.name = "盖伦";
     
        LifePotion lp =new LifePotion();
        MagicPotion mp =new MagicPotion();
         
        garen.useItem(lp);
        garen.useItem(mp);     
         
    }
       
}

使用多态的好处？

5，隐藏：类子父覆盖类的类。方法与重写类似，的方法的英文重写子类覆盖父类的对象方法

6，super：实例化子类，父类的构造方法一定会被调用，并且是父类构造方法先调用（子类构造方法会默认调用父类的无参的构造方法）

子类显式调用父类带参构造方法：

public ADHero(String name){

super(name);

System.out.println("AD Hero的构造方法");

}

调用父类属性：

public int getMoveSpeed2(){

return super.moveSpeed;

}

通过超级调用父类的useItem方法：

// 重写useItem，并在其中调用父类的userItem方法

public void useItem(Item i) {

System.out.println("adhero use item");

super.useItem(i);

}

如图7所示，对象类：是所有类的父类声明一个类的时候，默认是继承了对象

toString（）的意思是返回当前对象的字符串表达
通过System.out.println打印对象就是打印该对象的toString（）返回值

垃圾回收方法：终结（）：

当一个对象没有任何引用指向的时候，它就满足垃圾回收的条件

当它被垃圾回收的时候，它的finalize() 方法就会被调用。

finalize() 不是开发人员主动调用的方法，而是由虚拟机JVM调用的。

equals() 用于判断两个对象的内容是否相同

这不是Object的方法，但是用于判断两个对象是否相同
更准确的讲，用于判断两个引用，是否指向了同一个对象

hashCode方法返回一个对象的哈希值

Object还提供线程同步相关方法
wait()
notify()
notifyAll()

getClass()会返回一个对象的类对象，

8、final ：final修饰类，方法，基本类型变量，引用的时候分别有不同的意思。

final修饰类：表示该类不能被继承

final修饰方法：表示该方法不能被重写（覆盖）（在子类中）

final修饰基本类型变量：表示该变量只有一次赋值的机会。

final修饰引用：表示该引用只有一次指向对象的机会。

常量指的是可以公开，直接访问，不会变化的值：public static final int itemTotalNumber = 6;//物品栏的数量

9、抽象类：在类中声明一个方法，这个方法没有实现体，是一个“空”方法，使用修饰符“abstract"

当一个类有抽象方法的时候，该类必须被声明为抽象类（子类被要求实现父类中的抽象方法）

一旦一个类被声明为抽象类，就不能够被直接实例化

抽象类可以没有抽象方法

抽象类和接口的区别：

区别1：
子类只能继承一个抽象类，不能继承多个
子类可以实现多个接口
区别2：
抽象类可以定义
public,protected,package,private
静态和非静态属性
final和非final属性
但是接口中声明的属性，只能是
public
静态
final的
即便没有显式的声明（public static final） int resistMagic;

抽象类和接口都可以有实体方法。接口中的实体方法，叫做默认方法

10、内部类：分为四种

非静态内部类：可以直接在一个类里面定义（必须建立在一个存在的对象基础上）语法: new 外部类().new 内部类()
静态内部类：静态内部类的实例化，不需要一个外部类的实例为基础，可以直接实例化 new 外部类.静态内部类();
匿名类：在声明一个类的同时实例化它，使代码更加简洁精练

Hero h = new Hero(){

//当场实现attack方法

public void attack() {

System.out.println("新的进攻手段");

}

};

本地类：可以理解为有名字的匿名类

//与匿名类的区别在于，本地类有了自定义的类名

class SomeHero extends Hero{

public void attack() {

System.out.println( name+ " 新的进攻手段");

}

在匿名类中使用外部的局部变量，外部的局部变量必须修饰为final

在jdk8中，已经不需要强制修饰成final了，如果没有写final，不会报错，因为编译器偷偷的帮你加上了看不见的final

11、默认方法：默认方法是JDK8新特性，指的是接口也可以提供具体方法了，而不像以前，只能提供抽象方法default public void revive() { System.out.println("本英雄复活了"); }

假设没有默认方法这种机制，那么如果要为Mortal增加一个新的方法revive,那么所有实现了Mortal接口的类，都需要做改动。

但是引入了默认方法后，原来的类，不需要做任何改动，并且还能得到这个默认方法

通过这种手段，就能够很好的扩展新的类，并且做到不影响原来的类

UML：Unified Module Language统一建模语言

二、数字和字符串

1、装箱拆箱：

所有的基本类型都有对应的类类型，这种类就叫做封装类。

基本类型转封装类：Integer it = new Integer(i);

封装类转基本类型：int i2 = it.intValue();

自动装箱：不需要调用构造方法，通过=符号自动把基本类型转换为类类型就叫装箱 Integer it2 = i;

自动拆箱：不需要调用Integer的intValue方法，通过=自动把Integer类型自动转换成int类型，就叫拆箱 int i3 = it;

int的最大值可以通过其对应的封装类Integer.MAX_VALUE获取 System.out.println(Integer.MIN_VALUE);

2、字符串转换：

数字转字符串：

方法1：使用String类的静态方法valueOf String str = String.valueOf(i);
方法2：先把基本类型装箱为对象，然后调用对象的toString Integer it = i; String str2 = it.toString();

字符串转数字：调用Integer的静态方法parseInt int i= Integer.parseInt(str);

3、数学方法：java.lang.Math提供了一些常用的数学运算方法，并且都是以静态方法的形式存在

Math.round(f);四舍五入，Math.random();随机浮点数，Math.sqrt(f);开方，Math.pow(f,n);f的n次方，Math.PI，Math.E 自然常数

4、格式化输出：

如果不使用格式化输出，就需要进行字符串连接，如果变量比较多，拼接就会显得繁琐

%s 表示字符串
%d 表示数字
%n 表示换行

String sentenceFormat ="%s 在进行了连续 %d 次击杀后，获得了 %s 的称号%n";

printf和format能够达到一模一样的效果：

        String sentenceFormat ="%s 在进行了连续 %d 次击杀后，获得了 %s 的称号%n";
        //使用printf格式化输出
        System.out.printf(sentenceFormat,name,kill,title);
        //使用format格式化输出
        System.out.format(sentenceFormat,name,kill,title);

换行符就是另起一行 --- '\n' 换行（newline）
回车符就是回到一行的开头 --- '\r' 回车（return）
在eclipse里敲一个回车，实际上是回车换行符

Java是跨平台的编程语言，同样的代码，可以在不同的平台使用，比如Windows,Linux,Mac
然而在不同的操作系统，换行符是不一样的
（1）在DOS和Windows中，每行结尾是 “\r\n”；
（2）Linux系统里，每行结尾只有 “\n”；
（3）Mac系统里，每行结尾是只有 "\r"。
为了使得同一个java程序的换行符在所有的操作系统中都有一样的表现，使用%n，就可以做到平台无关的换行

其他常用的格式化方式：总长度，左对齐，补0，千位分隔符，小数点位数，本地化表达

package digit;
  
import java.util.Locale;
   
public class TestNumber {
   
    public static void main(String[] args) {
        int year = 2020;
        //总长度，左对齐，补0，千位分隔符，小数点位数，本地化表达
          
        //直接打印数字
        System.out.format("%d%n",year);
        //总长度是8,默认右对齐
        System.out.format("%8d%n",year);
        //总长度是8,左对齐
        System.out.format("%-8d%n",year);
        //总长度是8,不够补0
        System.out.format("%08d%n",year);
        //千位分隔符
        System.out.format("%,8d%n",year*10000);
  
        //小数点位数
        System.out.format("%.2f%n",Math.PI);
          
        //不同国家的千位分隔符
        System.out.format(Locale.FRANCE,"%,.2f%n",Math.PI*10000);
        System.out.format(Locale.US,"%,.2f%n",Math.PI*10000);
        System.out.format(Locale.UK,"%,.2f%n",Math.PI*10000);
          
    }
}

5、字符：

保存一个字符的时候使用char

char对应的封装类是Character

Character的常见方法：

package character;
 
public class TestChar {
 
    public static void main(String[] args) {
         
        System.out.println(Character.isLetter('a'));//判断是否为字母
        System.out.println(Character.isDigit('a')); //判断是否为数字
        System.out.println(Character.isWhitespace(' ')); //是否是空白
        System.out.println(Character.isUpperCase('a')); //是否是大写
        System.out.println(Character.isLowerCase('a')); //是否是小写
         
        System.out.println(Character.toUpperCase('a')); //转换为大写
        System.out.println(Character.toLowerCase('A')); //转换为小写
 
        String a = 'a'; //不能够直接把一个字符转换成字符串
        String a2 = Character.toString('a'); //转换为字符串
         
    }
}

把字符串转换为字符数组 char[] cs = str.toCharArray();

常见转义：

package character;
  
public class TestChar {
  
    public static void main(String[] args) {
        System.out.println("使用空格无法达到对齐的效果");
        System.out.println("abc def");
        System.out.println("ab def");
        System.out.println("a def");
          
        System.out.println("使用\\t制表符可以达到对齐的效果");
        System.out.println("abc\tdef");
        System.out.println("ab\tdef");
        System.out.println("a\tdef");
         
        System.out.println("一个\\t制表符长度是8");
        System.out.println("12345678def");
          
        System.out.println("换行符 \\n");
        System.out.println("abc\ndef");
 
        System.out.println("单引号 \\'");
        System.out.println("abc\'def");
        System.out.println("双引号 \\\"");
        System.out.println("abc\"def");
        System.out.println("反斜杠本身 \\");
        System.out.println("abc\\def");
    }
}

6、字符串：字符串即字符的组合，在Java中，字符串是一个类，所以我们见到的字符串都是对象
常见创建字符串手段：
. 每当有一个字面值出现的时候，虚拟机就会创建一个字符串
. 调用String的构造方法创建一个字符串对象
. 通过+加号进行字符串拼接也会创建新的字符串对象

        String garen ="盖伦"; //字面值,虚拟机碰到字面值就会创建一个字符串对象
         
        String teemo = new String("提莫"); //创建了两个字符串对象
         
        char[] cs = new char[]{'崔','斯','特'};
         
        String hero = new String(cs);//  通过字符数组创建一个字符串对象
         
        String hero3 = garen + teemo;//  通过+加号进行字符串拼接

immutable 是指不可改变的

字符串长度：length()方法返回当前字符串的长度

随机字符串，字符串数组排序，穷举法破解密码

7、操纵字符串

charAt(int index)获取指定位置的字符

toCharArray()获取对应的字符数组

//截取从第3个开始的字符串（基0）

String subString1 = sentence.substring(3); String subString2 = sentence.substring(3,5);

        //根据,进行分割，得到3个子字符串
        String subSentences[] = sentence.split(",");
        for (String sub : subSentences) {
            System.out.println(sub);
        }

System.out.println(sentence.trim()); //去掉首尾空格

//全部变成小写

System.out.println(sentence.toLowerCase());

//全部变成大写

System.out.println(sentence.toUpperCase());

    public static void main(String[] args) {
    
        String sentence = "盖伦,在进行了连续8次击杀后,获得了超神 的称号";
  
        System.out.println(sentence.indexOf('8')); //字符第一次出现的位置
          
        System.out.println(sentence.indexOf("超神")); //字符串第一次出现的位置
          
        System.out.println(sentence.lastIndexOf("了")); //字符串最后出现的位置
          
        System.out.println(sentence.indexOf(',',5)); //从位置5开始，出现的第一次,的位置
          
        System.out.println(sentence.contains("击杀")); //是否包含字符串"击杀"
          
    }

String temp = sentence.replaceAll("击杀", "被击杀"); //替换所有的

temp = sentence.replaceFirst(",","");//只替换第一个

8、比较字符串：

str1和str2的内容一定是一样的！但是，并不是同一个字符串对象

        String str1 = "the light";
         
        String str2 = new String(str1);
         
        //==用于判断是否是同一个字符串对象
        System.out.println( str1  ==  str2);

是同一个对象-特例

String str1 = "the light";

String str3 = "the light";

使用equals进行字符串内容的比较，必须大小写一致
equalsIgnoreCase，忽略大小写判断内容是否一致

System.out.println(str1.startsWith(start));//以...开始

System.out.println(str1.endsWith(end));//以...结束

9、StringBuffer：是可变长的字符串

追加删除插入反转：

package character;
  
public class TestString {
  
    public static void main(String[] args) {
        String str1 = "let there ";
 
        StringBuffer sb = new StringBuffer(str1); //根据str1创建一个StringBuffer对象
        sb.append("be light"); //在最后追加
         
        System.out.println(sb);
         
        sb.delete(4, 10);//删除4-10之间的字符
         
        System.out.println(sb);
         
        sb.insert(4, "there ");//在4这个位置插入 there
         
        System.out.println(sb);
         
        sb.reverse(); //反转
         
        System.out.println(sb);
 
    }
  
}

为什么StringBuffer可以变长？
和String内部是一个字符数组一样，StringBuffer也维护了一个字符数组。但是，这个字符数组，留有冗余长度
比如说new StringBuffer("the")，其内部的字符数组的长度，是19，而不是3，这样调用插入和追加，在现成的数组的基础上就可以完成了。
如果追加的长度超过了19，就会分配一个新的数组，长度比原来多一些，把原来的数据复制到新的数组中，看上去数组长度就变长了

自己设计一个可变长度的StringBuffer

package character;
 
public class MyStringBuffer implements IStringBuffer{
 
    int capacity = 16;
    int length = 0;
    char[] value;
    public MyStringBuffer(){
        value = new char[capacity];
    }
     
    //有参构造方法
    public MyStringBuffer(String str){
        this();
        if(null==str)
            return;
         
        if(capacity<str.length()){
            capacity  = value.length*2;
            value=new char[capacity];
        }
         
        if(capacity>=str.length())
            System.arraycopy(str.toCharArray(), 0, value, 0, str.length());
         
        length = str.length();
         
    }
     
    @Override
    public void append(String str) {
 
        insert(length,str);
    }
 
    @Override
    public void append(char c) {
        append(String.valueOf(c));
         
    }
 
    @Override
    public void insert(int pos, char b) {
        insert(pos,String.valueOf(b));
    }
 
    @Override
    public void delete(int start) {
         
        delete(start,length);
    }
 
    @Override
    public void delete(int start, int end) {
        //边界条件判断
        if(start<0)
            return;
         
        if(start>length)
            return;
         
        if(end<0)
            return;
         
        if(end>length)
            return;
         
        if(start>=end)
            return;
         
        System.arraycopy(value, end, value, start, length- end);
        length-=end-start;
         
    }
 
    @Override
    public void reverse() {
 
        for (int i = 0; i < length/2; i++) {
             
            char temp = value[i];
            value[i] = value[length-i-1];
            value[length-i-1] = temp;
        }
         
    }
 
    @Override
    public int length() {
        // TODO Auto-generated method stub
        return length;
    }
 
    @Override
    public void insert(int pos, String b) {
 
        //边界条件判断
        if(pos<0)
            return;
         
        if(pos>length)
            return;
         
        if(null==b)
            return;
         
        //扩容
        while(length+b.length()>capacity){
            capacity = (int) ((length+b.length())*1.5f);
            char[] newValue = new char[capacity];
            System.arraycopy(value, 0, newValue, 0, length);
            value = newValue;
        }
         
        char[] cs = b.toCharArray();
         
        //先把已经存在的数据往后移
         
        System.arraycopy(value, pos, value,pos+ cs.length, length-pos);
        //把要插入的数据插入到指定位置
        System.arraycopy(cs, 0, value, pos, cs.length);
         
        length = length+cs.length;
         
    }
     
    public String toString(){
         
        char[] realValue = new char[length];
 
        System.arraycopy(value, 0, realValue, 0, length);
         
        return new String(realValue);
         
    }
     
    public static void main(String[] args) {
        MyStringBuffer sb = new MyStringBuffer("there light");
        System.out.println(sb);
        sb.insert(0, "let ");
        System.out.println(sb);
 
        sb.insert(10, "be ");
        System.out.println(sb);
        sb.insert(0, "God Say:");
        System.out.println(sb);
        sb.append("!");
        System.out.println(sb);
        sb.append('?');
        System.out.println(sb);
        sb.reverse();
        System.out.println(sb);
         
        sb.reverse();
        System.out.println(sb);
         
        sb.delete(0,4);
        System.out.println(sb);
        sb.delete(4);
        System.out.println(sb);
 
    }
 
}

三、日期

1、Date类：
注意：是java.util.Date;
而非 java.sql.Date，此类是给数据库访问的时候使用的

2、时间原点概念：

所有的数据类型，无论是整数，布尔，浮点数还是字符串，最后都需要以数字的形式表现出来。

日期类型也不例外，换句话说，一个日期，比如2020年10月1日，在计算机里，会用一个数字来代替。

那么最特殊的一个数字，就是零. 零这个数字，就代表Java中的时间原点，其对应的日期是1970年1月1日 8点0分0秒。 (为什么是8点，因为中国的太平洋时区是UTC-8，刚好和格林威治时间差8个小时)

为什么对应1970年呢？因为1969年发布了第一个 UNIX 版本：AT&T，综合考虑，当时就把1970年当做了时间原点。

所有的日期，都是以为这个0点为基准，每过一毫秒，就+1

Date d1 = new Date(); //当前时间

getTime() 得到一个long型的整数
这个整数代表从1970.1.1 08:00:00:000 开始每经历一毫秒，增加1

当前日期的毫秒数
new Date().getTime() 和 System.currentTimeMillis() 是一样的

3、日期格式化：

日期转字符串：

y 代表年

M 代表月

d 代表日

H 代表24进制的小时

h 代表12进制的小时

m 代表分钟

s 代表秒

S 代表毫秒

public static void main(String[] args) {
          
        //y 代表年
        //M 代表月
        //d 代表日
        //H 代表24进制的小时
        //h 代表12进制的小时
        //m 代表分钟
        //s 代表秒
        //S 代表毫秒
        SimpleDateFormat sdf =new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS" );
        Date d= new Date();
        String str = sdf.format(d);
        System.out.println("当前时间通过 yyyy-MM-dd HH:mm:ss SSS 格式化后的输出: "+str);
         
        SimpleDateFormat sdf1 =new SimpleDateFormat("yyyy-MM-dd" );
        Date d1= new Date();
        String str1 = sdf1.format(d1);
        System.out.println("当前时间通过 yyyy-MM-dd 格式化后的输出: "+str1);
         
    }

字符串转日期：模式（yyyy/MM/dd HH:mm:ss）需要和字符串格式保持一致，如果不一样就会抛出解析异常ParseException

    public static void main(String[] args) {
        SimpleDateFormat sdf =new SimpleDateFormat("yyyy/MM/dd HH:mm:ss" );
  
        String str = "2016/1/5 12:12:12";
          
        try {
            Date d = sdf.parse(str);
            System.out.printf("字符串 %s 通过格式  yyyy/MM/dd HH:mm:ss %n转换为日期对象: %s",str,d.toString());
        } catch (ParseException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
          
    }

4、Calendar日历：

Calendar与Date进行转换：采用单例模式获取日历对象Calendar.getInstance();

package date;
  
//
import java.util.Calendar;
import java.util.Date;
  
public class TestDate {
  
    public static void main(String[] args) {
        //采用单例模式获取日历对象Calendar.getInstance();
        Calendar c = Calendar.getInstance();
          
        //通过日历对象得到日期对象
        Date d = c.getTime();
  
        Date d2 = new Date(0);
        c.setTime(d2); //把这个日历，调成日期 : 1970.1.1 08:00:00
    }
}

翻日历：

添加方法，在原日期上增加年/月/日
设置方法，直接设置年/月/日

package date;
 
import java.text.SimpleDateFormat;
//
import java.util.Calendar;
import java.util.Date;
 
public class TestDate {
 
    private static SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
 
    public static void main(String[] args) {
        Calendar c = Calendar.getInstance();
        Date now = c.getTime();
        // 当前日期
        System.out.println("当前日期：\t" + format(c.getTime()));
 
        // 下个月的今天
        c.setTime(now);
        c.add(Calendar.MONTH, 1);
        System.out.println("下个月的今天:\t" +format(c.getTime()));
 
        // 去年的今天
        c.setTime(now);
        c.add(Calendar.YEAR, -1);
        System.out.println("去年的今天:\t" +format(c.getTime()));
 
        // 上个月的第三天
        c.setTime(now);
        c.add(Calendar.MONTH, -1);
        c.set(Calendar.DATE, 3);
        System.out.println("上个月的第三天:\t" +format(c.getTime()));
 
    }
 
    private static String format(Date time) {
        return sdf.format(time);
    }
}

四，推荐书籍

核心Java字典

有效的Java零食，提升代码质量

用Java思考提升功力

Head First Java这是给幼儿园小朋友看的

官方出的Java Tutorial BEST OF THE BEST

DH2264664169

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java重新来过六（接口和继承，数字和字符串，日期，Java书籍推荐）

一，接口和继承1，接口：接口就像是一种约定在学习了多态之后就能进一步加深理解。2，对象转型：向上转型（即子类转父类）：把右边的当作左边来用（即将子类对象当成父类对象来用）向下转型（即父类转子类）：强制转换有风险没有继承关系的两个类，互相转换，一定会失败向上转型（实现类转换为接口）：接口中有的方法，实现类中一定是有的，可以转换成功。向下转型（接口转换为实现类）：有风险...
复制链接

扫一扫