day06

静态

用法：是一个修饰符，用于修饰成员（成员变量，成员函数）
所有对象都可以访问，被对象共享
当成员被静态修饰后，就多了一个调用方式，除了可以被对象调用外，还可以直接被类名调用。
类名.静态成员
静态特点：1.随着类的加载而加载（消失而消失）
2.被所有对象所共享
3.优先于对象存在
4.可以直接被类名所调用
类变量对应于类。实例变量对应于对象。
静态的使用注意事项：
1.静态方法只能访问静态成员。
非静态方法既可以访问静态方法也可以访问非静态方法
2.静态方法中不可以定义this，super关键字。
因为静态优先于对象存在，所以静态方法中不可以出现this。

public class Person {
    private String name;
    private int age;
    public final static int EYE_NUM = 2;
    public static void eat(){
        System.out.println("吃饭");
    }
    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;
    }
}

public class NewPerson {
    public static void main(String[] args) {
        Person zhangsan = new Person();
        System.out.println(Person.EYE_NUM);

    }
}

运行结果：2

import 静态，引用常量

import static 静态.Person.EYE_NUM;
import 静态.Person;

public class Inport {
    public static void main(String[] args) {
        Person zhangsan = new Person();
        System.out.println(EYE_NUM);

    }
}

运行结果：2

final关键字

final表示最终的意思，用final修饰的类，不能被继承。
final修饰的方法不能被重写，修饰的变量不能修改值。
用static final修饰的变量其实就是常量。
常量的命名的规则：
全部都用大写字母，单词用下划线分隔开。

上面的程序中用了static final来修饰一个变量，使其变成了常量。

math和一些包装类的方法

Math.floor();舍去小数点后所有
Math.ceil();舍去小数点后所有，然后小数点前面+1
Math.rint();四舍五入
Math.sqrt();开平方根
三角函数：
public static double sin(double a);
把sin换成其他的三角函数就可以用相应的三角函数公式。

抽象方法和匿名类

抽象方法：抽象方法没有方法体，必须在抽象类中
其子类也必须是抽象类，除非子类中将抽象方法实现。
匿名内部类：一般在只是用一个此类对象时使用，相当于一个类继承了赋予的类，然后用此类构建了一个对象。

public abstract class Student {
    public abstract void readBook();
}

public class SchoolBoy extends Student{
    public void readBook() {
        System.out.println("语文数学英语");
    }
}

public class Test {
    public static void main(String[] args) {
        Student lisi = new SchoolBoy();
        //抽象类建立对象可以通过非抽象的子类来完成
        lisi.readBook();
        Student zhangsan = new Student(){
            public void readBook(){
                System.out.println("读书");
            }//使用匿名内部类定义方法
        };
        zhangsan.readBook();
    }
}

运行结果：

接口

interface，接口也是抽象的，能有常量，不能有变量，只能有抽象的方法和相应参数。接口不用考虑实现的问题。定义接口就是定义编程中的一些准则。
创建了接口后，有类要用到接口就在类名后加上implements 接口名

public interface Car {
    public void run();
}

public interface Load {
    public void getGoods(String s);
}

public class Truck implements Car{
    @Override
    public void run() {
        // TODO Auto-generated method stub
        System.out.println("跑");
    }

}

public class BigTruck extends Truck implements Load{
    @Override
    public void getGoods(String s) {
        // TODO Auto-generated method stub
        System.out.println(s);
    }

}

public class Test {
    public static void main(String[] args) {
        BigTruck t = new BigTruck();
        t.run();
        t.getGoods("100");
    }
}

运行结果：

面向接口的编程+多态

多态的定义：指允许不同类的对象对同一消息作出响应，即同一消息可以根据发送对象的不同而采用多种不同的行为方式。（发消息指函数的调用）
简单来说就是同一时间发生在不同的对象上会有不同的结果。
多态的三个条件：1.要有继承 2.要有重写 3.父类引用指向子类对象

程序简介

定义了一个打印的程序，有三种接口，Paper：代表打印用的纸张
Ink：打印墨水的颜色 Print：打印机打印。每种接口都有两个类来实现，并且重写了接口的方法。最后一个Person类来归纳这些类，并且提供方法来完成打印过程。

public interface Ink {
    public String getInk();
}

public interface Paper {
    public String getPaper();
}

public interface Print {
    public void getPrint(Paper paper,Ink ink);
}

public class BeijingInk implements Ink{

    @Override
    public String getInk() {

        return "北京红色";
    }

}

public class ShanghaiInk implements Ink{

    @Override
    public String getInk() {
        return "上海黑色";
    }

}

public class ChenguangPaper implements Paper{

    @Override
    public String getPaper() {

        return "A4";
    }

}

public class OtherPaper implements Paper{

    @Override
    public String getPaper() {
        return "B2";
    }

}

public class HpPrint implements Print{

    @Override
    public void getPrint(Paper paper, Ink ink) {
        System.out.println("用纸是"+paper.getPaper()+",用的墨水是"+ink.getInk());
    }

}

public class ApplePrint implements Print{
        public void getPrint(Paper paper, Ink ink) {
        System.out.println("苹果打印机打印用纸是"+paper.getPaper()+",用的墨水是"+ink.getInk());

    }
}

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.Properties;

public class Person {
    public Paper usePaper(){
        Paper paper = new ChenguangPaper();
        return paper;
    }
    public Ink useInk(){
        Ink ink = new ShanghaiInk();
        return ink;
    }
    public Print usePrint(){
        Properties properties = new Properties();
        String s = "";
        try {
            properties.load(new FileInputStream("config.properties"));
            s = properties.getProperty("Print");
            System.out.println(s);
        } 
        catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        Print print = null;
        if(s.equals("hp")){
            print = new HpPrint();

        }else if(s.equals("apple")){
            print = new ApplePrint();
        }
//      Print print = new ApplePrint();
        return print;
    }
    public void print(){
        Paper paper = usePaper();
        Ink ink = useInk();
        Print print = usePrint();
        print.getPrint(paper, ink);
    }

    class Servent{
        String skill;
    }
}

import FaceToInterface.Person.Servent;

public class Test {
    public static void main(String[] args) {
        Person lisi = new Person();
        lisi.print();
        //Servent archer = new Person().new Servent();
    }
}

运行结果：

单例设计模式

单例设计模式：解决一个类在内存中只存在一个对象。
想要保证对象唯一。
1.为了避免其他程序过多建立该类对象。先控制禁止其他程序建立该类对象。
2.还为了让其他程序可以访问到该类对象，只好在本类中自定义一个对象。
3.为了方便其他程序对自定义对象的访问，可以对外提供一些访问方式。
怎么实现：
1.将构造函数私有化。
2.在类中创建一个本类对象。
3.提供一个方法可以获取到该对象。

public class Student {
    private static Student s;
    private Student(){
    }
    public static Student getstudent(){
        if(s==null){
            s = new Student();
        }
        return s;
    }
}

public class getStudent {

    public static void main(String[] args) {
        Student wangwu = Student.getstudent();
        Student lisi = Student.getstudent();
        System.out.println(wangwu);
        System.out.println(lisi);
    }
}

运行结果：

递归

反复调用就是递归

class Add{
    private int i = 1;
    public int sum = 0;
    public void add(){
        if(i<1001){
            sum+=i;
            i++;
            add();
        }
    }
}
public class Sum {
    public static void main(String[] args) {
        Add a = new Add();
        a.add();
        System.out.println(a.sum);
    }
}

运行结果：500500