Android学习-JAVA基础 (二)

2.网络保存netSaveImpl implements Save 接口

文件保存fileSaveImpl implements Save

(就是说：行为实现行为)

当小明需要调用网络保存的时候就new netSaveImpl()

package com.test.testjva.save;



public abstract class Person {

    private Save save;



    public Person(String name){



    }

    public void setSave(Save save){

        this.save = save;

    }



    public void Save(){

        save.save();

    }

}

package com.test.testjva.save;



public class Xiaobai extends Person{



    public Xiaobai(){

        super("小白");

    }

}

package com.test.testjva.save;



public class XiaoHei extends Person {



    public XiaoHei(){

        super("小黑");

    }

}

package com.test.testjva.save;



import java.io.File;



public interface Save {



    void save();



}

package com.test.testjva.save;



import java.io.File;



public class SaveToFileImpl implements Save {



    public void save() {

        System.out.println("保存到文件");

    }



}

package com.test.testjva.save;



import java.io.File;



public class SaveToNetImpl implements Save {



    @Override

    public void save() {

        System.out.println("保存到网络");



    }



}

package com.test.testjva.save;



public class Test {



    public static void main(String[] args) {



        Person person = new Xiaobai();

        person.setSave(new SaveToFileImpl());

        person.Save();





        Person person2 = new XiaoHei();

        person2.setSave(new SaveToNetImpl());

        person2.Save();

    }

}

2.Object类

1.在实体类中重写toString

public class person{

public String toString(){

        return "111";

    }

}

那么直接打印new Person()那么返回就不是一个person@euoj338488 返回的就是111了。就是表示这个类是干嘛的

2.package com.test.testjva.save;

public class Xiaobai extends Person{



    //重写Ovject类的equsal方法来实现对象的比较

    public boolean equals(Object obj){

        if(obj == null) return false;

        if(this.getClass()!=obj.getClass())return false;

        Xiaobai xiaobai = (Xiaobai) obj;

        return true;

    }

重写之后调用equals就相等了，不重写的情况下他们是不可能相等的。因为new了两份堆内存。地址不同

Xiaobai xiaobai = new Xiaobai();

        Xiaobai xiaobai2 = new Xiaobai();

        System.out.println(xiaobai.equals(xiaobai2));  

}

3.简单工厂设计模式

package com.test.testjva.factory;

public interface Work {

    void working();

}



package com.test.testjva.factory;

public class TclPhone implements Work{

    @Override

    public void working() {

        System.out.println("手机工作");

    }

}



package com.test.testjva.factory;

public class TclTv implements Work{

    @Override

    public void working() {

        System.out.println("电视工作");

    }

}



package com.test.testjva.factory;

//工厂类

public class Factory {

    public static Work getWork(int i){

        switch (i) {

        case 1:

            return new TclPhone();

        case 2:

            return new TclTv();

        default:

            break;

        }

        return null;

    }

}



package com.test.testjva.factory;

public class Test {

    public static void main(String[] args) {

        //这样写调用者就会依赖被调用者，如果被调用者（TclPhone删除了，或者改变了，使用者将会受到影响）

        /*TclPhone phone = new TclPhone();

        phone.working();*/



        //可以采用工厂模式

        Work w = Factory.getWork(1);

        w.working();



    }

}

4.静态代理模式

package com.test.testjva.proxy;

public interface SubJect {

    void Shopping();

}



package com.test.testjva.proxy;

//我需要找代理，给老婆买进口产品（我是被代理人）

public class My implements SubJect{

    @Override

    public void Shopping() {

        System.out.println("给老婆买进口化妆品");//直奔主题，不用考虑是否是正品，因为代理人已经做好了

    }

}



package com.test.testjva.proxy;

//代理人

public class Proxy implements SubJect{

    private SubJect mSubJect;



    //代理人

    public Proxy(SubJect subJect){

        this.mSubJect = subJect;



    }

    @Override

