Java基础教程--安卓入门教程（七）

达达前端

发布于 2022-04-29 08:45:29

6830

发布于 2022-04-29 08:45:29

文章被收录于专栏：达达前端

什么是接口？

接口的基本语法接口的基本语法（一）使用interface定义接口当中的方法都是抽象方法；接口当中的方法都是public权限接口中全是抽象函数，不能生成对象 interface USB{ public void read(); public void write(); } class USBPhone implements USB{ //复写 public void read(){ System.out.println("USBPhone read"); } public void write(){ System.out.println("USBPhone write"); } } class Test{ public static void main(String args[]){ USBPhone usbPhone = new USBPhone(); USB usb = usbPhone; usb.read(); usb.write(); } }

接口的基本语法（二）

实现接口使用implements关键字一个类可以实现多个接口一个接口可以继承多个接口 class Phone implements USB,WiFi{ public void read(){ System.out.println("USB read"); } public void write(){ System.out.println("USB write"); } public void open(){ System.out.println("USB open"); } public void close(){ System.out.println("USB close"); } } interface USB{ public void read(); public void write(); } interface WiFi{ public void open(); public void close(); } class Test{ public static void main(String args[]){ Phone phone = new Phone(); USB usb = phone; usb.read(); usb.write(); WiFi wifi = phone; wifi.open(); wifi.close(); } }

接口可以继承多个接口

什么是接口的应用为什么要用接口工厂方法模式 class HPPrinter implements Printer{ public void open(){ System.out.println("HP open"); } public void close(){ System.out.println("HP close"); } public void print(String s){ System.out.println("HP print-->" + s); } } class CanonPrinter implements Printer{ private void clean(){ System.out.println("clean"); } public void close(){ this.clean(); System.out.println("Canon close"); } public void open(){ System.out.println("Canon opern"); } public void print(String s){ System.out.println("Canon print--->"+s); } } interface Printer{ public void open(); public void close(); public void print(String s); } class Test{ public static void main(String args[]){ //根据用户的选择，生成相应的打印机对象 //并且向上转型为Printer类型 //Printer getPrinter(int flag) printer.open(); printer.print("test"); printer.close(); } }

打印机工厂

class PrinterFactory{ public static Printer getPrinter(int flag){ Printer printer = null; //int flag = 0; if(flag == 0){ printer = new HPPrinter(); } else(flag == 1){ printer = new CanonPrinter(); } return printer; } } class Test{ public static void main(String args[]){ //根据用户的选择，生成相应的打印机对象 //并且向上转型为Printer类型 //Printer getPrinter(int flag) int flag = 1; Printer printer = PrinterFactory.getPrinter(flag); printer.open(); printer.print("test"); printer.close(); } }

java当中的异常

什么是异常异常的分类 try...catch...finally结构的使用方法异常：中断了正常指令流的事件。 Throwable Exception Error class TestCheck{ public static void main(String args[]){ //check exception Thread.sleep(1000); } }

属于check异常

class Test{ public static void main(String args[]){ System.out.println(1); try{ System.out.println(2); int i = 1 / 0; System.out.println(3); } catch(Exception e){ e.printStackTrace(); System.out.println(4); } finally{ System.out.println("finally"); } System.out.println(5); } } class TestCheck{ public static void main(String args[]){ try{ Thread.sleep(1000); } catch(Exception e){ e.printStackTrace(); } } } 30总结程序员对Error无能为力，只能处理Exception 对异常的处理关系到系统的健壮性使用try...catch...finally来处理可能出现异常的代码

throw的作用

throws的作用 class User{ private int age; public void setAge(int age) throws Exception{ if(age<0){ RuntimeException e = new RuntimeException("年龄不能为负数"); throw e; } this.age=age } } class Test{ public static void main(String args[]){ User user = new User(); try{ user.setAge(-20); } catch(Exception e){ System.out.println(e); } } } throws Exception谁调用谁处理 32Java当中的IO IO操作的目标 IO的分类方法读取文件和写入文件的方法 IO操作的目标从数据源当中读取数据，以及将数据写入到数据目的地当中。

IO的分类：

第一种分法：输入流输出流第二种分类：字节流字符流第三种分类：节点流处理流

IO当中的核心类

InputStream OutputStream FileInputStream FileOnputStream 字节流的核心类 InputStream OutputStream所有字节流的父类抽象类，是不能生成对象的，子类可以生成对象。核心类的核心方法 InputStream: int read(byte[] b,int off,int len) OutputStream: void write(byte[] b,int off,int len) //第一步：导入类， import java.io.*; class Test{ public static void main(String args[]){ //声明输入流引用 FileInputStream fis = null; //读取文件数据的输入流，FileInputStream try{ //生成代表输入流的对象 fis = new FileInputStream("e:/src/from.text"); //读取数据 //生成一个字节数组 byte [] buffer = new byte[100]; //调用输入流对象的read方法，读取数据 //0,代表偏移量，如果是5，那么就从第五个读取 fis.read(buffer,0,buffer.length); for(int i = 0;i<buffer.length;i++){ System.out.println(buffer[i]); } } catch(Exception e){ System.out.println(e); } } }

字符表达

import java.io.*; class Test{ public static void main(String args[]){ //声明输入流引用 FileInputStream fis = null; //声明输出流的引用 FileOutputStream fos = null; //读取文件数据的输入流，FileInputStream try{ //生成代表输入流的对象 fis = new FileInputStream("e:/src/from.txt"); //生成代表输出流的对象 fos = new FileOutputStream("e:/src/to.txt"); //读取数据 //生成一个字节数组 byte [] buffer = new byte[100]; //调用输入流对象的read方法，读取数据 //0,代表偏移量，如果是5，那么就从第五个读取 int temp = fis.read(buffer,0,buffer.length); fos.write(buffer,0,temp); /* String s = new String(buffer); //调用一个String对象的trim方法，将会去除掉这个字符串的 //首尾空格和空字符 s = s.trim(); System.out.println(s);*/ } catch(Exception e){ System.out.println(e); } } }

32总结：IO系统的主要目标是为了对数据进行读写操作

数据的流向以JAVA程序为参照物 IO流可以有三种分类方法 read方法和write方法

33Java当中的IO（二）

大文件的读写方法字符流的使用方法 import java.io.*; class Test{ public static void main(String args[]){ //声明输入流引用 FileInputStream fis = null; //声明输出流的引用 FileOutputStream fos = null; //读取文件数据的输入流，FileInputStream try{ //生成代表输入流的对象 fis = new FileInputStream("e:/src/from.txt"); //生成代表输出流的对象 fos = new FileOutputStream("e:/src/to.txt"); //读取数据 //生成一个字节数组 byte [] buffer = new byte[1024]; while(true){ int temp = fis.read(buffer,0,buffer.length); if(temp == -1){ break; } fos.write(buffer,0,temp); } //调用输入流对象的read方法，读取数据 //0,代表偏移量，如果是5，那么就从第五个读取 /* String s = new String(buffer); //调用一个String对象的trim方法，将会去除掉这个字符串的 //首尾空格和空字符 s = s.trim(); System.out.println(s);*/ } catch(Exception e){ System.out.println(e); } finally{ try{ fis.close(); fos.close(); } catch(Exception e){ System.out.println(e); } } } }

33字符流：读写文件时，以字符为基础

字节输入流：Reader <--FileReader int read(char[] c,int off,int len) 字节输出流：Writer <--FileWriter void write(char[] c,int off,int len) import java.io.*; public class TestChar{ public static void main(String args[]){ //字符数据流 FileReader FileReader fr = null; FileWriter fw = null; try{ fr = new FileReader("e:/src/from.txt"); fw = new FileWriter("e:;/src/to.txt"); char[] buffer = new char[100]; int temp = fr.read(buffer,0,buffer.length); fw.write(buffer,0,temp); /*for(int i = 0;i<buffer.length;i++){ System.out.println(buffer[i]); }*/ } catch(Exception e){ System.out.println(e); } finally{ try{ } catch(Exception e){ System.out.println(e); } } } 34

节点流和处理流

处理流使用实例装饰者（Decorator）模式节点流与处理流的关系 BufferedReader介绍一行一行的读取 BufferedReader使用方法，生成BufferedReader对象的方法 BufferedReader in = new BufferedReader(new FileReader("foo.in")); 处理流，Reader,Writer以及他们所有的子类都属于字符流 BufferedReader属于字符流，处理流，然后呢，它又是处理流全称：字符输入处理流 public String readLine() throws IOException import java.io.*; class Test{ public static void main(String args[]){ FileReader fileReader = null; BufferReader bufferReader = null; try{ fileReader = new FileReader("e:/src/users.txt"); bufferedReader = new BufferedReader(fileReader); String line = null; while(true){ line = bufferedReader.readLine(); if(line == null){ break; } System.out.println(line); } /*String line = bufferedReader.readLine(); System.out.println(line);*/ } catch(Exception e){ System.out.println(e); } finally{ try{ bufferedReader.close(); fileReader.close(); } catch(Exception e){ System.out.println(e); } } } }

装饰者模式

worker.java interface worker{ public void doSomeWork(); } class Plumber implements Worker{ public void doSomeWork(){ System.out.println("修水管"); } } class Carpenter implemments Worker{ public void doSomeWork(){ System.out.println("修门窗"); } } class AWorker implements Worker{ private Worker worker; public AWorker(Worker worker){ this.worker = worker; } public void doSomeWork(){ System.out.println("你好"); worker.doSomeWork(); } } class Test01{ public static void main(String args[]){ //生成一个A公司水管工对象 Plumber plumber = new Plumber(); AWorker aWorker = new AWorker(plumber); aWorker.doSomeWork(); Carpenter carpenter = new Carpenter(); AWorker aWorker2 = new AWorker(capenter); aWorker2.doSomeWork(); } }

35内部类和匿名内部类

什么是内部类？内部类的使用方法匿名内部类的使用方法 class A{ class B{ } } 如何生成内部类的对象？ class Test{ public static void mian(String args[]){ A a = new A(); A.B b = a.new B(); } } class A{ int i; class B{ int j; int funB(){ int result = i + j; return result; } } } class Test{ public static void main(String args[]){ A a = new A(); A.B b = a.new B(); a.i = 3; b.j = 1; int result = b.funB(); System.out.println(result); } } class A{ int i; class B{ int j; int funB(){ int result = A.this.i + this.j; return result; } } }

匿名内部类

interface A{ public void doSomething(); } class B{ public void fun(A a){ System.out.println("B类的fun函数"); a.doSomething(); } } class AImpl implements A{ public void doSomething(){ System.out.println("doSomething"); } } class Test{ public static void main(String args[]){ AImpl al = new AImpl(); A a = al; B b = new B(); b.fun(a); } } 匿名内部类 class Test{ public static void main(String args[]){ //AImpl al = new AImpl(); ///A a = al; B b = new B(); b.fun(new A(){ public void doSomething(){ System.out.println("匿名内部类"); } }); } }

36Java当中的线程

1.进程和线程 2.多线程程序运行模式 3.定义线程的方法

多线程与多进程

多进程：在操作系统中能（同时）运行多个任务（程序）多线程：在同一应用程序中多个顺序流（同时）执行

创建线程的方法

方法1：定义一个线程类，它继承类Thread并重写其中的方法run();方法run()称为线程体；由于Java只支持单继承，用这种方法定义的类不能再继承其他类。 FirstThread.java class FirstThread extends Thread{ public void run(){ for(int i=0;i<100;i++){ System.out.println("FirstThread"+i); } } } class Test{ public static void main(String args[]){ //生成线程类的对象 FirstThread ft = new FirstThread(); //启动线程 ft.start(); //ft.run(); 千万不能这样写 for(int i = 0;i<100;i++){ System.out.println("main"+i); } } } 37

实现线程的第二种方法

控制线程的常用函数方法二：提供一个实现接口Runnable的类作为线程的目标对象，在初始化一个Thread类或者Thread子类的线程对象时，把目标对象传递给这个线程实例，由该目标对象提供线程体。 class RunnableImpl implements Runable{ public void run(){ for(int i = 0;i<100;i++){ System.out.println("Runnable-->"+i); } } } class Test{ public static void main(String args[]){ //生成一个Runnable接口实现类的对象 //ri 代表的是线程体 RunnableImpl ri = new RunnableImpl(); //生成一个Thread对象，并将Runnable接口实现类的对象作为参数 //传递给该Thread对象 //代表的是线程 Thread t = new Thread(ri); System.out.println(t.getPriority()); //通知Thread对象，执行start方法 t.start(); } }

线程的简单控制方法

中断线程 Thread.sleep(); Thread.yield();//让出自己正在使用的CPU 设置线程的优先级 getPriority(); setPriority(); class RunnableImpl implements Runnable{ public void run(){ for(int i=0;i<100;i++){ System.out.println("Runnable-->"+i); if(i==50){ try{ Thread.sleep(2000); } catch(Exception e){ System.out.println(e); } } } } } class Test{ public static void main(String args[]){ //生成一个Runnable接口实现类的对象 RunnableImpl ri = new RunnableImpl(); //生成一个Thread对象，并将Runnable接口实现类的对象作为参数 //传递给该Thread对象 Thread t = new Thread(ri); //线程的优先级最大是10，最小是1，可以使用Thread所提供的静态常理来设置线程的优先级 t.setPriority(Thread.MAX_PRIORITY); //t.setPriority(Thread.MIN_PRIORITY); //通知Thread对象，执行start方法 t.start(); System.out.println(t.getPriority()); } } 38

多线程数据安全

同步线程的方法 class Test{ public static void main(String args[]){ MyThread myThread = new MyThread(); //生成两个Thread对象，但是这两个Thread对象共用同一个线程体 Thread t1 = new Thread(myThread); Thread t2 = new Thread(myThread); //每一个线程都有名字，可以通过Thread对象的setName()方法设置线程名字，也可以使用getName方法获取线程的名字 t1.setName("线程a"); t2.setName("线程b"); //分别启动两个线程 t1.start(); t2.start(); } } class MyThread implements Runnable{ int i = 100; public void run(){ while(true){ System.out.println(Thread.currentThread().getName()+i); i--; Thread.yield(); if(i<0){ break; } } } } //同步代码块 class MyThread implements Runnable{ int i = 100; public void run(){ while(true){ synchronized(this){ //Thread.currentThread(); System.out.println(Thread.currentThread().getName()+i); i--; Thread.yield(); if(i<0){ break; } } } } }

39深入同步语法

深入synchronized关键字

class Service{ public void fun1(){ synchronized(this){ try{ Thread.sleep(3*1000); } catch(Exception e){ System.out.println(e); } System.out.println("fun1"); } } public void fun2(){ synchronized(this){ System.out.println("fun2"); } } } class MyThread1 implements Runnable{ private Service service; public MyThread1(Service service){ this.service = service; } public void run(){ service.fun1(); } } class MyThread2 implements Runnable{ private Service service; public MyThread2(Service service){ this.service = service; } public void run(){ service.fun2(); } } class Test{ public static void main(String args[]){ Service service = new Service(); Thread t1 = new Thread(new MyThread1(service)); Thread t2 = new Thread(new MyThread2(service)); t1.start(); t2.start(); } } 同步锁锁住的是service 同步方法,同步代码块锁住this class Service{ public synchronized void fun1(){ try{ Thread.sleep(3*1000); } catch(Exception e){ System.out.println(e); } System.out.println("fun1"); } public void fun2(){ synchronized(this){ System.out.println("fun2"); } } }

40JAVA当中的数组

数组的类型数组的定义方法数组的操作方法 class Test{ public static void main(String args[]){ //数组的静态声明 int arr [] = {5,2,7,8,9,0}; arr[3] = 10; //System.out.println(arr[3]); for(int i = 0;i<5;i++){ System.out.println(arr[i]); } } } class Test{ public static void main(String args[]){ int arr[] = {2,4,6,7,8}; System.out.println(arr.length); } } 数组的动态声明 class Test{ public static void main(String args[]){ //动态声明 int arr [] = new int [10]; System.out.println("arr数组长度"+arr.length); for(int i = 0;i<arr.length;i++){ System.out.println(arr[i]); } } }

二维数组定义方法

class Test{ public static void main(String args[]){ //二维数组的定义方法，长度为3 int arr [][] = {{1,2,3},{4,5,6},{7,8,9}}； System.out.println(arr[1][1]); for(int i = 0; i < 3; i++){ for(int j = 0; j < 3; j++){ System.out.println(arr[i][j]); } } } } 优化 class Test{ public static void main(String args[]){ //二维数组的定义方法，长度为3 int arr [][] = {{1,2,3},{4,5,6},{7,8}}； System.out.println(arr[1][1]); for(int i = 0; i < arr.length; i++){ for(int j = 0; j < arr[i].length; j++){ System.out.println(arr[i][j]); } } } } 动态 class Test{ public static void main(String args[]){ //int arr [][] = {{1,2,3},{4,5,6},{7,8}}； int arr [][] = new int[3][5]; System.out.println(arr[1][1]); for(int i = 0; i < arr.length; i++){ for(int j = 0; j < arr[i].length; j++){ System.out.println(arr[i][j]); } } } } 41类集框架什么是类集框架集合的种类类集框架的基础结构

什么是类集框架

1.类集框架是一组类和接口； 2.位于java.util包当中； 3.主要用户存储和管理对象； 4.主要分为三大类---集合，列表和映射

什么是集合（Set）

集合中的对象不按特定的方式排序，并且没有重复对象；对象是没有顺序的，集合是没有顺序的

什么是列表（List）

集合中对象按照索引位置排序，可以有重复的对象。可以按照顺序取，也可以指定取。

什么是映射（Map）

集合中的每一个元素包含一个键对象和一个值对象，键不可以重复，值可以重复。数据结构键值对

类集框架主体结构

interface Iterator Collection ListIterator List Set Map LinkeList ArrayList HashSet SortedSet HashMap SortedMap LinkedHashSet TreeSet LinkedHashMap TreeMap Comparable Comparator Collections Arrays //arrayList默认10,可无限长，关于泛型 Test.java import java.util.List; import java.util.ArrayList; public class Test{ public static void main(String args[]){ //ArrayList arrayList = new ArrayList(); ArrayList<String> arrayList = new ArrayList<String>(); arrayList.add("a"); arrayList.add("b"); arrayList.add("c"); //String s = arrayList.get(1); //System.out.println(s); for(int i=0;i<3;i++){ String s = arrayList.get(i); System.out.println(s); } } } 优化

import java.util.List;
import java.util.ArrayList;

public class Test{
 public static void main(String args[]){
  ArrayList<String> arrayList = new ArrayList<String>();
  
  arrayList.add("a");
  arrayList.add("b");
  arrayList.add("c");
  arrayList.add("d");
  
  for(int i = 0; i < arrayList.size(); i++){
   String s = arrayList.get(i);
  }
 }
}

import java.util.List;
import java.util.ArrayList;


public class Test{
 public static void main(String args[]){
  ArrayList<String> arrayList = new ArrayList<String>();
  arrayList.add("a"); 
  arrayList.add("b");
  arrayList.add("c");
  arrayList.add("d");

  arrayList.remove(1);

  for(int i = 0; i<arrayList.size();i++){
   String s = arrayList.get(i);
   System.out.println(s);
  }
 }
}

类集框架

集合无序不可重复列表有序可重复映射

Collection和Iterator接口

Set与HashSet的使用方法

Collection 接口（一）

boolean add(Object o) 向集合当中加入一个对象 void clear() 删除集合当中的所有对象 boolean isEmpty() 判断集合是否为空 remove(Object o) 从集合中删除一个对象的引用 int size() 返回集合中元素的数目 Set继承了Collection

import java.util.Set;
import java.util.HashSet;

public class Test{
  public static void main(String args[]){

   //HashSet<String> hashSet = new HashSet<String>();
   //Set<String> set = new HashSet<String>();
   
  //别管就是转，方便
   Set<String> set = new HashSet<String>();
   set.add("a");
   set.add("b");
   set.add("c");
   set.add("d");

   int i = set.size();
   System.out.println(i);

  }
}

不可以重复

import java.util.Set;
import java.util.HashSet;

public class Test{
  public static void main(String args[]){

   //HashSet<String> hashSet = new HashSet<String>();
   //Set<String> set = new HashSet<String>();
   
  //别管就是转，方便
   Set<String> set = new HashSet<String>();

   boolean b1 = set.isEmpty();
   System.out.println(b1);

   set.add("a");
   set.add("b");
   set.add("c");
   set.add("d");
   set.add("c");
    
   boolean b2 = set.isEmpty();
   System.out.println(b2);
   
   int i = set.size();
   
   System.out.println("clear之前的长度"+i);
 
   set.clear();
   
   int j = set.size();
 
   System.out.println(j);
  }
}

取数据，迭代 iterate器 (Iterator)

import java.util.Set;
import java.util.HashSet;
import java.util.Iterator;
public class Test{
 public static void main(String args[]){
  //HashSet<String> hashSet = new HashSet<String>();
  //Set<String> set = hashSet;
  //Iterator <-- Collection <-- Set <-- HashSet
  //hasNext() next()

  Set<String> set = new HashSet<String>();
  
  set.add("a");
  set.add("b");
  set.add("c");
  set.add("d");
  set.add("c");
 
  //生成迭代器对象
  //调用Set对象的Iterator方法，会生成一个迭代器对象，该对象用于遍历整个Set
   Iterator<String> it = set.iterator();
   boolean b1 = it.hasNext();
   if(b1){
    String s = it.next();
    System.out.println(s);
   }
   boolean b2 = it.hasNext();
   if(b2){
    String s = it.next();
    System.out.println(s);
   }
  }
}

迭代器的使用

it.hasNext(); 还有没有下一个元素，如果这个游标后面有元素就返回true，否则,false; it.next(); 返回游标所指位置的下一个元素，取出，用hasNext()看有没有，next取 ok

import java.util.Set;
import java.util.HashSet;
import java.util.Iterator;

public class Test{
 public static void main(String args[]){
  //HashSet<String> hashSet = new HashSet<String>();
  //Set<String> set = hashSet;
  //Iterator <-- Collection <-- Set <-- HashSet
  //                        <--List <--ArrayList
  //has Next() next()
  Set<String> set = new HashSet<String>();
 
  set.add("a");
  set.add("b");
  set.add("c");
  set.add("d");
  set.add("c");
  
  Iterator<String> it = set.iterator();

  while(it.hasNext()){
   String s = it.next();
   System.out.println(s);

  }
 }
}

43Map

Map与HashMap的使用方法

JDK帮助文档

什么是映射（Map）

映射中的每一个元素包含一个键对象和一个值对象，键不可以重复，值可以重复。 Map存的是一对

import java.util.Map;
import java.util.HashMap;

public class Test{
 public static void main(String args[]){
  HashMap<String,String> hasMap = new HashMap<String,String>()；

  Map<String,String> map = hasMap;

  map.put("1","a");
  map.put("2","b");
  map.put("3","c");
  map.put("4","d");
  
  int i = map.size();
 
  System.out.println(i);
  }
}

import java.util.Map;
import java.util.HashMap;

public class Test{
 public static void main(String args[]){
  HashMap<String,String> hashMap = new HashMap<String,String>();
  Map<String,String> map = hashMap;

  map.put("1","a");
  map.put("2","b");
  map.put("3","c");
  map.put("4","d");
  map.put("3","e");

  String s = map.get("3");
  System.out.println(s);
  }
}

import java.util.Map;
import java.util.HashMap;

public class Test{
 public static void main(String args[]){
  HashMap<String,String> hashMap = new HashMap<String,String>();
  Map<String,String> map = hashMap;

  map.put("1","a");
  map.put("2","b");
  map.put("3","c");
  map.put("4","d");
  map.put("3","e");

  int i = map.size();
  System.out.println(i);

  String s = map.get("3");
  System.out.println(s);

  }
}

本文参与腾讯云自媒体同步曝光计划，分享自作者个人站点/博客。

原始发表：2018-02-07，如有侵权请联系 cloudcommunity@tencent.com 删除

c++

编程算法

java

node.js

本文分享自作者个人站点/博客前往查看

如有侵权，请联系 cloudcommunity@tencent.com 删除。

本文参与腾讯云自媒体同步曝光计划，欢迎热爱写作的你一起参与！

登录后参与评论

0 条评论

热度