devbox
IT小白
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

java高级（零碎知识点）

作者：IT小白 | 2024-07-09 15:44:06

赞

踩

java高级

1，面向对象的本质

面向对象是一种方式 通过这种方式 把数据和方法重新封装 以提高代码的重复使用效率

class 类名{属性，方法}  //创建了模板

类名 对象名 = new 类名（）； //通过模板 创建实际案例的对象

对象名.属性；//使用里面的属性
对象名.方法；//使用里面的方法

2，java继承

访问权限控制：

  1. extend :扩展 延申 扩大 (java中 "继承" 的意思 extends 是其复数)
  2. public :公共的 公开的
  3. protected :受保护的
  4. default :默认的
  5. private :私有的 私自的
  6. super :超级的

3，面向对象三大特性封装,继承,多态：

继承:
1、extends 
子类会继承父类的属性和方法
2、super
子类用于调用父类的内容
3、
子类可以重写父类的方法

重载：同名不同参的函数
重写：子类重写父类同名方法

封装：
封装(Java 权限控制)
public 公共的 (在哪儿都可以访问)
protected 受保护的
default 默认的
private 私有的 (只能在自己这个类里使用)

受保护的数据 如何访问和修改
通过 指定的函数 例如 getter 和 setter

多态：
1 需要由继承
2 需要子类重写父类的函数
3 需要父类引用指向子类对象
4*子类独有的方法,多态不能启动,如果需要使用则强制类型转换*
 

 list和set继承结构：

 双向循坏列表：

 集合与泛型：

1，常用子接口：Map,List,Set;
Map常用实现类：HashTable,HashMap,TreeMap
List常用实现类：Vector,Stack,LinkedList,ArrayList
Set常用实现类：HashSet,TreeSet

2,ArrayList 和LinkedList 
相同点： 都是有序的 可以放重复的内容
不同点：
ArrayList 底层的实现时数组 有下标 查找块 但是修改慢
LinkedList 底层的实现双向循环链表 查找慢 但是修改块
3，ArrayList和HashSet
相同点：都可以存空值，由于都属于Collection接口，所以有很多方法都一样可以使用
不同点：
ArrayList是可重复的，是有序的，有索引
HashSet是不重复的，是无序的，无索引
4，HashSet和HashMap
相同点：都是哈希储存方法，可以存空值，算然查找数据比较快，但是修改都比较慢。
不同点：
HashSet实现set接口，仅储存对象；
HashMap实现了Map接口，储存的是键绝对，使用时需先将集合转化为set集合，再使用Iterator.

 JDBCUtil.java

  1. package com.app.JDBCUtil;
  2.  
  3. import java.io.FileInputStream;
  4. import java.io.IOException;
  5. import java.io.InputStream;
  6. import java.sql.Connection;
  7. import java.sql.DriverManager;
  8. import java.sql.ResultSet;
  9. import java.sql.SQLException;
  10. import java.sql.Statement;
  11. import java.util.Properties;
  12.  
  13. public class JDBCUtil {
  14. //	Connection con = null;
  15. //	Statement stm = null;
  16. //	ResultSet rs = null;
  17. 	//封装链接数据库功能 链接后 希望得到 Connection对象
  18. 	public static Connection linkSQL(){
  19. 		Connection con = null;
  20. 		String url = null;
  21. 		String name = null;
  22. 		String password = null;
  23. 		String driversrc = null;
  24. 		try {
  25. 			//读取配置文件
  26. 			
  27. 			//类加载器 加载properties文件
  28. 			InputStream inputStream = JDBCUtil.class.getClassLoader().getResourceAsStream("JDBC.properties");
  29. 			//FileInputStream inputStream = new FileInputStream("./src/JDBC.properties");
  30. 			Properties properties = new Properties();
  31. 			properties.load(inputStream);
  32. 			url = properties.getProperty("url");
  33. 			name = properties.getProperty("name");
  34. 			password = properties.getProperty("password");
  35. 			driversrc = properties.getProperty("driversrc");
  36. 			
  37. 			Class.forName(driversrc);
  38. 			con = DriverManager.getConnection(url,name,password);
  39. 			return con;
  40. 		} catch (ClassNotFoundException e) {
  41. 			// TODO Auto-generated catch block
  42. 			e.printStackTrace();
  43. 		} catch (SQLException e) {
  44. 			// TODO Auto-generated catch block
  45. 			e.printStackTrace();
  46. 		} catch (IOException e) {
  47. 			// TODO Auto-generated catch block
  48. 			e.printStackTrace();
  49. 		}
  50. 		return con;
  51. 	}
  52. 	
  53. 	
  54. 	//关闭释放资源
  55. 	public static void close(Connection con){
  56. 		if (con!=null) {
  57. 			try {
  58. 				con.close();
  59. 			} catch (SQLException e) {
  60. 				// TODO Auto-generated catch block
  61. 				e.printStackTrace();
  62. 			}
  63. 		}
  64. 	}
  65. 	public static void close(Statement stm){
  66. 		if (stm!=null) {
  67. 			try {
  68. 				stm.close();
  69. 			} catch (SQLException e) {
  70. 				// TODO Auto-generated catch block
  71. 				e.printStackTrace();
  72. 			}
  73. 		}
  74. 	}
  75. 	public static void close(ResultSet rs){
  76. 		if (rs!=null) {
  77. 			try {
  78. 				rs.close();
  79. 			} catch (SQLException e) {
  80. 				// TODO Auto-generated catch block
  81. 				e.printStackTrace();
  82. 			}
  83. 		}
  84. 	}
  85. 	public static void close(Connection con,Statement stm,ResultSet rs){
  86. 		if (con!=null) {
  87. 			try {
  88. 				con.close();
  89. 			} catch (SQLException e) {
  90. 				// TODO Auto-generated catch block
  91. 				e.printStackTrace();
  92. 			}
  93. 		}
  94. 		
  95. 		
  96. 		if (stm!=null) {
  97. 			try {
  98. 				stm.close();
  99. 			} catch (SQLException e) {
  100. 				// TODO Auto-generated catch block
  101. 				e.printStackTrace();
  102. 			}
  103. 		}
  104. 		if (rs!=null) {
  105. 			try {
  106. 				rs.close();
  107. 			} catch (SQLException e) {
  108. 				// TODO Auto-generated catch block
  109. 				e.printStackTrace();
  110. 			}
  111. 		}
  112. 	}
  113. }

 

