stJavaDay02

基本数据类型对应的引用数据类型

基本数据类型	引用数据类型
byte	Byte
short	Short
int	Integer
long	Long
char	Character
float	Float
double	Double
boolean	Boolean

装箱拆箱

Integer a=new Integer(3);
    Integer b=3;
    //装箱
    //Integer b=Integer.valueOf(3);
    
    //拆箱
    int c=a;
    //a.intValue()-------------xxValue()

String

方法名	说明
Arrays.sort(int[ ])	数组排序
Arrays.toString(int [])	转化成字符串
Arrays.copyOf(O , int length)	复制到新数组
Arrays.copyOfRange(O, int from, int to)	有界限复制
Arrays.fill(int[] a, int val)	填充

String的特性

1. 不是基本数据类型
2. 不是关键字
3. String在java.lang包下

字符串拼接

1. 任意类型和字符串拼接后结果都是字符串
2. +优先级一样 数字运算和字符串拼接

String str="结果"+12+12+33;
        System.out.println(str);//结果121233
 //字符串长度
        System.out.println(str.length());
 
 //查找字符  indexof 找不到返回-1；找到返回下标：
        System.out.println(str.indexOf("0"));
//反向找 lastIndexOf

 //charAt 传入下标返回下标的字符
        char c=str.charAt(5);
        System.out.println(c);
 //截取字符串
  String x= str.substring(1,3);
  System.out.println(x);
//字符串返回字符数组
        char[] xx=str.toCharArray();
//分割
        String[] ll=str.split("2");
        System.out.println(Arrays.toString(ll));  

 //替换 replace
        str=str.replace("1","0");
        System.out.println(str);      

字符串比较

String s1="1234";
        String s2="1234";

        String s3=new String("1234");
        String s4=new String("1234");

        System.out.println(s1==s2);
        System.out.println(s1==s3);


        String str5="12"+"34";
        String str6="1"+"234";
        System.out.println(str5==s1);
        System.out.println(str5==str6);
        String str7="12"+new String("34");
        System.out.println(str7==s1);

        System.out.println(s1.equals(s3));

StringBuffer and StringBulider

StringBuffer(线程安全 慢)

//System.arraycopy(原,起始位置,新数组,从哪开始粘贴，多少个);
//为什么要使用StringBuffer和StringBuilder？
字符串拼接会过程中生成许多中间量,如果大数量的拼接会导致程序运行速度变慢，
//        使用一个数组来存储拼接的内容,拼接完成后将数组转化成为一个字符串，
//        这样就变免了中间变量的行程

//扩容value数组:
      //  newCapacity=(value.length<<1)+2;//满足ji返回，不满足，需要多大给多大

包

包的定义格式：
格式：package 包名;(多级包用.分开)
范例：package com.day02;
带包编译
手动建包
自动建包
javac -d. xxxx.java

修饰符

权限修饰符

修饰符	同一个类中	同一个包中子类 无关类	不同包的子类	不同的的无关类
private	√
默认(default)	√	√
protected	√	√	√
public	√	√	√	√

状态修饰符

final（最终态）
static（静态）

final

final关键字是最重的意思，可以修饰成员方法，成员变量，类
final修饰的特点
1.修饰方法：表示该方法是最终方法，不能被重写
2.修饰变量：表明该变量是常量，不能再次被赋值
3.修饰类：表明该类是最终类，不能被继承

final修饰局部变量

1.变量是基本类型:基本类型的数据值不变
2.变量是引用类型：引用类型的地址值不变，地址里的内容可以改变

static

static关键字是静态的意思，可以修饰成员方法，成员变量

static修饰的特点
1.被类的所有对象共享
2.通过类名调用
       也可通过对象名调用

面向对象的三大特征

封装
继承
多态

重写

访问修饰符只能更大
异常只能更精确

多态

多态的前提和体现

1.有继承/实现关系
2.有方法重写
3.有父类引用指向子类对象

多态中成员访问特点

成员变量编译看左边，执行看左边
成员方法编译看左边，执行看右边

抽象类

抽象类特点

1. 抽象类和抽象方法必须用abstract表示
2. 抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类
3. 抽象类不可以被final修饰
4. 不能有方法体——>不能加大括号，只声明.

抽象类如何创建对象？

参照多态的方式，通过子类对象实例化

抽象类的子类

要么重写抽象类中的所有抽象方法
要么是抽象类

接口

1. 接口可以继承接口，而且可以继承多个接口，但是不能实现接口，因为接口中的方法全部是抽象的，无法实现；
2.普通类可以实现接口，并且可以实现多个接口，但是只能继承一个类，这个类可以是抽象类也可以是普通类，如果继承抽象类，必须实现抽象类中的所有抽象方法，否则这个普通类必须设置为抽象类；

接口的特点

1.接口是用关键字interface修饰
public interface 接口名{}
2.类实现接口用 implement表示
public class 类名 implements 接口名{}
3.接口不能实例化
多态的形式：具体类多态、抽象类多态、抽象多态
4.接口的实现类
要么重新接口中的所有抽象方法
要么是抽象类

接口的成员特点

1.成员变量
只能是常量
默认修饰符：public static final
2.构造方法
接口没有构造方法
一个类没有父类，默认继承自Object类
3.成员方法
只能是抽象方法
默认修饰符：public abstract
4.接口中只能实行默认default类型的实体方法

内部类

内部类访问特点

1.内部类可以直接调用外部类的成员，包括私有
2.外部类要访问内部类的成员，必须创建对象

内部类概述

public class Outer {
    private int num=10;
    public class Iner{
        //内部类直接调用外部对象
        public void show()
        {
            System.out.println(num);
        }

    }
    public void method(){
//        show()
        Iner s=new Iner();
        s.show();
    }
}

成员内部类

public class Outer {
    private int num=10;
    public class Iner {
        
        public void show() {
            System.out.println(num);
        }
    }
    public void method(){
            Iner s=new Iner();
            s.show();
    }
    -------------------------------
    main
    -------------------------------
    
    public class demo {
    public static void main(String[] args) {
        Outer w=new Outer();
        w.method();
    }

局部内部类

public class Outer {
    private int num=10;
    public void method(){
        class Inner{
            public void show(){
                System.out.println(num);
            }
        }
        Inner s=new Inner();
        s.show();
    }
-----------------------------
main
-----------------------------
public class demo {
    public static void main(String[] args) {
        Outer w=new Outer();
        w.method();
    }

匿名内部类

/*
* 前提：
*   存在一个接口或者类
*
* 格式：
*   new 类名或者接口名(){
*       重写方法;
* };
*
* 本质?
*   是继承了该类或者实现了该接口的子类匿名对象
* */
public class Outer {
    private int num=10;
    public void method(){
        new Inter(){
            @Override
            public void show() {
                System.out.println("匿名内部类");
            }
        };
        //调用
        Inter s= new Inter(){
            @Override
            public void show() {
                System.out.println("匿名内部类");
            }
        };
        s.show();
    }

匿名内部类的应用

public class JumpingDemo {
    public static void main(String[] args) {
       /* Jumping c=new Cat();
        c.jump();*/
        JumpingOperator j=new JumpingOperator();
        Jumping s=new Cat();
        j.method(s);

        j.method(new Jumping() {
            @Override
            public void jump() {
                System.out.println("猫可以跳高了");
            }
        });
    }