java面向对象查缺

匿名对象

匿名对象只能使用一次

public class Test1 {
    public static void main(String[] args) {
        PhoneFactory p1 = new PhoneFactory();
        p1.show(new Phone(1000,"black"));
    }
}
class PhoneFactory{
    public void show(Phone p){
        p.send();
    }
}
class Phone{
    private int price;
    private String color;

    public Phone() {
    }

    public Phone(int price, String color) {
        this.price = price;
        this.color = color;
    }
    public void send(){
        System.out.println("send");
    }
}

递归

递归方法：一个方法体内调用它自身

方法递归包含了一种隐式的循环，它会重复执行某段代码，但这种重复执行无需循环控制。
递归一定要向已知方向递归，否则这种递归就变成了无穷递归，类似于死循环。

public class Test2 {

    public static void main(String[] args) {
        Test2 t = new Test2();
        System.out.println( t.getSum(100));
    }
    /*
   例子1：计算1-n之间所有自然数的和
    */
    public int getSum(int n){//n为5
        if(n == 1){
            return 1;
        }else{
            return  n + getSum(n-1);
        }
    }
    /*
    例子2：计算1-之间所有自然数的乘机
     */
    public int getSum1(int n){//n为5
        if(n == 1){
            return 1;
        }else{
            return  n * getSum(n-1);
        }
    }
    /*
    例子3:已知有一个数列:f(0) = 1,f(1) = 4,f(n+2) =2*f(n+1)+f(n)
    其中n是大于0的整数，求f(10)的值。
    思路：要将f(n+2)当成f(n)
     */
    public  int f(int n){
        if(n == 0){
            return 1;
        }else if(n == 1){
            return 4;
        }else {
            return 2*f(n-1) + f(n-2);
        }
    }
    /*

例子4：斐波那契数列
    1 1 2 3 5 8 13 21 34 55
    规律：一个数等一两个数之和
    要求：计算斐波那契数列的第n个值。
     */
 public class Demo2 {
	private static int getFibo(int i) {
		if (i == 1 || i == 2)
			return 1;
		else
			return getFibo(i - 1) + getFibo(i - 2);
	}
 
	public static void main(String[] args) {
		System.out.println("斐波那契数列的前20项为：");
		for (int j = 1; j <= 20; j++) {
			System.out.print(getFibo(j) + "\t");
			if (j % 5 == 0)
				System.out.println();
		}
	}

instanceof关键字的使用

a instanceof A :判断对象a是否是A的实例。如果是，返回true，如果不是，返回false。
使用情景：为了避免在向下转型时出现ClassCastException的异常。我们在向下转型之前，先进行instanceof的判断，一旦返回true，就进行向下转型。如果返回false，不进行向下转型。

public class Test3 {
    public static void main(String[] args) {
        Person s = new Student();
        Person t = new teacher();


        System.out.println(s instanceof Student);//true，多态的体现
        System.out.println(s instanceof teacher);//flase
        
        if(s instanceof Student){
            Student s1 = (Student) s;
        }

    }
}
class Person{}
class Student extends Person{}
class teacher extends Person{}

抽象类抽象方法abstract

抽象类

1、此类不能实例化
2、抽象类中一定有构造器，便于子类实例化时调用(涉及，子类对象实例化的全过程)
3、开发中，都会提供抽象类的子类，让子类对象实例化，完成相关操作。

抽象方法

1、抽象方法只有方法的声明，没有方法体
2、包含抽象方法的类，一定时一个抽象类。反之，抽象类可以没有抽象方法。
3、若子类重写了父类中的所有抽象方法后，此子类方可实例化
4、若子类没有重写父类中的所有抽象方法，则此子类也是一个抽象类，需要用abstract修饰。

抽象类使用情景

抽象类时用来模型化那些父类无法确定全部实现，而是由其子类提供具体实现的对象的类。
举例

接口

1.接口使用interface来定义
2.java中，接口和类时并列的两个结构
3.如何定义接口：定义接口中的成员
	3.1 jdk7及以前：只能定义全局常量和抽象方法
		全局常量：public static final修饰，书写时，可以省略不写。	
		抽象方法：public abstract修饰。
	3.2 jdk8：除了定义全局常量和抽象方法之外，还可以定义静态方法、默认方法。
4.接口中不能定义构造器，意味着接口不可以实例化
5.java开发中，接口通过类实现(implement)的方式使用。
	如果实现了覆盖了接口中所有抽象方法，则此实现类就可以实例化。
	如果实现类没有覆盖接口中所有的抽象方法，则此实现类仍为一个抽象类
6.java类可以实现多个接口---->弥补了java单继承的弊端
	格式：class AA extends BB implements CC,DD,EE
7.接口于接口之间可以继承，而且可以多继承
8.接口的具体使用，体现多态性
9.接口，实际上可以看作是一种规范

内部类

1.java中允许将一个类A声明在另一个类B中，则类A就是内部类，类B称为外部类。
2.内部类的分类：成员内部类 、局部内部类(方法内、代码块内、构造器内)
3.成员内部类：
   一方面：作为外部类的成员：
       >调用外部类的结构
       >可以用static修饰
       >可以被四种不同权限修饰
   另一方面，作为一个类：
       >类内可以定义属性方法构造器等
       >可以被final修饰,即不能被继承
       >可以被abstract修饰，即不能被实例化
4.关注问题：
    4.1如何实例化成员内部类的对象
    4.2如何在成员内部类中区分调用外部类的结构
    4.3开发中，局部内部类的使用

成员内部类

public static void main(String[] args) {
        //创建Dog实例(静态成员内部类的实例)
        Person.Dog dog = new Person.Dog();
        dog.show();
        //创建Cat实例(非静态成员内部类)
        Person person = new Person();
        Person.Cat cat = person.new Cat();
        cat.show();
    }

}
class Person {
    String name;
    int age;
    public void eat(){
        System.out.println("Personeat");
    }


    //静态成员内部类
    static class Dog{
        String name;
        int age;
        public void show(){
            System.out.println("dogshow");
            //eat();静态结构不能调用非静态
        }

    }
    //非静态成员内部类
    class Cat{
        String name;
        int age;
        public void show(){
            System.out.println("catshow");
            eat();//调用外部类的属性Person.this.eat()
        }
        public void display(String name){
            System.out.println(name);//形参name
            System.out.println(this.name);//内部类属性
            System.out.println(Person.this.name);//外部类属性
        }

    }

局部内部类

public class Test2 {
    //局部内部类（不常用）
    public void method(){
        class AA{

        }
    }
    //返回一个实现了Comparable接口的对象，局部内部类多用于比较器
    public Comparable getComparable() {
        //方式一：
//        class MyComparable implements Comparable{
//
//            @Override
//            public int compareTo(Object o) {
//                return 0;
//            }
//        }
//        return  new MyComparable();
//    }
        //方式二：
        return new Comparable() {
            @Override
            public int compareTo(Object o) {
                return 0;
            }
        };
    }
}