day06

来源：互联网发布：七友软件编辑：程序博客网时间：2024/05/07 23:35

静态

用法：是一个修饰符，用于修饰成员（成员变量，成员函数）
所有对象都可以访问，被对象共享
当成员被静态修饰后，就多了一个调用方式，除了可以被对象调用外，还可以直接被类名调用。
类名.静态成员
静态特点：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

0 0