    public void Shopping() {

        System.out.println("我是代理人，我要为被代理人（顾客）选着好东西的质量，为客户买东西之前做一些准备工作");

        mSubJect.Shopping();

        System.out.println("我是代理人，为顾客买好东西了之后，做个回访，做一个客户调查");

    }

}



package com.test.testjva.proxy;

public class ProxyTest {

    //代理设计模式的目的

    //让自己直接去做关键的事情，比如购物，自己直接购物，

    //如果自己要买进口产品，自己买的话，需要评估进口产品好不好，渠道什么，如果有了代理人，那么就不用考虑这么多，直接买就可以了，代理人会帮你处理好

    public static void main(String[] args) {

        My my = new My();

        Proxy proxy = new Proxy(my);//把客户拉进来，我作为你的代理人

        proxy.Shopping();//我帮你买东西



    }

}

5.内部类的使用

1.public class A{



static class B





}



使用：

A.B ab = new A.B();

6.递归算法

例如：5的阶层：=5x4x3x2x1;

用递归：

public int getJieCheng(int num){

if(num==1)return 1;

return num*getJieCheng(num-1);

}

注意：递归必须要有出口，递归过多会造成栈内存溢出

好处：简写了我们的代码

建议：要少用

普通写法：

public void jiecheng(int num){

int sum = num;

int i = sum-1;

do{

sum = sum*!;

i--;



}while(i>1)

return sum;





}

7.链表数据结构实现

package com.test.testjva.node;

public class Node {



    private String name;

    private Node next;



    public String getName() {

        return name;

    }

    public void setName(String name) {

        this.name = name;

    }







    public Node getNext() {

        return next;

    }

    public void setNext(Node next) {

        this.next = next;

    }

    public Node(String name ){

        this.name = name;

    }

    public void add(String name){

        if(this.next == null) {

            this.next = new Node(name);

        } else {

            this.next.add(name);//递归

        }

    }



    public void delete(String name){

        if(this.next!=null) {

            if(this.next.name.equals(name)) {

                this.next = next.next;

            } else {

                this.next.delete(name);

            }

        }



    }

}







package com.test.testjva.node;

public class NodeManager {

    private Node root;

    public void addNode(String name){

        if(root == null) {

            root = new Node(name);



        } else {

            root.add(name);

        }

    }



    public void deleteNode(String name ){

        if(root.getName().equals(name)) {

            root = root.getNext();

        }else {

            root.delete(name);

        }

    }

}

8.小结

Integer i = 10;//装箱 int ii =  i.intValue();

int num = i+num;

Integer ： 把一个字节内的整数缓存在整数常量池中 ，这样可以避免不断创建细粒度的对象 ，造成对内存的消耗

oo原则：

1.开闭原则

一个软件的实体如类，模块，函数，应该对扩展开放，对修改关闭

2.合成，聚合复用原则

新对象的某些功能已经创建好的对象已实现，那么不要重复造轮子

3.依赖倒置

高层模块不应该依赖底层模块，二者都应该依赖其抽象，抽象不应该依赖细节，细节应该依赖抽象

4.接口隔离

客户端不应该依赖它不需要的接口，一个类对另一个类的依赖应该建立在最小的接口上

5.迪米特法则

一个对象 应该对其他对象保持最少额了解

6.里氏替换原则

所有引用基类的地方必须能透明的使用其子类对象

7.单一职责原则

不要存在多余一个导致类变更的原因，即一个类只负责一个职责

9.异常处理

try {

            //平级关系无所谓，非平级，如果是大小关系，只写一个大的就好，直接写一个Exception e偶尔也是可以的

        } catch (ArithmeticException | NullPointerException e) {

        }

try{



}cache(Exception e){//偶尔可以简单这样处理



}



try{



}cache(AException | BException b ){//AB平级时都适用，不是平级，只写一个大的就好了



}

受检异常：extends exception 编译期必须要用try catch包含代码

非受检异常：extends runtimeException

