形参和返回值 抽象类名作为形参和返回值 接口名作为形参和返回值 内部类 局部内部类 冒泡排序 基本类型包装类概述 int 和String之间的相互转换

形参和返回值

• 类名作为形参和返回值

1. 方法的形参是类名，其实需要的是该类的对象
2. 放啊的返回值是类名，其返回的是该类的对象。

package Demo10;

public class Cat {
    public void eat(){
        System.out.println("猫吃鱼");
    }
}

package Demo10;

public class CatDemo {
    public static void main(String[] args) {
        CatOperator co = new CatOperator();
        Cat c =new Cat();
        co.useCat(c);
        Cat c2 = co.getCat();//new Cat
        c2.eat();
    }
}

package Demo10;

public class CatOperator {
    public  void   useCat(Cat c){//Cat c=new Cat();
              c.eat();
    }
    public  Cat getCat(){
        Cat c = new Cat();
        return c;
    }
}

---

抽象类名作为形参和返回值

• 方法的形参是抽象类名，其实需要的是该抽象类的子类对象
• 方法的返回值是抽象类名，其返回的是该抽象类名的子类对象

package Demo11;

public  abstract  class Animal {
    public abstract  void eat();
}

package Demo11;

import sun.awt.HeadlessToolkit;

public  class Cat extends  Animal{
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}

package Demo11;

public class AnimalOperator {
    public void useAnimal(Animal a ){//Animal = new Cat
        a.eat();
    }
    public Animal getAnimal() {
       Animal a = new Cat();
       return  a;
    }
    }

package Demo11;

public class AnimalDemo {
    public static void main(String[] args) {
        AnimalOperator ao = new AnimalOperator();
        Animal a = new Cat();
        ao.useAnimal(a);
        Animal a2 = ao.getAnimal();//new Cat
        a2.eat();
    }
}

---

接口名作为形参和返回值

• 方法的形参是接口名，其实需要的是该接口的实现类对象
• 方法的返回值是接口名，其实返回值是该接口的实现类对象

package Demo12;

public interface Jumpping {
    void Jump();
}

package Demo12;

import Demo11.Animal;
import Demo11.AnimalOperator;

public class JumppingDemo {
    public static void main(String[] args) {
        JumppingOperator jo =new JumppingOperator();
        Jumpping j = new Cat();
        jo.useJumpping(j);
        Jumpping j2 = jo.getJumpping();//new Cat
        j2.Jump();
    }
}

package Demo12;

public class Cat implements  Jumpping{
    @Override
    public void Jump() {
        System.out.println("猫可以跳高了");
    }
}

package Demo12;

public class JumppingOperator {
    public  void useJumpping(Jumpping j ) {
        j.Jump();

    }
    public Jumpping getJumpping(){
        Jumpping j = new Cat();
        return  j ;
    }
}

内部类

内部类：就是在类中定义一个类

public class 类名{
    修饰符 class 类名{
    }
}
范例：
    public class Outer{
        public class Inter{
            
        }
    }

内部类的访问特点

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

成员内部类

• 按照内部类在类中的位置不同，可以分为如下两种形式
  1. 在类的成员位置：成员内部类
  2. 在类中的局部位置：局部内部类

成员内部类，外界如何创建对象使用呢？

• 格式：外部类名.内部类名 对象名 = 外部类对象。内部类对象
• 范例：Outer.Inner oi = new Outer().new Inner();

package Demo13;

import jdk.internal.org.objectweb.asm.tree.InnerClassNode;

public class Outer {
    private  int num =10;
    /*
    public class Inner{
    public void show(){
    System.out.println(num) } }
     */
    private  class Inner{
        public void show (){
            System.out.println(num);
        }}
        public void method(){
           Inner i =new Inner();
           i.show();
        }
    }

package Demo13;

public class Application {
    public static void main(String[] args) {
      //  Outer.Inter oi = new Outer().new Inter();
   // oi.show();
        Outer o = new Outer();
        o.method();
    }
}

---

局部内部类

• 局部内部类是定义在方法中的类，外界无法直接使用，需要在放啊内部创建对象并使用
• 该类可以直接访问外部类的成员，也可以访问方法内的成员变量

package  Demo14;
import Demo14.Outer;


public class Application {
    public static void main(String[] args) {
        Outer n = new Outer();
        n.method();
    }
}

package Demo14;

public class Outer {
    private int num = 10;
    public void method(){
        class Inner{
            int num2 =200;
            public void show(){
                System.out.println(num);
                System.out.println(num2);
            }
        }
        Inner i =new Inner();
        i.show();
    }
}

