学习内容总结(week 6)

最新推荐文章于 2024-09-29 08:33:21 发布

J2106_wzc

最新推荐文章于 2024-09-29 08:33:21 发布

阅读量132

点赞数

分类专栏： java_week6 文章标签： java

本文链接：https://blog.csdn.net/zjj0408/article/details/119701766

版权

java_week6 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

1.单例模式

2. File相关操作

3.递归

4. IO流

5.序列化和反序列化

6. Properties

7.网络编程

8.反射

9.sqlYog基本操作

1.单例模式

始终在内存中创建一个实例.
分为:
   a)饿汉式:永远不会出现问题的单例模式(最简单的一种单例);
   b)懒汉式:可能出现问题的一种单例模式;

1)饿汉式:
        1))构造方法私有:保证外界不能直接创建当前类的对象;
        2))在当前类的成员位置创建当前类实例;
        3))提供一个静态的功能,返回值就是当前类本身(需要当前类的实例);

例:
a) public class Student{
   private static Student s = new Student();//当前类实例
   private Student(){}
   pubilc static Student getStudentInstance(){
       return s ;//,静态功能,返回值是当前类本身
   }
   }

b) public class Single{
        public static void main(String[] args){
        Student s1 = Student.getStudentInstance();//调用
        Student s2 = Student.getStudentInstance();
        System.out.println(s1==s2);
        }
}


2)懒汉式:
   1))构造方法私有化;
   2))在当前成员变量的位置声明变量:数据类型就是当前类(私有,静态);
   3)提供静态功能,返回值还是当前类本身.判断如果当前类型变量为null, 直接new当前类的实例,如果不为null,就返回当前类的变量.

   例:
   a) public class Worker{
   private static Worker w;//成员变量位置声明变量,默认null
   private Worker(){}
   public synchronized static Worker getWorkerIntance(){//加入同步代码块防止安全问题
       if(w==null){
           w= new Worker();
           return w ;
       }
       return w;
   }
   }

   b) public class Single (){
       public static void main(String[] args){
           Worker w1 = Worker.getWorkerInstance();//调用
           Worker w2 = Worker.getWorkerInstance();
           System.out.println(w1==w2);
       }
   }

2.File相关操作

File 文件和目录(文件夹)路径名的抽象表示.

   1)成员方法:

   public boolean createNewFile() throws IOException :表示创建文件 :如果不存在,则创建
public boolean mkdir():创建文件夹,如果不存在,则创建;否则就返回false
public boolean mkdirs():创建多个文件,如果父目录不存在,则创建
public boolean delete():删除文件或者文件夹(如果删除文件夹,文件夹必须为空目录)
public boolean renameTo(File dest):重命名,参数传递的修改的 File对象

   2)构造方法:

       方式1: File(String pathname): 参数就是值定的路径,如果没有指定的路径就默认在当前项目下.通过将给定的路径名字字符串转换为抽象路径名来创建新的File实例.(推荐)

       例:
           public class FileDemo {
public static void main(String[] args) throws IOException
File file = new File("D:\\EE_2106\\day25\\code\\a.txt"); //绝对路径
File file2 = new File("aaa.txt");//没有带路径,就默认在当前项目下(相对路径)
        File file3 = new File("D:\\EE_2106\\day25\\code") ;
File file4 = new File("aaa\\bbb\\ccc\\ddd") ;

System.out.println(file.createNewFile());
System.out.println(file2.createNewFile());
System.out.println(file3.mkdir());
System.out.println(file4.mkdirs());
System.out.println(file3.delete());
System.out.println(file.delete());
System.out.println("------------------------");
   File("D:\\EE_2106\\day25\\code\\logo.jpg") ;
File srcFile = new        File("D:\\EE_2106\\day25\\code\\mv.jpg") ;
File destFile = new File("高圆圆.jpg") ;//当前项目路径下
System.out.println(srcFile.renameTo(destFile)) ;
{


       方式2: File(File parent,String child): 从父抽象路径名和子路径名字符串转换为抽象路径名来创建新的 File实例.

       例:

File file3 = new File(file2,"a.txt") ;

方式3:
   File(String parent, String child):参数1:父目录地址参数2:具体的子文件地址

   例:

        File file4 = new File("E://demo","a.txt") ;

   3)判断功能
       public boolean canRead()是否可读;
       public boolean canWrite()是否可写;
        public boolean exists():是否存在;
        public boolean isFile():是否是文件;
       public boolean isDirectory():是否是文件夹;
        public boolean isHidden():是否隐藏;

        例:
            File file = new File("aaa.txt") ;
System.out.println(file.canRead());
System.out.println(file.canWrite());
System.out.println(file.exists());
System.out.println(file.isDirectory());//false
System.out.println(file.isFile());
System.out.println(file.isHidden());

4)高级获取功能