自定义异常：

package com.test.testjva.error;

public class MyException extends Exception{



    private String message;

    public MyException(String message){

        super();

        this.message = message;

    }

    @Override

    public String toString() {

        return message;

    }

}



package com.test.testjva.error;

public class UserRequest {

    public static boolean login(String admin,String ps) throws MyException{



        if(!admin.equals("admin")) {

            throw new MyException("用户名错误");

        }

        if(!ps.equals("111")) {

            throw new MyException("密码错误");

        }

        return true;



    }



    public static void main(String[] args) {

        try {

            login("1", "111");

        } catch (MyException e) {

            e.printStackTrace();

            System.out.println("用户名或者密码错误");

        }

    }

}

调试：

f5：进入方法中

f6：进入下一行

f7：退出调试

10.StringBuffer

不要用“+”进行字符串连接，很消耗内存，建议使用StringBuffer

package com.test.testjva.StringBuffer;//同步

public class StringBufferDemo {

public static void main(String[] args) {

//这种写法效率非常低

for (int i = 0; i < 10; i++) {

System.out.println(“nihao”+i);

}

    //StringBuffer,比上面节省内存，2倍+2 = 新的容量扩充

    StringBuffer sb = new StringBuffer(26);//可以给他一个容量，避免它扩充

    for (int i = 0; i < 17; i++) {

        sb.append(i);

    }

    System.out.println(sb);

    System.out.println(sb.length());

    System.out.println(sb.capacity());

}

}

StringBuffer 同步：我在用，你就得等（比如公司用微波炉）；效率慢，安全

StringBuilder 不同步：并行一起用；效率高，不安全

11.程序国际化

package com.test.testjva.StringBuffer.Local;



import java.text.MessageFormat;

import java.util.Locale;

import java.util.ResourceBundle;

import java.util.Scanner;



import javax.annotation.Resource;



public class LocaleDemo {



    public static void main(String[] args) {



        Scanner input = new Scanner(System.in);

        Locale locale = Locale.CHINA;

        Locale locale2 = new Locale("en", "US");



        ResourceBundle rb = ResourceBundle.getBundle("com.test.testjva.StringBuffer.Local.info",locale2);



        System.out.println(rb.getString("input.username"));

        String username = input.next();

        System.out.println(rb.getString("input.password"));

        String ps = input.next();



        if(username.equals("1") && ps.equals("1")){

         String info= MessageFormat.format(rb.getString("info"), username);



            System.out.println(info);

        }

    }

}

创建文件info_en_US.properties

input.username=input username

input.password=input.password

info= {0}login success

创建文件info_zh_CN.properties

input.username=请输入用户名

input.username=请输入密码

info=登录成功

12.Math，Random，Arrays工具类

四舍五入：

Math.round(3.22222*100)/100.00

二分查找法（又称：折半查找）,必须保证数组是排序的算法

优点：

又称折半查找，优点是比较次数少，查找速度快，平均性能好；缺点：

要求待查表为有序表，且插入删除困难，因此折半查找适用于不经常变动而查找频繁的有序列表

package com.test.testjva.utils;

import java.util.Arrays;

import java.util.Iterator;

public class Utils {



    public static void main(String[] args) {

        int [] a = {11,22,3,4,4,};

        int[] b  = Arrays.copyOf(a, 10);





        Arrays.sort(a);

    int index=Arrays.binarySearch(a, 22);//必须要求数组是有序的，高效查找

    System.out.println("inxex=="+index);

        for (int i: a) {

            System.out.println(i);

        }

    }

}



//实现：

package com.test.testjva.utils;

import java.util.Arrays;

public class BanrySearchDemo {

    public static void main(String[] args) {

        int nums[] = {22,444,44,645,77765,78,2};

        Arrays.sort(nums);//先排序

        int index = binarySearch(nums, 78);

        System.out.println("index=="+index);



    }

    //二分查找算法

//    查找速度快，要求必须要排序

