”手动的“类

---

解释题目的来意在于这里面的类的类名都需我们手动打出来，需要自己定义名字。

一、内部类

1.概念

在一个类中定义一个类。

2.格式

class 外部类名{
修饰符 class 内部类名{}
}
代码如下（示例）：

publi class Outer {
    public class Inner {}      
 }

3.匿名内部类

（1）前提

存在一个类或者接口，这里的类可以是具体类也可以是抽象类

（2）格式

new 类名 ( ) { 重写方法 } new 接口名 ( ) { 重写方法 }
代码如下（示例）：

new Inter(){
    @Override
    public void method(){}
} 

（3）匿名内部类在开发中的使用

当发现某个方法需要，接口或抽象类的子类对象，我们就可以传递一个匿名内部类过去，来简化传统的代码

（4）案例

public class Outer {
    public void method(){
        /*
        new Inter(){

            @Override
            public void show() {
                System.out.println("匿名内部类");
            }
        };//对象
        */
        //调用内部类
        /*
        new Inter(){

            @Override
            public void show() {
                System.out.println("匿名内部类");
            }
        }.show();//对象调方法
        */
        //多次调用
        Inter i=new Inter(){

            @Override
            public void show() {
                System.out.println("匿名内部类");
            }
        };
        i.show();
        i.show();
    }
}
public interface Inter {
        void show();
}
public class InnerDemo {
    public static void main(String[] args) {
        Outer o = new Outer();
        o.method();
    }
}

二、抽象类

1.概念

在Java中，一个没有方法体的方法应该定义为抽象方法，例如学生类，学生这个类不是一个具体的对象，所以可以定义为一个抽象类。

代码如下（示例）：

2.特点

抽象类和抽象方法必须使用 abstract 关键字修饰
抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类
抽象类不能实例化，但是可以通过多态得形式来实例化。
抽象类的子类，要么重写抽象类中的所有抽象方法，要么是抽象类

代码如下（示例）：

//抽象类的定义：public abstract class 类名
public abstract class Animal {
	//抽象方法的定义
    public abstract void eat();
}
public class Cat extends Animal{//抽象类Animal的实现类Cat
    public  void eat() {
        System.out.println("猫吃鱼");
    }
}
public class text {//测试类
    public static void main(String[] args) {
        Animal a = new Cat();//多态的形式
        a.eat();
    }
}

多态的概念（多态）

3.成员特点

成员变量：既可以是变量,也可以是常量
构造方法：既可以是空参构造,也可以有参构造
成员方法：既可以是抽象方法，也可以是普通方法

三、接口

1.概念

接口就是一种公共的规范标准，只要符合规范标准，大家都可以通用。Java中的接口更多的体现在对行为的抽象！

2.特点

接口用关键字interface修饰   public interface 接口名 {}
类实现接口用implements表示  public class 类名 implements 接口名 {}
接口不能实例化；通过多态的形式来实例化接口。
接口的子类， 要么重写接口中的所有抽象方法，要么子类也是抽象类。

代码如下（示例）：

public interface Inter {//接口
    public void show1(){
        System.out.println("show1开始执行");
        System.out.println("初级工程师");
        System.out.println("中级工程师");
        System.out.println("高级工程师");
        System.out.println("show1结束执行");
    }
}
public class InterImpl implements Inter{//实现类
}
public class InterDemo {
    public static void main(String[] args) {
        Inter i = new InterImpl();
        i.show1();
        System.out.println("---------");
    }
}

3.成员特点

成员变量：只能是常量，默认修饰符：public static final
构造方法：没有，因为接口主要是扩展功能的，而没有具体存在；一个类如果没有父类，默认继承自Object类（默认访问Object的无参构造方法，还有没有构造方法，是因为他的构造方法的关键字是private）
成员方法：只能是抽象方法；默认修饰符：public abstract

4.类和接口

（1）关系

类与类的关系：继承关系，只能单继承，但是可以多层继承
类与接口的关系：实现关系，可以单实现，也可以多实现，还可以在继承一个类的同时实现多个接口
接口与接口的关系：继承关系，可以单继承，也可以多继承