public long length()
public String getName():获取抽象路径名所表示的文件或者目录的名称
public File[] listFiles():获取某个目录下的所有的文件以及文件夹的 File数组
public String[] list():获取某个抽象路径名所表示的文件以及目录的字符串数组

   例:
       File file2 = new File("d://") ;
   File[] fileArray = file2.listFiles();

   if(fileArray!=null){ //防止空指针异常
for(File f :fileArray){
System.out.println(f.getName());

String[] strArray = file2.list();
   if(strArray!=null){
for(String s:strArray){
System.out.println(s);

5)拓展应用
    获取D盘下所有的以.jpg结尾的文件

    方式1:
        public class File{
            public static void mian(String[] args){
            File file = new File("D://") //描述 D 盘
            File[] arrayFile = file.listFile();
            //获取D 盘下所有文件及文件夹
            if(arrayFile != null){
            for(File f :arrayFile){
                if(f.isFile()){// 判断f 是否是文件
                    if(f.getName().endsWith(".jpg")){
                        System.out.println(f.getName());
                    }
                }
            }
            }
            }
        }

    方式2:
        File srcFile = new File("D://");
        File[] files = srcFile.listFiles(new FilenameFilter){//接口的匿名内部类
            @Override
        public boolean accept(File dir, String name) {
//返回true:表示将指定文件添加列表文件中
//描述文件所表示抽象路径File
File file = new File(dir, name);
return file.isFile() && file.getName().endsWith(".jpg");
        }
        if(files != null){
            for(File f : files){
            System.out.println(f.getName());
            }
        }

3.递归

方法调用方法本身,并非是方法嵌套方法.
前提条件:
   1))必须有一个成员方法;
   2))必须有方法递归的出口条件(结束条件);
   3))存在一定的规律;

例:   使用递归方式去删除D盘某个demo文件夹中的.java文件

   public class DiGui{
   public static void main(String[] args) {
   File srcFloder = new File("d://demo");
   deleteFloder(srcFloder);
   }

   public static void deleteFloder(File srcFloder){
   File[] arrayFile = srcFloder.listFiles();
   if(arrayFile != null){
       for(File f : arrayFile){
           if(f.isDirectory()){
           deleteFloder(f);
           }else{
               if(f.getName().endsWith(".java"));
               System.out.println(f.getName()+"----"+f.delete());//删除".java"文件
           }
       }
       System.out.println(srcFile.getName()+srcFile.delete);//删除空文件夹
   }
   }

4.IO 流

1)分类:
       按流的方向:输入和输出;
       按类型:
               字节输入流: InputStream 表示输入字节流的超类;
               字节输出流: OutputSteam 表示输出字节流的超类;
               字符输入流: Reader 表示输入字符流的抽象类;
               字符输出流: Writer 表示输出字符流的抽象类;


   2)一个文本文件读写复制的方法: 11 种

       1))基本的字节流:一次读取一个字节/一次读取一个字节数组
   需求:将当前项目下的DiGui.java 的内容复制到D盘下的Copy.java文件中

       1))) 一次读取一个字节

       例:
           public class Copy{
               method("DiGui","Copy.java");

           public static void method(String srcFile,String destFile){
           FileInputStream fis = null ;
        FileOutputStream fos = null ;
try {
// 封装源文件:FileInputStraem(String pathname)
fis = new FileInputStream(srcFile) ;
// 封装目的地文件:FileOutputStream(String pathname)
fos = new FileOutputStream(destFile) ;
int by = 0 ;
while((by=fis.read())!=-1){
//没有读完,继续复制 :写一个字节
fos.write(by);
}
} catch (IOException e) {
e.printStackTrace();
}finally {
try {
fos.close();
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}


2)))一次读取一个字节数组