    public static int binarySearch(int [] nums,int key){

        int star = 0;

        int end = nums.length - 1;

        int mid = -1;

        while(star<=end) {

            mid = (star+end)/2;

            if(nums[mid] == key) {

                return mid;

            } else if(nums[mid] < key) {

                star = mid+1;

            } else if(nums[mid] > key){

                end = mid -1;

            }



        }





        return -1;



    }

}

13.日期操作类

package com.test.testjva.utils;

import java.text.DateFormat;

import java.text.SimpleDateFormat;

import java.util.Calendar;

import java.util.Date;

import java.util.GregorianCalendar;

public class DateUtils {

    public static void main(String[] args) {

        Calendar cr = Calendar.getInstance();

        Calendar cr2 = new GregorianCalendar();

        int year = cr.get(Calendar.YEAR);

        int month = cr.get(Calendar.MONTH);

        int day = cr.get(Calendar.DAY_OF_MONTH);

        int dayw = cr.get(Calendar.DAY_OF_WEEK);

        int dayh = cr.get(Calendar.HOUR_OF_DAY);

        int dayhm = cr.get(Calendar.MINUTE);

        int dayhs = cr.get(Calendar.MILLISECOND);



        System.out.println("=="+year + month+day+"星期"+dayw+"shijian"+dayh+":"+dayhm+":"+dayhs);



        DateFormat df= new SimpleDateFormat("yyyy年MM月dd HH:mm:ss SSS");

        System.out.println(df.format(new Date()));



        System.currentTimeMillis();//当前系统时间

    }

}

14.对象比较器

package com.test.testjva.compare;

public class Cat implements Comparable<Cat> {

    private String name;

    private int age;

    public Cat() {

    }

    public Cat(String name, int age) {

        super();

        this.name = name;

        this.age = age;

    }

    @Override

    public String toString() {

        return "Cat [name=" + name + ", age=" + age + "]";

    }

    public String getName() {

        return name;

    }

    public void setName(String name) {

        this.name = name;

    }

    public int getAge() {

        return age;

    }

    public void setAge(int age) {

        this.age = age;

    }

    // 通过此方法对对象排序

    public int compareTo(Cat o) {

        if (age < o.age) {

            return -1;

        } else if (age > o.age) {

            return 1;

        }

        return 0;

    }

}



package com.test.testjva.compare;

public class Dog {

    private String name;

    private int age;

    public String getName() {

        return name;

    }

    public void setName(String name) {

        this.name = name;

    }

    public int getAge() {

        return age;

    }

    public void setAge(int age) {

        this.age = age;

    }

    @Override

    public String toString() {

        return "Dog [name=" + name + ", age=" + age + "]";

    }

    public Dog(String name, int age) {

        super();

        this.name = name;

        this.age = age;

    }





}



package com.test.testjva.compare;

import java.util.Comparator;

public class DogComparator implements Comparator<Dog>{

    @Override

    public int compare(Dog o1, Dog o2) {

        if(o1.getAge() < o2.getAge()) {

            return -1;

        } else if(o1.getAge() > o2.getAge()) {

            return 1;

        }

        return 0;

    }

}



package com.test.testjva.compare;

import java.util.Arrays;

public class CompareDemo {

    public static void main(String[] args) {



        Cat[] cats = {new Cat("tom", 1),

                new Cat("mory", 2),

                new Cat("jer", 5),};

        Arrays.sort(cats);



        for (Cat cat : cats) {

            System.out.println(cat);

        }

        Dog[] dogs = {new Dog("tom", 1),

                new Dog("mory", 2),

                new Dog("jer", 5),};

        Arrays.sort(dogs,new DogComparator());



        for (Dog cat : dogs) {

            System.out.println(cat);

        }









    }

}

15.对象克隆

package com.test.testjva.utils;

public class Dog implements Cloneable {//这个类具有克隆的功能了

    private String name;

    private int age;

