笔触狂放9

这个屌丝很懒，什么也没留下！

热门标签

Java基础知识整理_java知识点

作者：笔触狂放9 | 2024-08-12 12:21:20

踩

java知识点

Java基础快速学习

一、Java基本知识

一、Java初级

1、变量

变量：用来命名一个数据的标识符

int year = 1949;
1

1）变量类型

这八种基本类型分别是：
整型（4种）

字符型 （1种）char：只能存放一个字符，16位

浮点型 （2种）小数值默认为double类型

浮点型
布尔型（1种）

boolean 只有两个值：true、false，可以使用 1 bit 来存储，但是具体大小没有明确规定。JVM 会在编译时期将 boolean 类型的数据转换为 int，使用 1 来表示 true，0 表示 false。JVM 支持 boolean 数组，但是是通过读写 byte 数组来实现的。

2）字面值

字符的字面值放在单引号中

字符串的字面值放在双引号中

3) 类型转换

转换规则

        byte b = 5;
        int i1 = 300;
        b =(byte) i1;
        System.out.println(b);
         
        //查看一个整数对应的二进制的方法：
        System.out.println(Integer.toBinaryString(i1));
1
2
3
4
5
6
7

4) 变量final

final修饰的变量只有一次赋值机会

在声明的时候赋值

public class HelloWorld {
   
 
    public void method1() {
   
        final int i = 5;
         
        i = 10; //i在第4行已经被赋值过了，所以这里会出现编译错误
         
    }
 
}
1
2
3
4
5
6
7
8
9
10
11
12

在声明的时候没有赋值

public class HelloWorld {
   
 
    public void method1() {
   
        final int i;
         
        i = 10; //i在第4行，只是被声明，但是没有被赋值，所以在这里可以进行第一次赋值
         
        i = 11; //i在第6行已经被赋值过了，所以这里会出现编译错误
         
    }
 
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

2、操作符

1）逻辑操作符

长路与 & 两侧，都会被运算
短路与 && 只要第一个是false，第二个就不进行运算了

长路或 | 两侧都会被运算
短路或 || 只要第一个是true的，第二个就不进行运算了

2）操作符Scanner

先导入import java.util.Scanner;

读取整数：nextInt 读取浮点数：nextFloat 读取字符串：nextLine

读取了整数后，接着读取字符串:需要注意的是，如果在通过nextInt()读取了整数后，再接着读取字符串，读出来的是回车换行:"\r\n",因为nextInt仅仅读取数字信息，而不会读取回车换行"\r\n".

所以，如果在业务上需要读取了整数后，接着读取字符串，那么就应该连续执行两次nextLine()，第一次是取走回车换行，第二次才是读取真正的字符串

import java.util.Scanner;
   
public class HelloWorld {
   