例:
   public class Copy{
               method("DiGui","Copy.java");

               FileInputStream fis = null ;
       FileOutputStream fos = null ;
try {
// 封装源文件:FileInputStraem(String pathname)
fis = new FileInputStream(srcFile) ;
// 封装目的地文件:FileOutputStream(String pathname)
fos = new FileOutputStream(destFile) ;

//读写复制操作
//一次读取一个字节数组
byte[] bytes = new byte[1024] ;
int len = 0 ;
while((len=fis.read(bytes))!=-1){
//赋值
//带上len的使用
fos.write(bytes,0,len);
}

} catch (IOException e) {
e.printStackTrace();
}finally {
try {
fos.close();
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}



       2))字节缓冲流:一次读取一个字节/一次读取一个字节数组
   需求:读取D://a.mp4,将这个文件内容复制到当前项目下的copy.mp4中

       1)))一次读取一个字节
           public class Copy{
               public static void main(String[] args) {
               method("D://a.mp4","copy.mp4");
               }
               public static void method(String srcFile,String destFile){
               BufferedInputStream bis = null;
               BufferedOutputStream bos = null;
               try {
bis = new BufferedInputStream(new FileInputStream(srcFile)) ;//只能使用FileInputStream传参
bos = new BufferedOutputStream(new FileOutputStream(destFile)) ;
//读写操作
int by = 0 ;
while((by=bis.read())!=-1){
bos.write(by);
}

} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}finally {
try {
bos.close();
bis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
               }
           }


       2)))一次读取一个字节数组

       同基本的字节流中间代码替换:
           int by →
           byte[] bytes = new byte();
           int len = 0;
           while((bytes = bis.read(bytes)) !=-1){
               bos.write(bytes,0,len);
           }


       3))字符转换流

       1))) 字符转换输入流

       public class ReaderDemo {

public static void main(String[] args) throws Exception {
//创建字符转换输入流对象
InputStreamReader is = new InputStreamReader(new FileInputStream("osw.txt")) ;//平台默认的解码集进行读取

//读一个字符数组
char[] chs = new char[1024] ;
//实际字符数
int len = 0 ;
while((len=isr.read(chs))!=-1){
//打印控制台上:每次获取的实际长度
System.out.println(new String(chs,0,len));
}

//释放资源
isr.close();
}
}

           2)))字符转换输出流

           public class WriterDemo {
public static void main(String[] args) throws Exception {
//创建字符转换输出流对象
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("osw.txt")) ;//使用平台的默认编码集(utf-8)

osw.write("hello");
char[] chs = {'A','B','C','D','E'} ;
osw.write(chs);
osw.write(chs,2,2);
//使用flush():刷新字符输出流
osw.flush();
//关闭资源,释放相关的资源
osw.close();
}
}

       4))字符转换流的便捷方式

       1)))一次读取一个字符
       public class CopyFile {
public static void main(String[] args) throws Exception {

//1)封装源文件:
FileReader fileReader = new FileReader("ReaderDemo.java") ;
//2)封装目文件
FileWriter fileWriter = new FileWriter("D://Demo.java") ;

//3)一次读取一个字符
int by = 0 ; //实际字符数
while((by=fileReader.read())!=-1){
fileWriter.write(by) ;
fileWriter.flush() ;

}

//关闭
fileWriter.close();
fileReader.close();
}
}

           2)))一次读取一个字符数组

           同基本的字节流中间代码替换:
           int by →
           byte[] bytes = new byte();
           int len = 0;
           while((bytes = bis.read(bytes)) !=-1){
               bos.write(bytes,0,len);
           }


       5))字符缓冲流

       1)))一次读取一个字符

       public class CopyFile {
public static void main(String[] args) throws Exception {

//1)封装源文件:
FileReader fileReader = new FileReader("ReaderDemo.java") ;
//2)封装目文件
FileWriter fileWriter = new FileWriter("D://Demo.java") ;

//3)一次读取一个字符
int by = 0 ; //实际字符数
while((by=fileReader.read())!=-1){
fileWriter.write(by) ;
fileWriter.flush() ;
}
}
//关闭
fileWriter.close();
fileReader.close();
}
}

           2)))一次读取一个字符数组

           int by →
           char[] charArray = new char[1024] ;