    public Dog(String name, int age) {

        super();

        this.name = name;

        this.age = age;

    }

    @Override

    public String toString() {

        return "Dog [name=" + name + ", age=" + age + "]";

    }

    public String getName() {

        return name;

    }

    public void setName(String name) {

        this.name = name;

    }

    public int getAge() {

        return age;

    }

    public void setAge(int age) {

        this.age = age;

    }

    //重写object中的clone方法

    @Override

    protected Object clone() throws CloneNotSupportedException {

        return super.clone();

    }



}



package com.test.testjva.utils;

public class CloneDemo {

    private static Dog dog1;

    public static void main(String[] args) {

        Dog dog = new Dog("sack", 2);

        System.out.println("dog"+dog);

        try {

            dog1 = (Dog) dog.clone(); //用的非常少，在你突然要创建100个对象的情况，它比你new 100个dog的效率要高

            System.out.println("dog1"+dog1);

        } catch (CloneNotSupportedException e) {

            e.printStackTrace();

        }

        //方法1

        for (int i = 0; i < 100; i++) {

            dog = new Dog("sack", 2);

        }

        //方法2

        for (int i = 0; i < 100; i++) {

            try {

                dog1 = (Dog) dog1.clone();

            } catch (CloneNotSupportedException e) {

                e.printStackTrace();

            }

        }

        //方法2比方法1效率高，



        System.out.println(dog == dog1);

    }

}

16.数据结构二叉树

package com.test.testjva.binaryTree;

public class BinaryTreeDemo {

    private Node root;

    public void addNode(int data) {

        if (root == null) {

            root = new Node(data);

        } else {

            root.add(data);

        }

    }

    public void printNode() {

        if(root != null) {

            root.print();

        }

    }

    class Node {

        private int data;

        private Node left;

        private Node right;

        //中序遍历，左根右

        public void print(){

            if(this.left != null) {

                this.left.print();

            } 

            System.out.print(this.data+"-->");

            if(this.right != null) {

                this.right.print();

            } 





        }

        public Node(int data) {

            this.data = data;

        }

        public void add(int data) {

            if (this.data > data) {

                if (this.left == null) {

                    left = new Node(data);

                } else {

                    left.add(data);

                }

            } else if (this.data <= data) {

                if (this.right == null) {

                    this.right = new Node(data);

                } else {

                    this.right.add(data);

                }

            }

        }

    }

}





package com.test.testjva.binaryTree;

public class Test {

    public static void main(String[] args) {

        BinaryTreeDemo bd= new BinaryTreeDemo();

        bd.addNode(8);

        bd.addNode(3);

        bd.addNode(10);

        bd.addNode(1);

        bd.addNode(6);

        bd.addNode(14);

        bd.addNode(4);

        bd.addNode(7);

        bd.addNode(13);

        bd.printNode();

    }

}

17.file(文件)使用

package com.test.testjva.IO;

import java.io.File;

import java.io.IOException;

import java.text.DateFormat;

import java.text.SimpleDateFormat;

import java.util.Date;

public class FileDemo {

    public static void main(String[] args) {

        findFile(new File("d:"+File.separator+"abc"), ".txt");

        testFile();

    }

    //在java中文件夹也是file

    public static void testFile(){

        File file = new File("d:"+File.separator+"a.txt");//File.separator代表不同操作系统给的/

        //如果不存在这个文件

        if(!file.exists()) {

            try {

            boolean success = file.createNewFile();

            } catch (IOException e) {

                e.printStackTrace();

            }

        } else {



        }

        System.out.println(file.getAbsolutePath());

        long lastTime = file.lastModified();

        DateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

        String lastTimes = df.format(new Date(lastTime));



        long fileLength = file.length();

        System.out.println(lastTimes);

        System.out.println("文件长度"+fileLength);

        System.out.println("文件长度"+file.isDirectory());//是否是目录、

        File f2 = new File("d:"+File.separator+"abc");

        if(!f2.exists()) {

            f2.mkdir();

        }

        String fs[]= f2.list();

        for (String string : fs) {

            System.out.println("文件名称"+string);

        }



        File files[] = f2.listFiles();

        for (File file2 : files) {

            System.out.println(file2.getAbsolutePath());

        }



        System.out.println(f2.delete());





    }