    public static void main(String[] args) {
   
        Scanner s = new Scanner(System.in);
        int i = s.nextInt();
        System.out.println("读取的整数是"+ i);
        String rn = s.nextLine();
        String a = s.nextLine();
        System.out.println("读取的字符串是："+a);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

3）控制流程

break:结束循环

continue:进行下一次

3、数组

1）创建数组

数组是一个固定长度的，包含了相同类型数据的容器

声明数组：int [] a或int a []

创建数组的时候，要指明数组的长度

public class HelloWorld {
   
    public static void main(String[] args) {
   
        //声明一个引用
        int[] a;
        //创建一个长度是5的数组，并且使用引用a指向该数组
        a = new int[5];
         
        int[] b = new int[5]; //声明的同时，指向一个数组
         
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

2）数组排序

选择排序

import java.util.Scanner;
public class Mxdx {
   

    public static void main(String[] args)
    {
   
        int a[]={
   6,3,9,5,2};
        for(int i=0;i<a.length;i++){
   
            System.out.println(a[i]+"");
        }
        System.out.println("     ");
        for(int j=0;j<a.length-1;j++){
   
            for(int i=j+1;i<a.length;i++){
   
                if(a[j]>a[i]){
   
                    int temp=a[j];
                    a[j]=a[i];
                    a[i]=temp;
                }
            }
        }
        for(int i=0;i<a.length;i++){
   
        System.out.println(a[i]+"");}
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

冒泡排序

import java.util.Scanner;
public class Mxdx {
   

    public static void main(String[] args)
    {
   
        int a[]={
   6,3,9,5,2};
        for(int i=0;i<a.length;i++){
   
            System.out.println(a[i]+"");
        }
        System.out.println("     ");
        for(int j=0;j<a.length;j++){
   
            for(int i=0;i<a.length-j-1;i++){
   
                if(a[i]>a[i+1]){
   
                    int temp=a[i];
                    a[i]=a[i+1];
                    a[i+1]=temp;
                }
            }
        }
        for(int i=0;i<a.length;i++){
   
        System.out.println(a[i]+"");}
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

3）复制数组

public class HelloWorld {
   
    public static void main(String[] args) {
   
        int a [] = new int[]{
   18,62,68,82,65,9};
         
        int b[] = new int[3];//分配了长度是3的空间，但是没有赋值
         
        //通过数组赋值把，a数组的前3位赋值到b数组
         
        //方法一： for循环
         
        for (int i = 0; i < b.length; i++) {
   
            b[i] = a[i];
        }
        
        //方法二: System.arraycopy(src, srcPos, dest, destPos, length)
        //src: 源数组
        //srcPos: 从源数组复制数据的起始位置
        //dest: 目标数组
        //destPos: 复制到目标数组的启始位置
        //length: 复制的长度       
        System.arraycopy(a, 0, b, 0, 3);
         
        //把内容打印出来
        for (int i = 0; i < b.length; i++) {
   
            System.out.print(b[i] + " ");
        }
 
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

4）二维数组

求最大值及位置

public class HelloWorld {
   
    public static void main(String[] args) {
   
        int a[][] = new int[5][5];
        // 初始化这个数组
        for (int i = 0; i < a.length; i++) {
   
            for (int j = 0; j < a[i].length; j++) {
   
                a[i][j] = (int) (Math.random() * 100);
            }
        }
        // 打印这个数组的内容：
        for (int[] row : a) {
   
            for (int each : row) {
   
                System.out.print(each + "\t");
            }
            System.out.println();
        }
 
        int max = -1;// 最大值
        // 最大值的坐标
        int target_i = -1;
        int target_j = -1;
        for (int i = 0; i < a.length; i++) {
   
            for (int j = 0; j < a[i].length; j++) {
   
                if (a[i][j] > max) {
   
                    max = a[i][j];
                    target_i = i;
                    target_j = j;
                }
            }
        }
 
        System.out.println("找出来最大的是:" + max);
        System.out.println("其坐标是[" + target_i + "][" + target_j + "]");
 
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

5) Arrays

复制数组：copyOfRange

import java.util.Arrays;
 
public class HelloWorld {
   
    public static void main(String[] args) {
   
        int a[] = new int[] {
    18, 62, 68, 82, 65, 9 };
 
        // copyOfRange(int[] original, int from, int to)
        // 第一个参数表示源数组
        // 第二个参数表示开始位置(取得到)
        // 第三个参数表示结束位置(取不到)
        int[] b = Arrays.copyOfRange(a, 0, 3);
 
        for (int i = 0; i < b.length; i++) {
   
            System.out.print(b[i] + " ");
        }
 
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

转换成字符串：toString

 int a[] = new int[] {
    3, 6, 2, 7, 4 };
        String content = Arrays.toString(a);
        System.out.println(content);
  
1
2
3
4
5

排序：sort

System.out.println(Arrays.toString(a));
        Arrays.sort(a);
1
2

搜索：binarySearch

在查找之前需要先用sort排序

 int a[] = new int[] {
    18, 62, 68, 82, 65, 9 };
 
        Arrays.sort(a);
 
        System.out.println(Arrays.toString(a));
        //使用binarySearch之前，必须先使用sort进行排序
        System.out.println("数字 62出现的位置:"+Arrays.binarySearch(a, 62));
1
2
3
4
5
6
7
8

4、数字与字符串

1）String、StringBuffer、StringBuilder的区别

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7aeSP9Wu-1601383173322)(C:\Users\17227\AppData\Roaming\Typora\typora-user-images\image-20200912141356623.png)]

2）装箱和拆箱

自动装箱:

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

package digit;

public class TestNumber {
   

public static void main(String[] args) {
   
    int i = 5;
    //基本类型转换成封装类型
    Integer it = new Integer(i);
    //自动转换就叫装箱
    Integer it2 = i;
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

自动拆箱：

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

package digit;
public class TestNumber {
   
    public static void main(String[] args) {
   
        int i = 5;
        Integer it = new Integer(i);
        //封装类型转换成基本类型
        int i2 = it.intValue();
        //自动转换就叫拆箱
        int i3 = it;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

基本类型都有对应的包装类型，基本类型与其对应的包装类型之间的赋值使用自动装箱与拆箱完成。

Integer x = 2;     // 装箱 调用了 Integer.valueOf(2)
int y = x;         // 拆箱 调用了 X.intValue()
1
2

3）字符串的转换

数字转换成字符串：

方法1：使用String类的静态方法valueOf
方法2：先把基本类型装箱为对象，然后调用对象的toString
```
 int i=5；
 String str=String.valueOf(i); //数字转字符串。
 int i2=Integer.parseInt(str);  //字符串转换成数字
1
2
3
```

4) 格式化输出

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

%s 表示字符串、%d 表示数字、%n 表示换行；(使用printf输出)

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

5）Character常见方法

Character.isLetter('a')  //判断是否为字母
String a = 'a'; //不能够直接把一个字符转换成字符串
String a2 = Character.toString('a'); //转换为字符串
1
2
3

6) 字符串

常见创建字符串手段：

每当有一个字面值出现的时候，虚拟机就会创建一个字符串

调用String的构造方法创建一个字符串对象

通过+加号进行字符串拼接也会创建新的字符串对象

7）字符串的常见操作：

String sentence = "盖伦,在进行了连续8次击杀后,获得了 超神 的称号";
char c = sentence.charAt(0);//“盖”
char[] cs = sentence.toCharArray(); //获取对应的字符数组
 //截取从第3个开始的字符串 （基0）  //左闭右开原则
String subString1 = sentence.substring(3); //截取3以后的，（在进行。。。称号）
String subString2 = sentence.substring(3,5); //3-5，“在进”

 //根据,进行分割，得到3个子字符串
 String subSentences[] = sentence.split(",");
 //去掉首尾空格
 System.out.println(sentence.trim());
 //全部变成小写
 System.out.println(sentence.toLowerCase());
 //全部变成大写
 System.out.println(sentence.toUpperCase());
 String temp = sentence.replaceAll("击杀", "被击杀"); //替换所有的击杀
 System.out.println(sentence.indexOf("超神")); //字符串第一次出现的位置
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

8）字符串的比较

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

        String str1 = "the light";
    
        String str2 = new String(str1);
         
        String str3 = str1.toUpperCase();
 
        //==用于判断是否是同一个字符串对象
        System.out.println( str1  ==  str2);
         
        System.out.println(str1.equals(str2));//完全一样返回true
         
        System.out.println(str1.equals(str3));//大小写不一样，返回false
        System.out.println(str1.equalsIgnoreCase(str3));//忽略大小写的比较，返回true
1
2
3
4
5
6
7
8
9
10
11
12
13

9）StringBuffer

StringBuffer是可变长的字符串

append追加、delete 删除、insert 插入、reverse 反转

String str1="hello,world";
StringBuffer buffer=new StringBuffer(str1);//根据str1创建一个StringBuffer对象
buffer.append(",LiHua"); //在最后追加
buffer.delete(4, 10);//删除4-10之间的字符；
buffer.insert(4, "there ");//在4这个位置插入 there
buffer.reverse();  //反转
1
2
3
4
5
6

为什么StringBuffer可以变长？

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

参考MyStringBuffer
length: “the”的长度 3
capacity: 分配的总空间 19

注： 19这个数量，不同的JDK数量是不一样的

10）增强型for循环

注：增强型for循环只能用来取值，却不能用来修改数组里的值

public class HelloWorld {
   
    public static void main(String[] args) {
   
        int values [] = new int[]{
   18,62,68,82,65,9};
        //常规遍历
        for (int i = 0; i < values.length; i++) {
   
            int each = values[i];
            System.out.println(each);
        }
         
        //增强型for循环遍历
        for (int each : values) {
   
            System.out.println(each);
        }
         
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

5、类和对象

1）引用

引用和指向

new Hero();//代表创建了一个Hero对象,没有办法访问它,为了访问这个对象，会使用引用来代表这个对象

Hero h =new Hero();//使用一个引用来指向这个对象
//使用一个引用来指向这个对象
Hero h1 = new Hero();
Hero h2 = h1;  //h2指向h1所指向的对象
1
2
3
4
5
6

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LXWZHAut-1601383173324)(C:\Users\17227\AppData\Roaming\Typora\typora-user-images\image-20200913085930021.png)]

2) 继承

public class Item {
   
    String name;
    int price;
}//Item类
1
2
3
4
5

public class Weapon extends Item{
   //继承Item类；
    int damage; //攻击力
     
    public static void main(String[] args) {
   
        Weapon infinityEdge = new Weapon();
        infinityEdge.damage = 65; //damage属性在类Weapon中新设计的    
        infinityEdge.name = "无尽之刃";//name属性，是从Item中继承来的，就不需要重复设计了
        infinityEdge.price = 3600;   
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

3）方法的重载

方法的重载指的是方法名一样，但是参数类型不一样

public class ADHero extends Hero {
   
    public void attack() {
   
        System.out.println(name + " 进行了一次攻击 ，但是不确定打中谁了");
    }
 
    public void attack(Hero h1) {
            //方法重载
        System.out.println(name + "对" + h1.name + "进行了一次攻击 ");
    }
 
    public void attack(Hero h1, Hero h2) {
   
        System.out.println(name + "同时对" + h1.name + "和" + h2.name + "进行了攻击 ");
    }
 
    public static void main(String[] args) {
   
        ADHero bh = new ADHero();   //初始化对象
        bh.name = "赏金猎人";
 
        Hero h1 = new Hero();
        h1.name = "盖伦";
        Hero h2 = new Hero();
        h2.name = "提莫";
 
        bh.attack(h1);        //对象的方法
        bh.attack(h1, h2);
    }
 
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

4）构造方法

如果没有写构造函数、系统直接调用默认构造函数。构造函数可以重载；

public class Hero4 {
   
	String name;
	float hp;
	public Hero4() {
   
		System.out.println("这是无参构造方法");
	}
	public Hero4(String name) {
   
		System.out.println("这是带参构造函数方法"+name);
	}
    public Hero4(String name,float hp){
     //构造方法重载
		System.out.println("这是带参构造函数方法重载");
    }
	public static void main(String[] args) {
   
		Hero4 h4=new Hero4();
		Hero4 h5=new Hero4("HHH");
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

5）this

  //通过this访问属性
    public void setName3(String name){
   
        //name代表的是参数name
        //this.name代表的是属性name
        this.name = name;
    }
1
2
3
4
5
6
7

如果要在一个构造方法中，调用另一个构造方法，可以使用this()

	 //带一个参数的构造方法
    public Hero(String name){
   
        System.out.println("一个参数的构造方法");
        this.name = name;
    }
    //带两个参数的构造方法
    public Hero(String name,float hp){
   
        this(name);//调用了带一个参数的构造方法；
        System.out.println("两个参数的构造方法");
        this.hp = hp;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13

6）传参

变量有两种类型基本类型和类类型

参数也是变量，所以传参分为：1、基本类型传参 2、类类型传参

基本类型传参

在方法内，无法修改方法外的基本类型参数；

public void huixue(int xp){
   
        hp = hp + xp;
        //回血完毕后，血瓶=0
        xp=0;
    }
public static void main(String[] args) {
   
        Hero teemo =  new Hero("提莫",383);
        //血瓶，其值是100
        int xueping = 100;
        //提莫通过这个血瓶回血 
        teemo.huixue(xueping);//传参
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14

引用与赋值（=）

如果一个变量是基本类型，比如 int hp = 50;我们就直接管hp叫变量，=表示赋值的意思。

如果一个变量是类类型，比如 Hero h = new Hero();我们就管h叫做引用。=不再是赋值的意思，=表示指向的意思**

类类型传参

类类型又叫引用

 public Hero(String name, float hp) {
   
        this.name = name;
        this.hp = hp;
    }
    // 攻击一个英雄，并让他掉damage点血
    public void attack(Hero hero, int damage) {
   
        hero.hp = hero.hp - damage;
        System.out.println("被攻击还剩血量"+hero.hp+"攻击者血量"+this.hp);//this.hp指当前对象garen
    }
    public static void main(String[] args) {
   
        Hero teemo = new Hero("提莫", 383);   //初始化两个英雄
        Hero garen = new Hero("盖伦", 616);
        garen.attack(teemo, 100);       //盖伦攻击提莫100点伤害
        System.out.println(teemo.hp);
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

包（package）

把比较接近的类，规划在同一个包下
使用同一个包下的其他类，直接使用即可，但是要使用其他包下的类，必须import

7）访问修饰符

成员变量有四种修饰符：private 私有的、package/friendly/default 不写、protected 受保护的、public 公共的

红色表示不可访问

那么什么情况该用什么修饰符呢？
从作用域来看，public能够使用所有的情况。但是大家在工作的时候，又不会真正全部都使用public,那么到底什么情况该用什么修饰符呢？

属性通常使用private封装起来
方法一般使用public用于被调用
会被子类继承的方法，通常使用protected
package用的不多，一般新手会用package,因为还不知道有修饰符这个东西

再就是作用范围最小原则
简单说，能用private就用private，不行就放大一级，用package,再不行就用protected，最后用public。这样就能把数据尽量的封装起来，没有必要露出来的，就不用露出来了。

8）类属性

1、当一个属性被static修饰的时候，就叫做类属性，又叫做静态属性
2、当一个属性被声明成类属性，那么所有的对象，都共享一个值
与对象属性对比：不同对象的对象属性的值都可能不一样。比如盖伦的hp 和提莫的hp 是不一样的。但是所有对象的类属性的值，都是一样的

static String copyright;//类属性,静态属性
public static void main(String[] args) {
   
   Hero garen =  new Hero();
   Hero.copyright = "版权由Riot Games公司所有"; //修改成garen.copyright="...."也可以,效果同样，静态属性，会同步变化
   Hero teemo =  new Hero();
   System.out.println(teemo.copyright);
   System.out.println(garen.copyright);//两个输出的结果是相同的；
}
1
2
3
4
5
6
7
8
9

访问类属性

访问类属性有两种方式

对象.类属性
```
teemo.copyright
1
```
类.类属性
```
Hero.copyright
1
```

这两种方式都可以访问类属性，访问即修改和获取，但是建议使用第二种 类.类属性 的方式进行，这样更符合语义上的理解

对象属性和类属性使用情景

如果一个属性，每个英雄都不一样，比如name，这样的属性就应该设计为对象属性，因为它是跟着对象走的，每个对象的name都是不同的

如果一个属性，所有的英雄都共享，都是一样的，那么就应该设计为类属性。比如血量上限，所有的英雄的血量上限都是 9999，不会因为英雄不同，而取不同的值。这样的属性，就适合设计为类属性。

9）类方法

类方法： 又叫做静态方法

对象方法： 又叫实例方法，非静态方法

访问一个对象方法，必须建立在有一个对象的前提的基础上；访问类方法，不需要对象的存在，直接就访问

 	//实例方法,对象方法，非静态方法
    //必须有对象才能够调用
    public void die(){
   
        hp = 0;
    }
    //类方法，静态方法
    //通过类就可以直接调用
    public static void battleWin(){
   
        System.out.println("battle win");
    }
	public static void main(String[] args) {
   
           Hero garen =  new Hero();
           garen.name = "盖伦";
           //必须有一个对象才能调用
           garen.die();
           //无需对象，直接通过类调用
           Hero.battleWin();   
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

调用类方法也有两种方式

对象.类方法

garen.battleWin();
1

类.类方法

Hero.battleWin();
1

如果在一个方法里，调用了对象属性，设置为对象方法；

    public String getName(){
   
    	return name;
    }
1
2
3
4

如果一个方法，没有调用任何对象属性，那么就可以考虑设计为类方法，如：

  public static void printGameDuration(){
   
    	System.out.println("已经玩了10分50秒");
    }
1
2
3
4

10) 属性初始化

对象属性初始化

声明该属性的时候初始化
构造方法中初始化
初始化块

public class Hero {
   
    public String name = "some hero"; //声明该属性的时候初始化
    protected float hp;
    float maxHP;
    {
   
        maxHP = 200; //初始化块
    }  
    public Hero(){
   
        hp = 100; //构造方法中初始化
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

类属性初始化

声明该属性的时候初始化
静态初始化块

 //物品栏的容量
    public static int itemCapacity=8; //声明的时候 初始化
    static{
   
        itemCapacity = 6;//静态初始化块 初始化
    }
1
2
3
4
5
6

11）枚举

预定义枚举类型

public enum Season {
   
	SPRING,SUMMER,AUTUMN,WINTER
}
1
2
3
4

 public static void main(String[] args) {
   
        Season season = Season.SPRING;   //枚举赋值。
        switch (season) {
   
        case SPRING:
            System.out.println("春天");
            break;
        case SUMMER:
            System.out.println("夏天");
            break;
        case AUTUMN:
            System.out.println("秋天");
            break;
        case WINTER:
            System.out.println("冬天");
            break;
        }
 }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

6、接口与继承

1）接口

关键字：implements；

package charactor;
//设置一个接口
public interface AD {
   
        //物理伤害
    public void physicAttack();
}
1
2
3
4
5
6
7

package charactor;
public class ADHero extends Hero implements AD{
    //继承这个接口
    @Override
    public void physicAttack() {
   
        System.out.println("进行物理攻击");
    }
}
1
2
3
4
5
6
7
8
9

2) 对象转型

子类转父类(向上转型)

 public static void main(String[] args) {
   
        Hero h = new Hero();  //父类
        ADHero ad = new ADHero(); //子类
        //类型转换指的是把一个引用所指向的对象的类型，转换为另一个引用的类型
        //把ad引用所指向的对象的类型是ADHero
        //h引用的类型是Hero
        //把ADHero当做Hero使用，一定可以
        h = ad;     
    }
1
2
3
4
5
6
7
8
9
10

父类转子类

有的时候行，有的时候不行，所以必须进行强制转换。

 Hero h =new Hero();
 ADHero ad = new ADHero();
 h = ad;//是子类转父类，一定可以的
 ad = (ADHero) h;//父类转子类，所以要进行强转
1
2
3
4

3）重写

父类：Item

public class Item {
   
	String name;
	int price;
	public void effect() {
   
		System.out.println("物品使用后，有治疗效果");
	}
	public static void main(String[] args) {
   
		Item i = new Item();
		i.effect();
		Lifeportion lp=new Lifeportion(); 
		lp.effect();//调用重写的方法
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

子类Lifeportion 重写

public class Lifeportion  extends Item{
      //继承父类进行重写
	public void effect() {
   
		System.out.println("可以i");
	}
}
1
2
3
4
5
6
7

如果没有重写这样的机制怎么样？

如果没有重写这样的机制，也就是说Lifeportion这个类，一旦继承了Item，所有方法都不能修改了。

但是Lifeportion又希望提供一点不同的功能，为了达到这个目的，只能放弃继承Item,重新编写所有的属性和方法，然后在编写effect的时候，做一点小改动

4) 多态

操作符的多态
+ 可以作为算数运算，也可以作为字符串连接
类的多态
父类引用指向子类对象

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

 public static void main(String[] args) {
   
        Item i1= new LifePotion(); //创建对象
        Item i2 = new MagicPotion();
        System.out.print("i1  是Item类型，执行effect打印:");
        i1.effect();//调用重写父类方法
        System.out.print("i2也是Item类型，执行effect打印:");
        i2.effect()1
2
3
4
5
6
7

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/笔触狂放9/article/detail/969762?site