（2）区别

成员区别：(抽象类：变量,常量；有构造方法；有抽象方法,也有非抽象方法)
         (接口：常量；抽象方法)
关系区别:(类与接口:实现，可以单实现，也可以多实现)
         (接口与接口:继承，单继承，多继承)
设计理念区别:(抽象类:对类抽象，包括属性、行为)
         (接口:对行为抽象，主要是行为)

（3）做题技巧

分析：从具体到抽象  
实现：从抽象到具体
使用：具体的类的对象

四、包装类

1.作用

将基本数据类型封装成对象的好处在于可以在对象中定义更多的功能方法操作该数据
常用的操作之一：用于基本数据类型与字符串之间的转换

2.种类

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

3.Integer类（常用）

方法名	说明
public Integer(int value)	根据 int 值创建 Integer 对象(过时)
public Integer(String s)	根据 String 值创建 Integer 对象(过时)
public static Integer valueOf(int i)	返回表示指定的 int 值的 Integer 实例
public static Integer valueOf(String s)	返回一个保存指定值的 Integer 对象 String

（1）int转换为String

方式一：直接在数字后加一个空字符串
方式二：通过String类静态方法valueOf()

可通过api查看。

（2）String转换为int

方式一：先将字符串数字转成Integer，再调用valueOf()方法
方式二：通过Integer静态方法parseInt()进行转换

代码如下（示例）：

public class IntegerDemo {
    public static void main(String[] args) {
        //int ---String
        int number = 100;
        //方式一
        String s1 = "" + number;
        System.out.println(s1);
        //方式二
        String s2 = String.valueOf(number);
        System.out.println(s2);
        System.out.println("-------------");
        //String --- int
        String s = "100";
        //方式1
        //String ----  Integer ---- int
        Integer i = Integer.valueOf(s);
        //pulic int intValue()
        int x = i.intValue();
        System.out.println(x);
        //方式二
        //public static int parseInt(String s)
        //String ---- int
        int y = Integer.parseInt(s);
        System.out.println(y);

    }
}

4.自动拆箱和自动装箱

自动装箱：把基本数据类型转换为对应的包装类类型
自动拆箱：把包装类类型转换为对应的基本数据类型

代码如下（示例）：

public class IntegerDemo {
    public static void main(String[] args) {
        //装箱：把基本数据类型转化为对应的包装类类型
        Integer i = Integer.valueOf(100);
        Integer ii = 100;//自动装箱,底层做了上面的动作
        //拆箱：把包装类类型转化为对应的基本数据类型
        //ii+=200;//內部隐含自动拆箱、自动装箱
        ii = ii.intValue()+200;//ii.intValue()这个动作叫拆箱

        System.out.println(ii);

        Integer iii = null;
        if (iii!=null){
            iii+=300;//NullPointerException
        }

    }
}

5.案例

案例需求：有一个字符串：“91 27 46 38 50”，请写程序实现最终输出结果是：“27 38 46 50 91”
代码如下（示例）：

import java.util.Arrays;

public class IntegerDemo {
    public static void main(String[] args) {
        //字符串中数据排序
        //需求：有一个字符串："91 27 46 38 50"
        //最终结果："27 38 46 50 91"
        String s = "91 27 46 38 50";
        String[] strArray = s.split(" ");
//        for (int i=0;i<strArray.length;i++){
//            System.out.println(strArray[i]);
//        }
        int[] arr = new int[strArray.length];
        for (int i=0;i<arr.length;i++){
            arr[i]=Integer.parseInt(strArray[i]);
        }
//        for (int i=0;i<arr.length;i++){
//            System.out.println(arr[i]);
//        }
        Arrays.sort(arr);
        StringBuilder sb = new StringBuilder();
        for (int i=0;i<arr.length;i++){
            if (i==arr.length-1){
                sb.append(arr[i]);
            }else {
                sb.append(arr[i]).append(" ");
            }
        }
        String result = sb.toString();
        System.out.println("result:"+result);
    }

---

总结

以上就是今天要讲的内容，可能后续还会添加。