int len = 0 ;
while((len=fileReader.read(charArray))!=-1){
//写入实际字符数
fileWriter.write(charArray,0,len);
fileWriter.flush();


3)))一次读取一行

public class BufferedReaderDemo {
public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new FileReader("bw.txt")) ;
//定义变量
String line = null ;
while((line=br.readLine())!=null){
System.out.println(line);
}
}
}

5.序列化和反序列化

1)序列化:   ObjectOutputStream
            将某个实体对象写入到流对象中,将一个对象变成流数据.
   序列化之前创建一个实体类:
   实体类在idea中生成一个固定的序列版本id号(一般针对实体类)
            实体类要求:
                a.当前类必须为具体类class 类名{};
                b.必须存在私有字段(私有成员变量);
                c.必须提供公共的setxxx()/getxxx();
                d.如果当前类需要在网络中进行传输(分布式系统中)必须implements Serializable.

        实体类:
            例:
                public class Person implements Serializable {

       //产生一个固定的序列化版本Id
            private static final long serialVersionUID = 8988325735017562383L; //常量值
       String name ; //姓名
       private transient int age ; //年龄 //transient :想让某个字段不参与序列化:这个字段(成员变量就使用transient)
       public Person(){}

public Person(String name, int age) {
this.name = name;

this.age = age;
}

@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}

       序列化:
            例:

        public class ObjectStreamDemo {
public static void main(String[] args) throws IOException, ClassNotFoundException {

myWrite() ;//写
private static void myWrite() throws IOException {
//创建Person对象
Person p = new Person("高圆圆",42) ;

//protected ObjectOutputStream(OutputStream out):创建一个序列化流对象
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("oos.txt")) ;

//将p对象写入到oos流对象中
//public final void writeObject(Object obj)throws IOException
oos.writeObject(p);

//释放资源
oos.close();
}
}
}


   反实例化:
       例:

       public class ObjectStreamDemo {
public static void main(String[] args) throws IOException, ClassNotFoundException {
myRead() ;//读
}
//反序列化
private static void myRead() throws IOException, ClassNotFoundException {
//创建反序列化流对象
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("oos.txt")) ;

//读
//public final Object readObject()
Object object = ois.readObject();
//关闭流
ois.close();
System.out.println(object);//toString()
}

6.Properties

Properties extends Hashtable<K,V> ,它没有泛型,Key和Value都是String,表示一组持久的属性.Properties可以保存到流中或从流中加载,属性列表中的每个键及其对应的值都是一个字符串.
   1)可以使用Map的功能,put(K ,V)
遍历:
keySet()通用

2)有自己特有功能添加元素和遍历
public Object setProperty(String key,String value):给属性列表中添加属性描述(key和value);
public Set<String> stringPropertyNames():获取属性列表中的所有的键;
public String getProperty(String key):在属性列表中通过键获取值;

        遍历,例:

            // 使用Map的遍历方式
            public class PropertiesDemo {
public static void main(String[] args) {
//Properties() :空参构造
Properties properties = new Properties() ;
//利用Map集合的功能去添加元素
properties.put("高圆圆","赵又廷") ;
properties.put("文章","姚笛") ;
properties.put("文章","马伊琍") ;
properties.put("王宝强","马蓉") ;
// System.out.println(properties);

//遍历
Set<Object> keySet = properties.keySet();
for(Object key :keySet){
//通过key获取value
Object value = properties.get(key);
System.out.println(key+"---"+value);
}

System.out.println("---------------------------------------");

// 推荐Properties作为集合类的遍历方式
//创建一个空的属性列表
Properties prop = new Properties() ;
prop.setProperty("张三","30") ;
prop.setProperty("李四","40") ;
prop.setProperty("王五","35") ;
prop.setProperty("赵六","45") ;

//遍历:
Set<String> set = prop.stringPropertyNames();//获取所有键
for(String key:set){
String value = prop.getProperty(key);
System.out.println(key+"---"+value);
}
}
}


       3)Properties 的应用

       1))读取:
           public class PropertiesDemo {
public static void main(String[] args) throws IOException {
   myLoad() ;
private static void myLoad() throws IOException {
//创建一个空的属性列表
Properties prop = new Properties() ;
// Reader r = new FileReader("names.txt") ;//names.txt是在当前项目下路径下
//读取src路径下的names.properties (类路径)
//1)获取当前类所在的字节码文件对象
Class clazz = PropertiesDemo2.class ;
//2)获取当前类所在的类加载器
ClassLoader classLoader = clazz.getClassLoader();
//3)在类加载器中:获取当前资源文件(配置文件names.proprites)所在的输入流对象
InputStream inputStream = classLoader.getResourceAsStream("names.properties");
//将inputStream加载到属性集合类中
// void load(InputSteram in)
prop.load(inputStream);

System.out.println(prop);

Set<String> keySet = prop.stringPropertyNames();
for(String key:keySet){
String value = prop.getProperty(key);
System.out.println(key+"---"+value);
}
}
}
}

   2))存储:
       public class PropertiesDemo {
public static void main(String[] args) throws IOException {
myStore() ;
private static void myStore() throws IOException {
Properties prop = new Properties() ;

//添加key-value
prop.setProperty("张三丰","56") ;
prop.setProperty("吴奇隆","60") ;
prop.setProperty("成龙","65") ;
prop.setProperty("刘德华","70") ;

//public void store(Writer writer,String comments):
//参数2:给当前属性列表中加入一个描述
//保存指定的文件中
prop.store(new FileWriter("user.txt"),"name's list'");

System.out.println("保存完毕");

}
}

7.网络编程

1)特点:
       发送端/客户端; 接收端/服务器端; 两端必须存在Socket对象

   2)三要素:
       ip地址;端口号; 协议
       协议:
           UDP协议:
               a.不需要建立连接通道;