---

匿名内部类

• 前提：存在一个类或者接口，这里对类可以是具体的类液可以是抽象的类

格式：
    new 类名或者接口名（）{
    重写方法；
}；
    范例
    new Inter(){
    public void show(){
        
    }
}

• 本质：是一个继承了该类或者实现了该接口的子类匿名对象
• 匿名内部类是局部内部类的特殊形式，也就是也要在方法中来写

package Demo14;

public interface Inter {
    void show();
}

package Demo14;

public class Outer {
public void method(){
    /*
    new Inter() {
        @Override
        public void show() {
            System.out.println("匿名内部类");
        //仅仅是一个对象

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

package  Demo14;
import Demo14.Outer;


public class Application {
    public static void main(String[] args) {
        Outer n = new Outer();
        n.method();
    }
}

---

---

package Demo15;

public class Demo15 {
    public static void main(String[] args) {
        long start =System.currentTimeMillis();
        for (int i = 0; i < 10000; i++) {
            System.out.println(i);

        }
        long end = System.currentTimeMillis();
        System.out.println("共耗时"+(end-start)+"毫秒");
    }
}

---

重写toString

package Demo15;

public class Student {
    private  int age ;
    private  String name;
    public Student(){}
    public Student(String name ,int age){
        this.name =name;
        this.age=age;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Student{" +
                "age=" + age +
                ", name='" + name + '\'' +
                '}';
    }
}

package Demo15;

public class Demo15 {
    public static void main(String[] args) {
    Student s = new Student();
    s.setName("pofenx");
    s.setAge(20);
        System.out.println(s);
    }

}

按下Alt+insert,选中toString，equals。

---

冒泡排序

• 如果有n个书记进行排序，则共需要比较n-1次
• 每一次比较完毕，下一次就会少一个数据参与

package Demo116;

public class Demo16 {
    public static void main(String[] args) {
        int[] arr = {54, 61, 23, 6, 187, 123};
        System.out.println("排序前：" + arrayToString(arr));
        for(int x = 0;x<arr.length-1; x++){
            for (int i = 0; i <arr.length-1-x ; i++) {
                if(arr[i]>arr[i+1]){
                    int temp = arr[i];
                    arr[i] = arr[i+1];
                    arr[i+1]= temp;
                }
            }
            System.out.println("第"+(x+1)+"次排序后" + arrayToString(arr));
        }
    }

    public static String arrayToString(int[] arr) {
        StringBuilder sb = new StringBuilder();
        sb.append("[");
        for (int i = 0; i < arr.length; i++) {
            if (i == arr.length - 1) {
                sb.append(arr[i]);

            } else {
                sb.append(arr[i]).append(",");
            }
        }
        sb.append("]");
        String s = sb.toString();
        return s;
    }
}

排序前：[54,61,23,6,187,123]
第1次排序后[54,23,6,61,123,187]
第2次排序后[23,6,54,61,123,187]
第3次排序后[6,23,54,61,123,187]
第4次排序后[6,23,54,61,123,187]
第5次排序后[6,23,54,61,123,187]

---

---

package Demo17;
//int
public class Demo17 {
    public static void main(String[] args) {
        System.out.println(Integer.MIN_VALUE);
        System.out.println(Integer.MAX_VALUE);
    }
}

基本类型包装类概述

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

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

package Demo17;

public class Demo17 {
    public static void main(String[] args) {
    Integer i1 = Integer.valueOf(100);
        System.out.println(i1);
        Integer i2 = Integer.valueOf("1002");
        System.out.println(i2);
    }
}

---

int 和String之间的相互转换

1. int转换为String

• public static String valueof(int i):返回int参数字符串表示，该方法是String类中的方法

2. String 转换为int

• public static int parseInt(String s):将字符串解析为int类型，该方法是Integer类中的方法

package Demo17;

public class Demo17 {
    public static void main(String[] args) {
    //int---->String
        //方式1
        int number = 100;
        String s1= ""+number;
        System.out.println(s1);
        String s = "500";
        //方式2
        //public static String valueof(int i)
        String s2= String.valueOf(number);
        System.out.println(s2);
        System.out.println("-------------");
        //String ----->int
        //方式1，Strin-Integer-int
        Integer i = Integer.valueOf(s);
        //public int intValue()
        int x = i.intValue();
        System.out.println(x);
        //方式2
        //public static int parseInt(String s)
        int y = Integer.parseInt(s);
        System.out.println(y);
    }
}