java小笔记wzt

String

charAt(index)

public class string {
    public static void main(String[] args) {
        String str="wzt牛";
        char c=str.charAt(0);
        System.out.println(c);


        //for循环
        for (int i = 0; i < str.length(); i++) {
            System.out.println(str.charAt(i));
        }
    }
}

结果为
w
w
z
t
牛
getBytes()

public class string {
    public static void main(String[] args) {
        String str = "wzt牛";
        int length = str.getBytes().length;
        System.out.println(length);
    }
    }

结果为6
indexof(String str)

public class string {
    public static void main(String[] args) {
        String str = "wzt牛";
        int length = str.getBytes().length;
        System.out.println(length);
    }
    }

结果为0

equals()

public class string {
    public static void main(String[] args) {
        String str = "wzt牛";
        String s="wzt牛啊";
        System.out.println(str.equals(s));
    }
    }

结果为false
对比字符串内容，一致为true，反之为false

方法
分为构造方法，有参构造方法，普通方法，普通有参方法，main方法（程序主入口）

修饰符为 public,private,还有两个基本不用的
数据类型为void,int,float…和引用类型

构造方法

修饰符+类名（）{}
修饰符+类名(参数){}

普通方法
修饰符+数据类型+自定义名称（）{}
修饰符+数据类型+自定义名称（参数）{}

继承
一个类继承（extends）另一个类
被继承的类为父类，去主动继承的是子类
错误继承：extends 类，类，类
extends 只能继承一个，但是可以多重继承

继承的特性
子类拥有父类非 private 的属性、方法。

子类可以拥有自己的属性和方法，即子类可以对父类进行扩展。

子类可以重写父类的方法。

public class father {
    public void a(){
        System.out.println("asd");
    }
}

```java
public class son extends father{
    @Override
    public void a() {
        System.out.println("ppp");
    }
}

一个类中只能有一个public修饰的类
this指的是当前类所有方法之外，但是类之内的意思。
重载：参数类型不同的方法；
如：
public void a(int a){}
public void a(String s){}
参数不能同为相同数据类型
如：public void a(int a){}
	public void a(int b){}
	如此为错误写法，会报错

**抽象类**
抽象的：abstract
抽象类与普通类的区别在于有抽象的概念，不能使用实例化对象。
如：s s=new s();会报错。
加入了抽象方法。
public abstract void a();
在方法中加入abstract就不能以{}结尾，必须以;结尾。
而且，被继承后需要重写这个抽象的方法。如：


public abstract class demo2 {
    public abstract void po() ;
    public void pp(){}
}
//抽象类不能实例化对象
//抽象方法不能有花括号用;结束

public class This extends demo2{
    public static void main(String[] args) {
        This l=new This();
        l.po();
    }

    @Override
    public void po() {
        System.out.println("sasd");
    }
}

输出结果为：sasd
接口
被继承的关键词为：implement，不是extends
接口与类的区别：
接口不能用于实例化对象。
接口没有构造方法。
接口中所有的方法必须是抽象方法，Java 8 之后 接口中可以使用 default 关键字修饰的非抽象方法。
接口不能包含成员变量，除了 static 和 final 变量。
接口不是被类继承了，而是要被类实现。
接口支持多继承。
实例：

public interface it1 {
    public void s();
}

public class test implements  it1{

    @Override
    public void s() {
        System.out.println("aaaaaaaaaa");
    }

    public static void main(String[] args) {
        test t=new test();
        t.s();
    }
}

输出结果为aaaaaaaa
接口支持多继承：implements 接口，接口，接口…