b.属于一种不可靠连接;
c.发送文件大小限制的;
d.执行效率高 (不同步的);

TCP/IP协议:
        a.建立连接通道;
   b.属于安全连接(可靠连接);
        c.发送文件(使用基本字节流),相对udp协议来说没有限制;
d.执行效率低(同步的);

3)UDP编程的发送端:
    a.创建Socket对象;
        b.发送内容:内容数据一种数据报文(报包)DatagramPacket;
       c.释放资源;

       例:
           public class UdpSend {
public static void main(String[] args) throws IOException {
//1）创建Socket对象
//DatagramSocket:发送和接收数据报数据包的套接字
//public DatagramSocket() throws SocketException
DatagramSocket ds = new DatagramSocket() ;
//2)创建一个数据报包对象DatagramPacket
//DatagramPacket(byte[] buf, int length, InetAddress address, int port)
//参数1:当前数据的字节数组
//参数2:当前数据的长度
//参数3:InetAddress:ip地址对象
//参数4:绑定的端口号
byte[] bytes = "hello".getBytes() ;
int length = bytes.length ;
//public static InetAddress getByName(String host)
InetAddress inetAddress = InetAddress.getByName("10.12.156.107");
int port = 12306 ;
DatagramPacket dp = new DatagramPacket(bytes,length,inetAddress,port) ;
//3)发送数据报包
//public void send(DatagramPacket p)
ds.send(dp);
//4)释放资源
ds.close();
}
}
       4)UDP接收端:
           a.创建Socket对象;
           b.创建一个接收容器:数据报包:DatagramPacket;
            c.接收;
           d.解析容器的的实际数据大小;
           e.展示发送端发送的数据;

       例:
           public class UdpReceive {
public static void main(String[] args) throws IOException {
//)创建Socket对象
//public DatagramSocket(int port)
DatagramSocket ds = new DatagramSocket(12306) ;
//2)创建一个接收容器:数据报包:DatagramPacket
//public DatagramPacket(byte[] buf, int length)
//自定义字节缓冲区
byte[] bytes = new byte[1024] ;
int lentgth = bytes.length ;
DatagramPacket dp = new DatagramPacket(bytes,lentgth);

//3)public void receive(DatagramPacket p)
ds.receive(dp);

//4)解析实际数据
//byte[] getData() 获取实际字节数
//返回数据缓冲区。
//int getLength() 获取实际长度
byte[] bytes2 = dp.getData();
int length2 = dp.getLength();
String receiverStr = new String(bytes2,0,length2) ;
//获取ip地址
//InetAddress getAddress()
//InetAddress
//public String getHostAddress():
String ip = dp.getAddress().getHostAddress();
//展示数据
System.out.println("data from "+ip+" ,content is :"+receiverStr)
}
}

       5)TCP 客户端
       特点:需要建立连接通道(就是以一种字节流的方式写入,读取),服务器端如果监听到端口,客户端就立即和服务器端建立连接.
       步骤:
           a.创建TCP客户端的Socket对象;
           b.写数据;
           c.释放资源;

       例:

           public class ScoketDemo {
public static void main(String[] args) throws IOException {
//1)创建TCP客户端的Socket对象
// public Socket(String host, int port)throws UnknownHostException, IOException
//参数1:主机名称/或者ip地址字符串形式
//参数2:指定的端口(0-65535(不包含0-1024))
Socket s = new Socket("10.12.156.107",8888) ;

//2)写数据
//public OutputStream getOutputStream()throws IOException
OutputStream out = s.getOutputStream();//获取通道内的输出流对象
out.write("hello,TCP".getBytes());
//3)释放资源
s.close();
}
}
       6)TCP 服务器端
       实现步骤:
       a.创建服务器端的Socket对象