    public static void findFile(File filePath,String file){



        if(filePath!=null) {

            if(filePath.isDirectory()) {

                File fs[] = filePath.listFiles();

                for (File file2 : fs) {

                    findFile(file2, file);

                }

            } else {

                String path = filePath.getAbsolutePath();

                if(path.endsWith(".txt")) {

                    System.out.println("find"+path);

                }



            }

        }

    }

}

18.byteSteam字节流和CharacterStream字符流

package com.test.testjva.IO;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.InputStream;

import java.io.OutputStream;

//字节流

public class ByteStream {



    private static OutputStream mOutputStream;

    private static InputStream mInputStream;

    public static void main(String[] args) {

        File f = new File("d:"+File.separator+"bytes.txt");

        write(f);

        read(f);

    }

    //字节输出流，从程序向硬盘文件输出数据

    public static void write(File f){





        if(f.exists()) {

            try {

                //针对文件创建一个输出流FileOutputStream(File file, boolean append)这个是追加，不写是默认覆盖上一次的数据

                mOutputStream = new FileOutputStream(f,true);//直接写入到文件中

                String info = "你好";

                //写入数据

                mOutputStream.write(info.getBytes());

                //关闭

                mOutputStream.close();

            } catch (IOException e) {

                e.printStackTrace();

            }

        } else {

            try {

                f.createNewFile();

            } catch (IOException e) {

                e.printStackTrace();

            }

        }

    }



    public static void read(File f){

        try {

            mInputStream = new FileInputStream(f);



            //读文件时，一个字节一个字节读太慢，一下全部读，太多。



            byte[] by = new byte[1024*1024*10];//最大10m



            int len = -1;//每次真实读取的长度,每次最大10m

            StringBuffer sb = new StringBuffer();

            while((len = mInputStream.read(by)) != -1){

                sb.append(new String(by,0,len));

            }

            mInputStream.close();

            System.out.println(sb);



            } catch (IOException e) {

                e.printStackTrace();

            }



    }





}



package com.test.testjva.IO;

import java.io.File;

import java.io.FileNotFoundException;

import java.io.FileReader;

import java.io.FileWriter;

import java.io.IOException;

import java.io.Reader;

import java.io.Writer;

public class CharacterStream {

    public static void write(File file){



        try {

            Writer out = new FileWriter(file,true);

            String info = "字符流,你好";

            out.write(info);//输出到缓存中

            out.write("\r\n");//换行

            out.flush();//刷新缓存（把缓存数据清空，并写入到文件中）

            out.close();//关闭时会自动调用flush方法

        } catch (IOException e) {

            e.printStackTrace();

        }





    }



    public static void read(File file){

        try {

            Reader in = new FileReader(file);

            char[] cs = new char[2];//一个中文也是一个字符，一个英文也是一个字符

            int len = -1;

            StringBuffer sb = new StringBuffer();

                while((len = in.read(cs))!=-1){

                    sb.append(new String(cs,0,len));

                }

                System.out.println(sb);

            } catch (IOException e) {

                e.printStackTrace();

            }



    }



    //如果操作 的是文本类型的文件，建议适用字符流

    //如果操作的是非文本类型（如音频文件，视频，都是字节文件）建议适用字节流

    public static void main(String[] args) {

        File file = new File("d:"+File.separator+"character.txt");

        write(file);

        read(file);

    }

}

字节流和字符流的区别：

1.字符流在out.write(info);//会先输出到缓存中，然后在out.close();//关闭时会自动调用flush方法来刷新缓存（把缓存数据清空，并写入到文件中）

2.字节流mOutputStream.write(info.getBytes());直接写入到文件中去