小总结

//javaOOP复习
public class Demo02 {
    public static void main(String[] args) {

  1.         //面向对象 三大特征  封装 继承 多态
  2.         //封装:为属性和方法分访问权限,以提高安全性
  3.         //继承:让程序可以拓展,减少代码的重复,提高复用效率
  4.         //多态:让程序更加灵活,减少代码的修改

        
        //封装 四个关键词    当前类       子类          同一个包          不同的包
        //public ;         √        √        √        √
        //protected;    √        √        √        X
        //default;        √        √        X        X
        //private;        √        X        X        X
        

             继承 extends  

  •         //构造函数(和类名相同的函数)的使用    初始化信息
  •         //this的使用 指代当前对象
  •         //super的使用 指代父类对象

        

       重写 和 重载的区别

  •         //方法的重载 同名不同参数的方法
  •         //方法的重写 子类对于父类同名的方法进行重新定义

        
        //要求 写一个父类 两个子类 子类对于父类的方法进行重写 并还可以调用父类的方法
        //要求2 父类中 有构造函数 并 构造函数有重载
        
        
        常用类
        //包装类
        //8大基本数据类型 对应的有8个包装类
        //byte>>>Byte short>>>Short long>>>Long int>>>Integer
        //float>>>Float double>>>Double char>>>>Character
        //可以将基本数据类型转变为对象,也可以有对象转变成基本数据类型
     

  1.    Integer integer = new Integer("123");
  2.         int i = integer.intValue();
  3.         //自动封箱 拆箱
  4.         int i2 = new Integer("123");
  5.         //Math 算数常用类
  6.         int abs = Math.abs(-123);//绝对值
  7.         System.out.println(abs);
  8.         Math.ceil(3.14);//向上取整
  9.         Math.floor(3.14);//向下取整
  10.         Math.round(3.14);//四舍五入
  11.         Math.random();//0到1之间的随机小数
  12.         //求 随机数 30到60之间的 随机整数
  13.         //随机数 n到m之间的 随机整数 Math.random()*(m-n+1)+n
  14.         int r = (int)(Math.random()*31+30);


        //Arrays 数组工具类

  1.         int[] a = new int[3];
  2.         a[0] = 123;
  3.         a[1] = 345;
  4.         a[2] = 166;
  5.         Arrays.sort(a);//为现有数组排序
  6.         for (int j = 0; j < a.length; j++) {
  7.             System.out.println(a[j]);
  8.         }


       
        //Date 日期类
        //可以获取当前时间 
        //可以把时间转为毫秒值(时间戳)
        //可以设置新时间
    

  1.     Date nowdate = new Date();
  2.         System.out.println(nowdate);
  3.         nowdate.getHours();
  4.         nowdate.getMinutes();
  5.         nowdate.getSeconds();
  6.         //可以把时间转为毫秒值(时间戳)
  7.         nowdate.getTime();
  8.         //可以设置新时间
  9.         Date fdate = new Date(2021,4,16);
  10.         Date f2date = new Date();
  11.         f2date.setHours(12);
  12.         f2date.setMinutes(30);


        
        //字符串工具类
      

  1.  String string = new String("abcdefg");
  2.         string.charAt(3);//根据下标拿第几个字符
  3.         string.concat("hijklmn");//拼接字符串
  4.         System.out.println(string+"hijklmn");
  5.         String[] split = string.split("d");    //以目标字符 分割字符串为数组
  6.         for (int j = 0; j < split.length; j++) {
  7.             System.out.println(split[j]);
  8.         }
  9.         string.replace("a", "A");
  10.         string.toLowerCase();//大小写转换
  11.         string.toUpperCase();


        
        //String 和 StringBulider 和 StringBuffer的区别
        //String固定长度 不可以变
        //StringBulider长度可变 但是 线程不安全 效率高
        //StringBuffer 线程安全 效率低
        
        //集合和泛型
        //set list map的异同
        //set 无序 不可重复  HashSet(哈希散列) TreeSet(二叉树)
        //list  有序 课重复 ArrayList(数组) LinkedList(双向循环链表)
        //map 无序 键值对 HashMap(哈希散列) TreeMap(二叉树)
  

  1.      HashSet<String> hashSet = new HashSet<String>();
  2.         hashSet.add("张三");
  3.         hashSet.add("李四");
  4.         hashSet.add("赵六");
  5.         Iterator<String> iterator = hashSet.iterator();
  6.         while (iterator.hasNext()) {
  7.             String string2 = iterator.next();
  8.             System.out.println(string2);
  9.         }


    
        //IO 考试不考
        //File对象  文件关联 可以创建路径 创建文件 可以删除文件 
        //FileInputStream 字节输入
        //FileOutputStream 字节输出
        //FileReader 字符输入
        //FileWriter 字符输出
        //BufferedInputStream 自带缓冲区 字节输入 线程安全
        //BufferedOutputStream 自带缓冲区 字节输出 线程安全
        //BufferedReader 自带缓冲区 字符输入 线程安全
        //BufferedWriter 自带缓冲区 字符输出 线程安全
        
        //异常的处理
        //try carch finally 捕获 处理异常 最终执行
        //throw 扔异常 谁调用这个方法 谁处理异常

  1.   try {
  2.             FileInputStream fileInputStream = new FileInputStream("./src/abc.txt");
  3.             byte[] b = new byte[1024];
  4.             int len;
  5.             while ((len = fileInputStream.read(b))!=-1) {
  6.                 String string2 = new String(b);
  7.                 System.out.println(string2);
  8.             }
  9.         } catch (FileNotFoundException e) {
  10.             // TODO Auto-generated catch block
  11.             e.printStackTrace();
  12.         } catch (IOException e) {
  13.             // TODO Auto-generated catch block
  14.             e.printStackTrace();
  15.         }


        
        //线程 
        //实现线程的方式
        //1、继承Thread类
        //2、实现runnable接口
        //问 run()和 start()的区别
        //在线程中 主要运行的内容 全部写在 run()里面
        //启动线程 用 start() 如果启动run()运行的是非线程
        
        //线程的生命周期 
        //线程就绪 线程运行 线程阻塞 线程结束
    

  1.     try {
  2.             Thread.sleep(2000);//线程等待
  3.             Thread.yield();//线程让步
  4.             //join()线程加入
  5.         } catch (InterruptedException e) {
  6.             // TODO Auto-generated catch block
  7.             e.printStackTrace();
  8.         }
  9.         //synchronized 同步 （线程锁）
  10.         
  11.         //JDBC
  12.         
  13.         
  14.         
  15.         
  16.         Cat cat = new Cat();
  17.         cat.eat();
  18.         cat.sleep();
  19.         
  20.         Dog dog = new Dog();
  21.         dog.eat();
  22.     }
  23. }
  24.  
  25. class Animal{
  26.     public String name;
  27.     
  28.     //构造函数
  29.     Animal(){//方法的重载
  30.         
  31.     }
  32.     Animal(String name){//方法的重载
  33.         this.name = name;
  34.     }
  35.     
  36.     public void eat(){
  37.         System.out.println("动物吃");
  38.     }
  39.     public void sleep(){
  40.         System.out.println("动物睡");
  41.     }
  42. }
  43. class Cat extends Animal{
  44.     
  45. }
  46. //overwrite
  47. class Dog extends Animal{
  48.     public void eat(){//重写
  49.         super.eat();//调用父类的内容
  50.         System.out.println("狗在吃");
  51.     }
  52. }


 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/IT小白/article/detail/802885
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号