public ServerSocket(int port)throws IOException;
b.监听客户端连接
public Socket accept()throws IOException 返回值就是当前监听到的客户端的Socket对象;
c.获取通道内的输入流
public InputStream getInputStream() throws IOException;;;
d.读取数据:一次读取一个字节数组;
e.展示数据而且获取ip地址
public InetAddress getInetAddress();

例:
   public class ServerDemo {
public static void main(String[] args) throws IOException {

// 1)创建服务器端的Socket对象
//public ServerSocket(int port)throws IOException
ServerSocket ss = new ServerSocket(8888) ;
System.out.println("服务器正在等待连接...");

//2)监听客户端连接
// public Socket accept()throws IOException 返回值就是当前监听到的客户端的Socket对象
Socket socket = ss.accept(); //阻塞式方法
//3)取通道内的输入流
//public InputStream getInputStream() throws IOException
InputStream inputStream = socket.getInputStream();
//4)读取数据:一次读取一个字节数组
byte[] bytes = new byte[1024] ;
int len = inputStream.read(bytes);
//获取内容
String clientStr = new String(bytes,0,len) ;
//再去反馈数据
//5)获取ip
String ip = socket.getInetAddress().getHostAddress();
//展示数据
System.out.println("data from "+ip+" content is--->"+clientStr);
ss.close();
}
}

8.反射

能够获取当前某个类的字节码文件对象Class,那么就可以获取当前类的构造器并且创建当前类实例,还可以获取当前类的成员变量并去赋值,或者获取当前类的成员方法并去调用.

   1)应用1
       例:

       a.创建一个实例类

       public class Person {

//成员变量
private String name ;//姓名私有
public int age ; //年龄默认
String address ; //地址默认修饰符

//无参构造方法:公共的
public Person(){}

//提供带两个参数的构造方法,默认修饰符
Person(String name,int age){
this.name = name ;
this.age = age ;
}

//提供三个参数的构造方法,私有的
private Person(String name,int age,String addrss){
this.name = name ;
this.age = age ;
this.address = addrss ;
}

//提供一些成员方法(非静态)
public void show(){
System.out.println("show Person");
}
private String functioin(String str){
return str ;
}

void method(String message,int num){
System.out.println(message+num);
}

public int method2(){
return 100 ;
}

@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
", address='" + address + '\'' +
'}';
}
}

       b.获取成员变量

       public class ReflectDemo {
public static void main(String[] args) throws Exception {
//反射的方式
//1)获取Person类的字节码文件
Class clazz = Class.forName("com.qf.reflect_03.Person") ;

//方式1:直接获取当前类的实例
//public T newInstance()
Object obj = clazz.newInstance();
System.out.println(obj);
//方式2:通过获取构造函数对象,创建当前类实例
/* Constructor constructor = clazz.getConstructor();
Object obj = constructor.newInstance();
System.out.println(obj);*/

//2)Class类
//获取所有的公共的成员变量Field
//public Field[] getFields()throws SecurityException
//public Field[] getDeclaredFields():所有的字段所在的Field对象
// 这包括公共，受保护，默认（包）访问和私有字段，但不包括继承的字段。
// Field[] fields = clazz.getFields() ;
/*Field[] fields = clazz.getDeclaredFields() ;
for (Field field : fields) {
System.out.println(field);*/
//public int com.qf.reflect_03.Person.age

//private java.lang.String com.qf.reflect_03.Person.name
// public int com.qf.reflect_03.Person.age
// java.lang.String com.qf.reflect_03.Person.address
// }

//现在访问name private String name ;
//public Field getDeclaredField(String name):获取指定的单个的字段所在的Field对象
//参数为"当前字段名称"
Field nameField = clazz.getDeclaredField("name"); //默认:null

//Field提供方法
//public void set(Object obj,Object value):给绑定在当前对象上的字段进行赋值
//参数1:创建当前类的实例
//参数2:value 赋值的实际参数
//取消Java语言访问检查
nameField.setAccessible(true);
//赋值
nameField.set(obj,"雷欧");
System.out.println(obj);

System.out.println("-----------------------------------------------");

//public int age ;
//获取当前age所在Field对象
//public Field getField(String name):参数为字段名称
Field ageField = clazz.getField("age");
//直接赋值
ageField.set(obj,20);
System.out.println(obj);

System.out.println("-----------------------------------------");
// String address ; //地址默认修饰符
//获取Field对象
Field addressField = clazz.getDeclaredField("address");
//取消Java语言访问检查
addressField.setAccessible(true);
//赋值
addressField.set(obj,"L77星");
System.out.println(obj);
}
}

       c.获取成员方法

       public class ReflectDemo {
public static void main(String[] args) throws Exception{
//直接反射方式获取
//1)获取当前Person字节码文件对象
Class clazz = Class.forName("com.qf.reflect_03.Person") ;
Object obj =clazz.newInstance() ;//当前类实例

//2)获取所有的成员方法:公共的(包含他父类的所有的公共的方法)
//public Method[] getMethods()
//public 方法[] getDeclaredMethods():通过此表示类对象，包括公共，保护，默认（包）访问和私有方法，但不包括继承的方法。
// Method[] methods = clazz.getMethods();
/* Method[] methods = clazz.getDeclaredMethods();
for (Method method : methods) {
System.out.println(method);
}*/

//获取指定的方法调用public void show()
// public Method getMethod(String name,Class<?>... parameterTypes)
//参数1:方法名
//参数2:当前这个方法所携带的参数类型的Class
Method showMethod = clazz.getMethod("show");
//Method:底层调用方法
//public Object invoke(Object obj,Object... args):将方法的实际参数绑定在当前类的实例上
//参数1:就是当前类的实例
//参数2:可变参数, 方法传递实际参数若无参,则实际不用传递
//返回值:如果当前方法本身有返回值,则返回Object

showMethod.invoke(obj) ;

System.out.println("--------------------------------------");
//private String functioin(String str){
// return str ;
// }

//调用Person类中function
//获取function方法的Method对象
//public Method getDeclaredMetho(String name,Class<?> ..parameterTypes).
Method functonMethod = clazz.getDeclaredMethod("functioin", String.class);
//取消Java语言访问检查:私有方法
functonMethod.setAccessible(true);
Object returnObj = functonMethod.invoke(obj, "hello");
System.out.println(returnObj);

}
}

   2)应用2

       例:往ArrayList<Integer>里面添加String类型的元素

public class ReflectTest {
public static void main(String[] rgs) throws Exception {

//有一个ArrayList集合对象
ArrayList<Integer> arrayList = new ArrayList<>() ;
arrayList.add(100) ;
arrayList.add(50) ;
arrayList.add(200) ;
System.out.println(arrayList);

// arrayList.add("hello") ;

//1)获取当前集合实例所在的字节码文件对象
//通过Object的getClass()获取当前实例所在的类的字节码对象
Class clazz = arrayList.getClass();

//System.out.println(obj);
//System.out.println(clazz);//class java.util.ArrayList
//获取当前类中 add方法所在的Method
//public boolean add(E e) ://参数就是任意Java类型 (Element)
Method addMethod = clazz.getMethod("add", Object.class);
//调用方法
addMethod.invoke(arrayList, "hello");
addMethod.invoke(arrayList, "world");
addMethod.invoke(arrayList, "javaEE");

System.out.println(arrayList);
}
}

9.sqlYog基本语法

1. 使用库: USE 库名
   USE mybank_01;

2. 新建表:   CREATE TABLE bank(
           id INT,
           name VARCHAR(10),
           address VARCHAR(20),
           age INT,
           ...
           );

3. 查阅表: SELECT 字段列表 FROM
           SELECT age,name From;
   查阅表整体: SELECT * FROM;

4. 插入全表数据: INSERT INTO 表名 VALUES(值1,值2,...);
       INSERT INTO bank VALUES(1,'雷欧','L77星',235);

5. 插入部分字段:   INSERT INTO 表名(字段1,字段2...) VALUES(值 1,值2...);
           INSERT INTO bank(id,name) VALUES(1,'迪迦');

6. 修改表数据:   UPDATE 表名 SET 要修改的字段名称1=值1,要修改的字段名称2=值2 WHERE 用于定位的字段名称=值;
               UPDATE bank SET id=2,address=地球 WHERE name=雷欧;

7. 删除制定的内容: DELETE FROM 表名 WHERE 字段名称=值;
               DELETE FROM bank WHERE age=235;

8. 删除全表数据:   DELETE FROM 表名;
               DELETE FROM bank;//即使删除,其他数据在此基础上继续叠加,不影响原版的序列;
               TRUNCATE TABLE 表名;
               TRUNCATE TABLE bank;//删除后,后续数据从初始化状态开始存储,默认等同于初始化的一张新表;

9. 查询指定字段并命名: SELECT
                       id '序号',
                       name '姓名'
                   FROM bank;

10. 大于某值的限定: SELECT * FROM bank WHERE age>100;

11. 在两数之间的限定: SELECT * FROM bank WHERE
                       age>=100 && age<=300;
                       (age>=100 AND age<=300 亦可);
                       (BETWEEN 100 AND 300 亦可);

12. 指定条件的限定:   SELECT * FROM bank WHERE age=235 OR
                       age=210;
                   (WHERE age IN(235,210) 亦可);

13. 查询年龄为null人的信息:   SELECT * FROM bank
                           WHERE age IS NULL;

14. 查询年龄不为null人的信息:   SELECT * FROM bank
                           WHERE age IS NOT NULL;

15. 查询为空的数学和英语成绩和:   SELECT
                           id,
                           name,
                           age,
                       (math+IFNULL(english,0)) 's'
                           FROM bank;

16. 对字段去重:   SELECT DISTINCT age FROM bank;

17. 查询不等于某值的信息: SELECT * FROM bank WHERE age<>235

18. 查询包含某个字符的人员信息: SELECT * FROM bank WHERE name LIKE '%三%';

19. 查询第二个字符为'三'的人员信息: SELECT * FROM bank WHERE name LIKE '_%三%';

20. 查询姓名是三个字符的人: SELECT * FROM bank WHERE name
                           LIKE '___';

21. 查询英语最高成绩:   SELECT MAX(IFNULL(english,0)) FROM bank;

22. 排序: select 字段列表 from 表名 order by 字段名排序规则
       SELECT * FROM bank ORDER BY math DESC;
       (DESC 降序;asc升序)

23. 分组查询: SELECT gender,COUNT(id) FROM bank
           GROUP BY gender WHERE age>100;

24. 筛选:   SELECT gender,COUNT(id),AVG(age) FROM bank
       WHERE age>100 GROUP BY gender HAVING COUNT(id)>2;

25. 分页查询: LIMIT 起始行数,每页显示条数;
           起始行数=(当前页码数-1)*每页显示的条数
           SELECT * FROM bank LIMIT 0,3;
           SELECT * FROM bank LIMIT 3,3;
           ...

26. 默认约束: 加入默认约束:
           ALTER TABLE bank MODIFY gender VARCHAR(2)
           DEFAULT '男';
           删除默认约束:
           ALTER TABLE bank MODIFY gender VARCHAR(2);

27. 非空约束: 存在值,空字符,不是null
       CREATE TABLE test(
                           name VARCHAR(10) NOT NULL
                           );
           删除非空约束:
               ALTER TABLE bank MODIFY name VARCHAR(2)

28. 唯一约束: 可以有null值,不能重复
           ALTER TABLE bank MODIFY name VARCHAR(11) UNIQUE ;
           删除约束:
           ALTER TABLE bank DROP INDEX name;

29. 主键约束:(非空+唯一特点) primary key
       CREATE TABLE test(
               id INT PRIMARY KEY , -- 非业务字段
               NAME VARCHAR(10),
               gender VARCHAR(2)
                       ) ;