热门标签
热门文章
当前位置: article > 正文
JAVA基础_public void prun(){ int pass = 100; for(int i=0;i<
作者：从前慢现在也慢 | 2024-07-17 05:25:17
赞
踩
public void prun(){ int pass = 100; for(int i=0;i<5;i++){ system.ou
int []a = new int[10];
char [] a = new char[10];
String a = new String("abcd");
int []a = new int[]{1, 2, 3};
int [][]b = {{1, 2, 3},{4, 5, 6}};
int [][]b = new int [10][];
for(int i=0; i<b.length; i++){
b[i] = new int[i+1]; //为各行分配内存空间
for(j=0; j<b[i].length; j++){
b[i][j] = i*j + 2; //为行的数据赋值
}
}
int []a = {1, 2, 3};
for(int i=0; i<10; i++){
a[i] = 表达式（其中有i参与）;
}
d:
dir 列出这个磁盘中有哪些文件；列出这个文件夹中有哪些文件
md 文件夹名 创建一个文件夹
cd 文件夹名 进入到某个文件夹
cd..返回上一级文件夹路径
cd/ 返回根目录
rd 删除某个文件夹
JAVA_HOME: C:\Program Files\Java\jdk1.7.0_17
PATH: 继续添加 C:\Program Files\Java\jdk1.7.0_17\bin
CLASSPATH: .;%JAVA_HOME%;%JAVA_HOME%\lib\tools.jar
javac
java -version
编译：javac www.java
运行：java www.class
数据类型：
基本数据类型：byte/short/int/long/float/double(数值型) char(字符型) boolean(布尔型)
引用数据类型：字符窜、数组、类、接口、枚举型
byte short char 之间不进行强转
switch(
byte/short/int/char/enum/String
参数){
case 常量1: break;
case 常量2: break;
................
default: break;
}
面向对象的三大特征：
封装(private)、
继承(extends)、
多态(
Father father = new Son son();
father.sonOverrideFunction();//父类访问子类重写的构造方法（
虚拟方法调用）
Son son = (Son)father;
son.sonNotOverrideFuncion();//父类访问子类非重写的构造方法（
强转）
)
在同一个类中，函数名称相同，但是形参的个数 或 类型不同的，
称为：方法的重载
public void aaa(int a, int b){};
public void aaa(int a, int b, int c){};
public void aaa(double a, double b){};
构造方法的重载：
public Student(int stuAge, String stuName){
this.age = stuAge;
this.name = stu.Name;
}
public Student(int stuAge, String stuName, int stuGrade){
this.age = stuAge;
this.name = stu.Name;
this.grade = stu.stu.Grade;
}
this关键字：当前类对象的一个引用
public Student(int stuAge, String stuName){
this.age = stuAge;
this.name = stu.Name;
}
public Student(int stuAge, String stuName, int stuGrade){
this(age, stuName); //this调用重载的构造方法
this.grade = stu.stuGrade;
}
导入核心类：import java.lang.*;
导入工具类：import java.util.*;
导入输入输出类：import java.io.*;
导入网络有关类：import java.net.*;
private(只在当前类中使用)
public(使用范围最广，既可跨包，也可跨类)
protected(只在继承关系的类之间使用，即可跨包，也可跨类)
default(不能跨包，但可跨类)
@Override
方法的重写：（名称、类型、参数）要都相同，修饰符可以不同，但要有更大的访问权限
protected String getInfo(){
System.out.println(age + name);
}
@Override
public String getInfo(){
System.out.println(age + name + grade);
}
super: 在继承的关系中，子类中使用对父类对象的引用
public class Person{
public Person(int page, String pname){
this.age = page;
this.name = pname;
}
public void aaa(){};
}
public class Student extends Person{
public Student(int stuAge, String stuName, int stuGrade){
super(age, name);
this.grade = stuGrade;
}
boolean a = x instanceof A: x是A类的对象或x是A类的子类的对象
Object 类： 是所有类的根父类
String a = "abc";
String b = "abc";
boolean ww = a.equals(b);
System.out.println(ww); //ww是true
String str1 = new String("abc");
String str2 = new String("abc");
boolean ww = str1.equals(str2);
System.out.println(ww); //ww是false
Object根父类中有equals（）方法
可以重写方法
@Override
public boolean equals(Object obj) {
if(this==obj){
return true;
}
else if(obj instanceof
MyDate){
MyDate myDate = (
MyDate)obj;
return (this.year==
myDate.year&&this.month==
myDate.month&&this.day==
myDate.day);
}else{
return false;
}
}
如果遇到
比较大小的话，先要在包里面创建一个接口CompareObject：
package com.atguigu.javase.lesson5.ex;
public interface CompareObject {
int CompareTo(Object o);
}
然后在包的其他的某个类A中 实现CompareObject接口， ( implements CompareObject )
@Override
public int CompareTo(Object obj) {
if(obj instanceof
Circle){
Circle c = (
Circle)obj;
return (int)(this.radius-
c.getRadius());
}else{
return 0;
}
}
其实这一步可以直接用“匿名内部类对象”的方式：
在其他类C中：
CompareObject compareObject = new CompareObject() {
@Override
public int compareTo(Object o1, Object o2) {
if(o1 instanceof C && o2 instanceof C){
C c1 = (C)o1;
C c2 = (C)o2;
return (
c1.getRadius()-c2.getRadius());
}
}
};
Comparator是用在
集合
里面进行排序的
Comparator comparator = new Comparator() {
@Override
public int compare(Object o1, Object o2) {
if(o1 instanceof Person1 && o2 instanceof Person1){
Person1 p1 = (Person1)o1;
Person1 p2 = (Person1)o2;
return (p1.getAge()-p2.getAge());
}
throw new ClassCastException("不能转为Person1类型");
}
};
就可以在其他类C中使用A类的CompareTo()方法了
A a = new A();
a.某个属性的set方法();
A b = new A();
b.某个属性的set方法();
boolean c = a.compareTo(b);
System.out.println(c);
包装类（封装类）：都是静态类
int Integer
long Long
double Double
short Short
float Float
char Character
boolean Boolean
byte Byte
在建立一个类中，标配：
成员属性，get() set()方法，toString()方法，hashCode()方法，有参构造器，无参构造器
单子模式：某个类
只能存在一个对象实例
public class Single {
// 1、在类的外部不能有new构造器的方式创建实例.
//把构造器私有化
private Single(){}
// 2、在类的外部不能创建构造器，那就只能在类的内部创建构造器
// 3、为了让外部都可以使用该实例，使用static修饰
// 4、不能在类的外部修改该属性，就必须将这个属性私有化private，只好提供公有的get方法去访问
private
static Single instance = new
Single();
public static Single
getInstance() {
return instance;
}
public static void
setInstance(Single instance) {
Single.instance = instance;
}
}
外部访问：
Single s1 =
Single.getInstance();
Static关键字：
package com.java.atguigu.lesson5;
public class Chinese {
private static String country;
private String name;
private int age;
public Chinese(String country, String name, int age) {
super();
Chinese.country = country;
this.name = name;
this.age = age;
}
public String getCountry() {
return country;
}
public void setCountry(String country) {
Chinese.country = country;
}
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 "Chinese [country=" + country + ", name=" + name + ", age=" + age + "]";
}
}
static方法里面不能有super和this关键字
static静态方法只能访问static静态成员，如果想要访问非静态方法的话，就要用new 一个对象然后去访问才行 public static void main(String []args)
public
static void main(String []args){
int i =
Integer.parseInt(args[0]); arg[0]、arg[1]:命令行参数
int j =
Integer.parseInt(arg[1]);
Person p = new Person();
person.getInfo(){
}
int result = ecm(1,2);
}
public
static void ecm(int i, int j){
.......
}
你好，我觉得一句话就能说清楚，说的多了，反而让你理解的更加模糊。记住这点：
静态方法是属于类的，而普通方法是属于对象的。
属于类的静态方法可以在对象不存在的时候就能访问到，而普通方法必须先new一个对象才能用这个对象访问。
当我们访问调用静态方法的时候（使用类名.静态方法名）这个时候就没有对象创建，所以普通方法是访问不到的。为了避免这种错误，所以java就不允许在静态方法中访问非静态方法。
还有纠正你的错误，main方法也满足我上面说的，你仔细看下，
main方法中是不是先创建的对象，然后用对象去访问的呀。
如果不希望类的属性和方法不因为对象的不同而发生改变时，就要设置为类的静态属性和静态方法
认清静态代码块和非静态代码块：
int age;
{
age = 26;---------------------------非静态代码块
}
public static int total;
static{
total = 100;----------------------------静态代码块
}
abstract抽象类和抽象方法：
有抽象方法的类一定是抽象类
抽象类中不一定要有抽象方法
抽象类不能被实例化
abstract class
abstract int aaa();----无方法体
以下错误：
abstract private--------------私有成员和函数不能抽象
abstract Custom(){}-------------构造器不能抽象
abstract static int aaa(){}-----------静态方法不能抽象
abstract static int b-------------成员不能抽象
abstract int aaa(){}------------抽象方法无方法体
interface接口（里面只有抽象方法和常量，而且无构造器）
一个类只能有一个父类，但可以有很多的接口
public
class OrderDao implements BaseDao1,BaseDao2{
@Override
...
@Override
...
}
public
abstract class OrderDao implements BaseDao1,BaseDao2{
@Override
...
少了些方法的重载
}
类是可以实现接口的（implements），一个类可以有多个接口，但一个类只能有一个父类，
public class OrderDao
extends BaseDaoImpl
implements Dao,Test
接口和接口之间是可以继承的
package com.atguigu.javase.lesson5;
public
interface BaseDao extends Dao{
Object getSingleInstance();
}
输出时间中的年/月、日
Calender calender = Calender.getInstance();
String curentTime = calender.get(Calender.Month)+1;
不用的版本如下
Date currentTime = new Date();
String currentDate = currnetTime.getMonth();
有抽象方法的类一定是抽象类，但抽象类不一定必须有抽象方法
普通类中可以有静态方法，也可以有普通方法
DateFormat可以将日期进行格式化：
Date date = new Date();
System.out.println(date);
DateFormat dateFormat = new SimpleDateFormat("yyyy-mm-dd hh:mm:ss");
Date date = new Date();
String strDate =
dateFormat.format(date)
System.out.println(strDate);
String dateStr = "1990-12-12 12:12:12";
Date date2 =
dateFormat.parse(dateStr);
System.out.println(date2);
DateFormat dateFormat = DateFormat.getDateTimeInstance(DateFormat.LONG, DateFormat.LONG);
Date date = new Date();
String dateStr =
dateFormat.format(date);
System.out.println(dateStr);
如果在创建类中，有静态成员的时候，构造器就会变成：
package com.java.atguigu.lesson5;
public class Chinese {
private static String country;
private String name;
private int age;
public Chinese(String country, String name, int age) {
super();
Chinese.country = country;
this.name = name;
this.age = age;
}
静态内部类和非静态内部类
外部类和内部类的成员变量尽量设置为不同
package com.atguigu.javase.lesson5;
public class
OuterClass {
static class staticInnerClass{
}
class InnerClass{
}
}
非静态内部类访问：
OuterClass oc = new OuterClass();
InnerClass in = oc.new InnerClass();
静态内部类访问：
staticInnerClass sic = new OuterClass.staticInnerClass();
Java异常：
1、error
2、exception(RuntimeException和编译时候的异常)
（1）数学异常 ArithmeticException
（2）空指针异常 NullPointerException
（3）数组下标越界异常 ArrayIndexOutOfBoundsException
（4）类型转换异常 ClassCastException
抓抛：
try{
...
}
catch(
Exception e){
e.printStackTrace();
}
finally{
System.out.println(....) //finally一定会执行的
}
try{
}
catch(
ClassNotFoundException e){
e.printStackTrace();
}
catch(
RuntimeException e){
e.printStackTrace();
}
用户自定义异常类：
public class
UserNotExistException extends RuntimeException{
private static final long serialVersionUID = 1L;
public UserNotExistException(){}
public UserNotExistException(String msg){
super(msg);
}
}
使用：
if(users.contains(user)){
return new User();
}else{
throw new UserNotExistException("用户不存在");
}
有关
遍历输出
的方式：
for(Object obj: person){
System.out.println(obj);
}
for(int i=0; i<person.length; i++){
System.out.println(person[i])
}
Java集合：多个对象的引用放入容器
1、List，有序，可重复 实现类有：LinkedList
2、Set，无序，不可重复 实现类有：HashSet LinkedHashSet TreeSet
3、Map，具有映射关系的集合 实现类有：HashMap LinkedHashMap TreeMap
Java集合中：Collection（包含List/Set） Iterator Map 是一个级别，都是接口
ArrayList集合在后面，它是实现类
1、Collection集合
Collection collection = new ArrayList();
Person person = new Person("WangJZ", 12);
collection.add(person);
colection.remove(person);
int aa =
collection.size();
boolean flag1 =
collection.isEmpty();
boolean flag2 =
collection.contains(new Person("WangJZ",12))
Collection collection = new ArrayList();
Collection collection2 = new ArrayList();
Person person = new Person();
collection2.add(person);
collection.addAll(collection2);
collection.removeAll(collection2);
boolean flag3 =
collection.containsAll(collection2);
collection.clear();
Object []obj =
collection.toArray();
for(Object o1:obj){
System.out.println(o1);
}
保留增加
retainAll(没有retain)的那个部分的元素,用retainAll()需要和add()连用
Collection collection2 = new ArrayList();
collection2.
add(new Person("WangJZ1",12));
collection2.
add(new Person("WangJZ2",13));--------------------new Person("WangJZ1",12)和new Person("WangJZ2",13)
如果在原来的collection集合中没有，就在这个集合中添加这两个
collection2.retainAll(collection);
2、Set集合
（1）Set是无顺序的，按照元素的hashCode值存放，hashCode()可以在Source中生成
Set set = new HashSet();
set.add(new Person("WangJZ", 12));
set.remove();
set.addAll(set2);
set.removeAll(set2);
boolean flag1 = collection.isEmpty();
boolean flag2 = set.contains(new Person("WangJZ", 12));
boolean flag3 = set.containsAll(collection2);
（2）TreeSet
TreeSet set = new TreeSet();
set.
add(new Person("AA", 12));
set.
add(new Person("CC", 16));
set.
add(new Person("EE", 18));
Iterator it = set.iterator();
while(
it.hasNext()){
System.out.println(
it.next());
}
//1、
TreeSet用Comparator来实现排序
，创建Comparator接口的实现类的对象
//实现Compare方法，来比较两个对象的大小
Comparator comparator = new Comparator() {
@Override
public int
compare(Object o1, Object o2) {
if(o1 instanceof Person1 && o2 instanceof Person1){
Person1 p1 = (Person1)o1;
Person1 p2 = (Person1)o2;
return
(p1.getAge()-p2.getAge());//这是按照年龄“升序排列”
}else{
throw new ClassCastException("不能转为Person1类型");
}
}
};
//2、
创建TreeSet对象，然后传入Compare实现类的对象
TreeSet set = new TreeSet(comparator);
set.
add(new Person1("AA", 12));
set.
add(new Person1("CC", 16));
set.
add(new Person1("EE", 18));
set.
add(new Person1("DD", 11));
set.
add(new Person1("BB", 10));
Iterator it = set.iterator();
while(
it.hasNext()){
System.out.println(
it.next());
}
（3）LinkedHashSet集合
LinkedHashSet是有顺序的，顺序按照add的前后顺序存放
Set set = new LinkedHashSet();
set.
add(new Person("AA", 12));
set.
add(new Person("BB", 13));
set.
add(new Person("CC", 14));
（4）
TreeSet set = new TreeSet(comparator);
set.
add(new Person("AA", 12));
set.
add(new Person("BB", 13));
set.
add(new Person("CC", 14));
set.subSet(new Person("AA", 12), new Person("CC", 14));---------------获取两者元素之间的元素----------[ )
set.headSet(new Person("CC", 14));--------------------------获取小于这个元素的所有元素
set.tailSet(new Person("AA",12));--------------------------获取大于这个元素的所有元素
3、List集合
List 有序，可重复
List list = new ArrayList();
List list = Arrays.asList("A","B","C"); //这样的写法，获得的集合是只读的，不能对集合进行相关操作
（1）
list.
add(new Person1("AA", 12));
list.
add(new Person1("BB",11));
list.
add(new Person1("CC", 10));
list.
add(new Person1("DD",9));
Iterator it = list.iterator();
while(
it.hasNext()){
System.out.println(
it.next());
}
还有一种变量方式：（只有list才有）
for(int i=0;i<
list.size();i++){
Object object =
list.get(i);
System.out.println(object);
}
//List集合涉及的几个方法：
// 1. void add(int index, Object ele):把元素添加到指定的位置，原来的元素后移
// 2. boolean addAll(int index, Collection eles):把一组元素添加到指定的位置
// 3. Object get(int index):获取指定索引的元素
// 4. int indexOf(Object obj):获取指定元素的索引值,若元素不存在，则返回-1
int index = list.indexOf(new Person1("CC", 10));
System.out.println(index);
// 5. int lastIndexOf(Object obj):
List中可以存放重复的元素，获取重复元素的
list.add(new Person1("CC", 10));
System.out.println(list.lastIndexOf(new Person1("CC", 10)));
// 6. Object remove(int index):移除指定索引的元素
// 7. Object set(index, Object ele):设置index位置的元素为ele，原来的元素被替换
// 8. List subList(int fromIndex, int toIndex)
可变形参：
（1）记住，如果有能匹配定长的方法（这里面的test( )方法），那么优先匹配该方法，含有不定参数的重载方法被最后匹配
（2）一个方法最后只能有一个长度可变的形参
（3）调用包含一个可变形参的方法时，可以为该形参传入多个参数或一个数组,不传入任何参数也可以
public void test(
String...args){
}
使用：
test("aa","bb","cc","dd","ee");
test(new String[]{"MM","NM"});;
test("aa","bb");
4、Map集合
（1）HashMap 无序
Map map = new HashMap();
map.
put("AA",new Person1("AA", 12));
map.
put("BB",new Person1("BB", 12));
map.
put("CC",new Person1("CC", 12));
map.
put("DD",new Person1("DD", 12));
Set keySet = map.keySet();--------------------------map独有
map.size()
map.clear();
boolean flag = map.
isEmpty();
boolean flag2 = map.
containsKey("DD");
boolean flag3 = map.
containsValue(new Person1("AA", 12));
V
get(Object key):
根据Key返回对应的Value
Object obj =
map.get("CC");
System.out.println(obj);
Collection<V>
values():
返回Value对应的集合。
Collection values =
map.values();
System.out.println(values);
(2)
LinkedHashMap，
有顺序，顺序是元素先后添加的顺序
Map map = new LinkedHashMap();
map.put("AA",new Person1("AA", 12));
map.put("BB",new Person1("BB", 12));
map.put("CC",new Person1("CC", 12));
map.put("DD",new Person1("DD", 12));
（3）
TreeMap: 有顺序，但要和Comparator的compare()方法连用，不用它的话就无法实现排序，以及equals()和hashCode()都要创建
Comparator
comparator = new Comparator() {
@Override
public int
compare(Object o1, Object o2){
if(o1 instanceof Person1 && o2 instanceof Person1){
Person1 p1 = (Person1) o1;
Person1 p2 = (Person1) o2;
return p1.getAge()-p2.getAge();
}
return 0;
}
};
Map map2 = new TreeMap(comparator);
map2.put("AA",new Person1("AA", 12));
map2.put("BB",new Person1("BB", 12));
map2.put("CC",new Person1("CC", 12));
map2.put("DD",new Person1("DD", 12));
关于集合的迭代器：
Iterator迭代器：
Iterator it = collection/set/list.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
另外
List独有迭代器：
for(int i=0; i<
list.size();i++){
Object obj =
list.get(i);
System.out.println(obj);
}
还有Map的迭代器：
Iterator it = keySet.iterator();
while(it.hasNext()){
Object key = it.next();
Object value = map.get(it);
System.out.println(key + value);
}
jdbc.properties:
//读取jdbc.properties文件
//1. 创建properties对象
Properties properties = new Properties();
//2.
调用properties的load()方法，加载属性文件对应的输入流
InputStream inStream = PropertiesTest.class.getClassLoader().getResourceAsStream("jdbc.properties");
properties.load(inStream);
//3. 调用getProperties(String key)方法获取属性值
String user =
properties.getProperty("user");
System.out.println(user);
Collections工具类（是一种可以操作Set集合、List集合、Map集合的一种工具类）
1、获取进程安全：
Collections.synchronizedList(list);
Collections.synchronizedSet(set);
Collections.synchronizedMap(map);
如：
List list = new ArrayList();
List list2 =
Collections.synchronizedList(list);//可以得到进程安全的对象
2、排序(只能用在List集合中)
Comparator comparator = new Comparator() {
@Override
public int compare(Object o1, Object o2){
if(o1 instanceof Person1 && o2 instanceof Person1){
Person1 p1 = (Person1) o1;
Person1 p2 = (Person1) o2;
return p1.getAge()-p2.getAge();
}
return 0;
}
};
Collections.sort(list,comparator);
for(Object obj: list){
System.out.println(obj);
}
3、获取最大/最小
先要排序之后，再做。。。
Object min =
Collections.min(set/map/list);
泛型（Generic）
先建立一个Person类 还有Person类的子类
Student
类
普通方式把对象添加到集合中：
List persons = new ArrayList();
persons.add(new Person("AA",12));
persons.add(new Person("BB",13));
persons.add(new Person("CC",14));
persons.add(new Person("DD",15));
persons.add("ABCD");
for(int i=0;i<
persons.size();i++){
Object obj =
persons.get(i);
Person person = (Person)obj; //对obj要进行强制类型转换
System.out.println(person.getName());//会出现类型转换异常
}
集合中泛型方式添加：
List<Person> persons2 = new ArrayList<Person>();//就是Person类型的List了
persons2.add(new Person("AA",12));
persons2.add(new Person("BB",13));
persons2.add(new Person("CC",14));
persons2.add(new Person("DD",15));
persons2.add(new
Student
());//也可以放Person的子类对象
Person person2 = persons2.get(2);
System.out.println(person2);
集合中泛型+Comparator排序：
Set<Person> persons = new TreeSet<>(new Comparator<Person>() {
@Override
public int
compare(Person p1,Person p2){
return p1.getAge()-p2.getAge();//这里使用compare函数的时候，就不必使用强制类型转换了
}
});
persons.add(new Person("AA",16));
persons.add(new Person("BB",13));
persons.add(new Person("CC",11));
persons.add(new Person("DD",18));
Iterator<Person> it = persons.iterator();
while(
it.hasNext()){
Person person = it.next();
System.out.println(person);
}
public void printPersons
(List<Person> persons){ }
public void printPersons2(
List<? extends Person> persons){ }
泛型类以及函数创建：
public class Dao<T> {
public
T get(int id){
T result = null;
return result;
}
//在泛型类中使用类声明的泛型
public
void save(T entity){
}
//在类(不一定是泛型类)中使用的泛型方法：
//1. 在方法的返回值使用<>前面声明泛型，则在方法的参数，方法体中，都可以使用该类型
//public
<E> E getProperty(int id, E obj){内容} 也是可以的
public <E> E getProperty(int id) {
return null; //返回值是什么类型，那么E就是什么类型
}
//public <E> void test(E[] a, Collections<T> c ){内容}
public <E> void test(E entity){ //传的参数是什么类型，那么E就是什么类型
}
}
使用：
Dao<Peron> dao = new Dao<>();
Person person = new Peson();
person.get(1);
Dao<Peron> dao = new Dao<>();
Person person = new Person();
dao.save(person);
使用：
String name2 = dao.getProperty(1);
int age = dao.getProperty(2);
toArray()方法的妙用：
toArray()方法可以把该集合转为Person类型的数组
Collection<Person> persons = new ArrayList<>();
persons.add(new Person());
persons.add(new Person());
persons.add(new Person());
Person []personArray = persons.toArray(new Person[0]);
System.out.println(personArray.length);
枚举型：
枚举类 希望这个类中只有这几个固定的元素
（1）第一种情况
package com.atguigu.javase.lesson9;
public enum Season2 {
//枚举类的实例需要在枚举类的第一行列出
SPRING("春天","春风又绿江南岸"
),
SUMMER("夏天","印日荷花别样红"
),
AUTUMN("秋天","秋水共长天一色"
),
WINTER("冬天","窗含西岭千秋雪"
);
final String SEASON_NAME;
final String SEASON_DESC;
private Season2(String seasonName, String seasonDesc){
this.SEASON_DESC = seasonDesc;
this.SEASON_NAME = seasonName;
}
}
（2）第二种情况（需要实现某个接口的话）
package com.atguigu.javase.lesson9;
public enum Season4 implements Info{
//枚举类的实例需要在枚举类的第一行列出
SPRING("春天","春风又绿江南岸"){
@Override
public String getInfo(){
return "^^A";
}
},
SUMMER("夏天","印日荷花别样红"){
@Override
public String getInfo(){
return "^^B";
}
},
AUTUMN("秋天","秋水共长天一色")
{
@Override
public String getInfo(){
return "^^C";
}
},
WINTER("冬天","窗含西岭千秋雪"){
@Override
public String getInfo(){
return "^^D";
}
};
final String SEASON_NAME;
final String SEASON_DESC;
Season4(
String seasonName, String seasonDesc){
this.SEASON_DESC = seasonDesc;
this.SEASON_NAME = seasonName;
}
如何使用注解：（Annotation）
可以用IDE创建一个注解
注解可以是程序在编译的时候被读取，并执行相应结果，可以在不改变原有逻辑的情况下，在源文件中嵌入一些信息
@Rentention:注解的保留位置
@Rentention(RetentionPolicy.RUNTIME)
@Target:注解的作用目标
@Target(value={ElementType.TYPE, ElementType.METHOD})
@Deprecated:表示（这个成员、方法、类）已经过时
@SuppressWarnings: 可以抑制编译器发出的警告信息 @SuppressWarnings("unchecked")
(1)示例1
//使用@interface来声明注解
package com.atguigu.javase.lesson9;
@Target(value={ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)//定义为运行时可见
public
@interface
HelloAnnocation {
//使用接口中声明方法的方式来声明注解的属性
String major();
int age();
String school() default "atguigu";
}
（2）示例2
package com.atguigu.javase.lesson9;
public class AnnotationTest {
@SuppressWarnings("rawtypes")//抑制警报器响应：“必须要传递带泛型的参数”
@Test
public void helloAnnotation(){
@SuppressWarnings("unused")
List list = new ArrayList();
}
}
@
HelloAnnocation
(age = 12, major = "Java")
class A{
@HelloAnnocation
(age = 13, major = "Oracle")
void test(){}
void test2(@Deprecated String name){
}
@Deprecated
void test3(){
}
}
class B extends A{
@Override
void test() {
super.test();
}
}
使用：
反射和注解连用
先创建一个注解：
package com.atguigu.javase.lesson12;
@Retention(RetentionPolicy.RUNTIME)
@Target(value = {ElementType.METHOD})
public
@interface AgeValidator {
public int min();
public int max();
}
再创建一个类：
package com.atguigu.javase.lesson12;
public class Person {
String name;
private int age;
private void test(){
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public void setName(String name, Integer age){
System.out.println("name:" + name);
System.out.println("age:" + age);
}
public int getAge() {
return age;
}
@AgeValidator(min=18, max=35)
public void setAge(int age) {
this.age = age;
}
public Person(String name, Integer age) {
super();
this.name = name;
this.age = age;
System.out.println("有参数的构造器");
}
/*
* 无参构造器是留给反射使用的，所以一个类里面要写两个构造器
* */
public Person() {
// System.out.println("无参数的构造器");
}
private String method2(){
return "private String method2";
}
private Object method3(String name, Integer age){
Person person = new Person();
return person;
}
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + "]";
}
}
文件IO流：
字节输入输出流：
InputStream/OutputStream
FileInputStream/FileOutputStream(文件)
BufferedInputStream/BufferedOutputStream(缓冲)
字符输入输出流：
Reader/Writer
FileReader/FileWriter(文件)
BufferedReader/BufferedWriter(缓冲)
使用：
package com.atguigu.javase.lesson10;
public void testStream(){
InputStream inputStream =
new FileInputStream("1.txt");
BufferedInputStream bufferedInputStream = new BufferedInputStream(inputStream);
OutputStream outputStream =
new FileOutputStream("2.txt");
BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(outputStream);
byte []Buffer = new byte[1024];
int len = 0;
while((len = bufferedInputStream.read(Buffer))!=-1){
bufferedOutputStream.write(buffer,0,len);
}
bufferedInputStream.close();
bufferedOutputStream.close();
}
public void testRW(){
InputStream inputStream = new FileInputStream("1.txt");
Reader reader = new InputStreamReader(inputStream);-----------------------使用转换流，字节流转为字符
BufferedReader bufferedReader = new BufferedReader(reader);
OutputStream ouputStream = new FileOutputStream("2.txt");
Writer writer = new OutputStreamWriter(ouputStream);-----------------------使用转换流，字节流转为字符
BufferedWriter bufferedWriter = new BufferedWriter(writer);
String str = null;
int i = 0;
while((str = bufferedWriter.readLine())!=-1){
if(i!=0){
bufferedWriter.write("\n");
}
bufferedWriter.write(str);
i++;
}
bufferedReader.close();
bufferedWriter.close();
}
RandomAccessFile类既可以读，也可以写-------------------用来在文件里面添加内容
public void testRandomAccessFile2() throws IOException{
RandomAccessFile access = new RandomAccessFile("hello.txt","rw");
//先读一行
String line = access.readLine();
//把第一行后面的内容先读取到一个byte数组中。
byte [] buffer = new byte [(int)(access.length()-line.length())];
access.read(buffer);
//移动指针到第一行的后面
access.seek(line.length());
//写入要写的字符窜
access.writeBytes("\n I love Gongfu...\n");
//再写入先前的内容
access.write(buffer);
//关闭
access.close();
}
String 类：
/*
* 1. String 是不可变的字符序列！!!!!!
* 2. 关于字符窜缓冲池: 直接通过 = 为字符窜赋值，会先在缓冲池中查找有没有一样的字符窜，如果有，就把那个引用赋给字符窜变量，否则，就会创建一个新的字符窜，并会把对应的字符窜放入到缓冲池中
* 3. 字符窜的一个常用方法：
* 3.1 去除前后空格的trim()方法,只能是前后空格
* 3.2 求子字符窜的方法：subString()
* 从fromIndex开始，包含fromIndex，且String的字索引从0开始
* 3.3 subString(fromIndex, toIndex): [fromIndex, toIndex)
* 3.4 indexOf(): 求指定字符的索引
* 3.5 split(String regex): 把字符窜拆分成字符窜数组
* 3.6 equals(): 比较字符窜内容是否相等，必须使用该方法，而不能直接使用 ==
*
* */
（1）String类一旦被创建，就是固定的了
public void testNewString(){
String str1 = "hello world";
String str2 = "hello world";
System.out.println(str1.equals(str2)); //true
System.out.println(str1.hashCode());
System.out.println(str2.hashCode());
String str3 = new String("abcd");
String str4 = new String("abcd");
System.out.println(str3==str4); //false
}
（2）
public void testSubString(){
String str = "http://www.atguigu.org/index.jsp?name=Tom";
//subString(fromIndex):从fromIndex开始，包含fromIndex，且String的字索引从0开始
String str1 = str.substring(7);
System.out.println(str1);
String str2 = str.substring(1, 5);
System.out.println(str2);
}
public void testIndexOf(){
String str = "http://www.atguigu.org/index.jsp?name=Tom";
System.out.println(str.indexOf("//")); //5
System.out.println(str.lastIndexOf("/"));
int beginIndex = str.indexOf("//")+2;
int endIndex = str.lastIndexOf("/");
System.out.println(str.substring(beginIndex, endIndex));--------------输出的结果是：
www.atguigu.org
}
（3）
public void testSplit(){
String str = "a-b-c-d-e-f";
String [] values = str.split("-");
for(String s: values){
System.out.println(s);
}
}
（4）
/* * 给定一个字符窜：acmfnz
* 经过运算后打印：每个字符都向后窜一位 bdngoa
* 若某个字符已经是z，则返回到最开始的a
* * */
public void testTranstorString(){
String str = "acmfnz&AcceeEMM";
System.out.println(str);
for(int i=0;i<str.length();i++){
char ch = str.charAt(i);
if(ch>='a'&&ch<='z'){
if(ch=='z'){
ch = 'a';
}
else{
ch = (char)(ch+1);
}
}
else if(ch>='A'&&ch<='Z'){
if(ch=='Z'){
ch = 'A';
}
else{
ch = (char)(ch+1);
}
}
System.out.print(ch);
}
}
(5)
String 变为可变的话，就用StringBuffer()和StringBuilder(),一般用StringBuilder()
StringBuilder stringBuilder = new StringBuilder("abc");
stringBuilder = stringBuilder.replace('a','c');
stringBuilder = stringBuilder.append("aaa").append("bbb").apend("ccc");
Math类：为了获取一些数学值
double aa =
Math.sin(Math.PI);
Random类：为了获取随机数
Random random = new Random();
int bb =
random.nextInt();-------------------获取随机数
int cc =
random.nextInt(10);-----------------获取10以内的随机数
反射Reflection
（1）clazz为Class类的对象
和
Class类（是一种描述类,封装了当前类对象的一些信息）
用反射的时候，Person类里面一定要有无参构造器
Person person = new Person();
Class clazz =
Person.class;
Class clazz =
person.getClass();
Class clazz =
Class.forName("类文件名com.atguigu.aaa");
Object obj =
clazz.newInstance();-----------创建Person类的实例
（2）类加载器是用来把类装进JVM的
public void testClassLoader() throws Exception{
//1. 获取一个系统的类加载器
ClassLoader classLoader = ClassLoader.getSystemClassLoader();
System.out.println(classLoader);
//2. 获取系统类加载器的父类加载器
classLoader = classLoader.getParent();
System.out.println(classLoader);
//3. 获取扩展类加载器的父类加载器
classLoader = classLoader.getParent();
System.out.println(classLoader);
//4. 测试当前类是由哪个类加载器进行加载的
classLoader = Class.forName("com.atguigu.javase.lesson12.Person").getClassLoader();
System.out.println(classLoader);
//5. 测试JDK提供的Object类由哪个加载器加载
classLoader = Class.forName("java.lang.object").getClassLoader();
System.out.println(classLoader);
//6. 关于类加载器的一个主要方法
//调用getResourceAsStream获取类路径下的文件对应的输入流 ---------用的很多
// InputStream in = new FileInputStream("test.properties");
InputStream in = null;
in = this.getClass().getClassLoader().getResourceAsStream("com/atguigu/javase/lesson12/test.properties");
System.out.println(in);
}
（3）Method类
public void testMethod() throws Exception{
Class clazz = Class.forName("com.atguigu.javase.lesson12.Person");
//1. 得到clazz对应的类中有哪些方法，不能获取private方法
Method []methods = clazz.getMethods();
for(Method method:methods){
System.out.println("^" + method.getName());
}
//2. 获取所有方法，不包括private方法，且
只获取当前类声明的方法
Method []methods2 = clazz.getDeclaredMethods();
for(Method method:methods2){
System.out.println("~" + method);
}
//3.
获取指定的方法
Method method =
clazz.getDeclaredMethod("setName", String.class);
System.out.println(method);
method = clazz.getDeclaredMethod("test");
System.out.println(method);
method = clazz.getDeclaredMethod("setName", String.class, Integer.class);
System.out.println(method);
//4. 执行方法
Object obj = clazz.newInstance();
method.invoke(obj, "尚硅谷",12);
System.out.println();
}
重写invoke()方法：
2个
（1）
/* *
* obj: 方法执行的那个对象
* methodName: 类的一个声明，该方法也可能是一个私有方法
* args: 调用该方法需要传入的参数
* return: 调用方法后的返回值
* */
public Object invoke(
Object obj, String methodName,Object...args) throws Exception{
//1. 获取Method对象
Class []parameterTypes = new Class [args.length];
for(int i = 0; i<args.length; i++){
parameterTypes[i] = args[i].getClass();
System.out.println(parameterTypes[i]);
}
try {
Method method =
obj.getClass().getDeclaredMethod(methodName, parameterTypes);
return method.invoke(obj, args);
} catch (Exception e) {
e.printStackTrace();
}
//2. 执行Method方法
//3. 返回方法的返回值
return null;
}
（2）
/* *
* className: 某个类的全类名
* methodName: 类的一个声明
* args: 调用该方法需要传入的参数
* return: 调用方法后的返回值
* */
public Object invoke(
String className, String methodName, Object...args){
Object obj = null;
try {
obj = Class.forName(
className).newInstance();
return invoke(obj, methodName, args);
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
（6）
获取当前类的父类
/* *
获取当前类的父类:
* 直接调用Class对象的getSuperclass()方法
* */
public void testGetSuperClass() throws Exception{
String className = "com.atguigu.javase.lesson12.Student";
Class clazz = Class.forName(className);
Class superClazz = clazz.getSuperclass();
System.out.println(superClazz);
}
（7）method.setAccessible(true);
public class
Student extends Person {
private void method1(Integer age){
System.out.println("private void method1");
}
}
public void testInvokePrivateMethod() throws Exception{
Object obj = new Student();
Class clazz =
obj.getClass();
Method method =
clazz.getDeclaredMethod("method1", Integer.class);
System.out.println(method);
//若需要通过反射执行私有方法
method.setAccessible(true);
method.invoke(obj, 10);
}
代理Proxy:（把类的对象包起来，成为代理对象） 面向对象编程的补充---面向切面编程，如果从各个模块里面收集出
“横切关注点”
一些固定的非业务的需求很多的话，把这些固定的非业务需求用代理去完成
用代理类的代理对象去实现
（1）创建代理对象：
final PersonDo personDo = new PersonDo();----------
被代理的对象一定要是final修饰的
PersonDo proxy
= (PersonDo)
Proxy.newProxyInstance(
clazz.getClassloader(), new Class []{PersonDo.class},
new InnvocationHandler(){
@Override
public Object invoke(Object proxy, Method method, Object []args){
...............一些非业务代码块
调用被代理类的目标方法
Object result = method.invoke(personDo, args);
System.out.println(result);
}
});
（2）使用代理对象实现方法
int ress = proxy.add(1, 2);
线程 Thread类(是一个接口)： 把程序放在线程里面运行
进程，也叫任务（程序运行的基本单位）-------多个线程（线程是独立运行的，不受其他线程干扰）
（1）创建
单线程Thread
public class MyThread
extends Thread{
@Override
public void run(){
线程需要的执行的内容...
}
}
Thread thread = new MyThread();
给线程命名：
thread.setName("WangJZ");
获取线程的名字：thread.getName();
（2）启动单线程
thread.start();
（3）获取当前线程：
Thread thread =
Thread.currentThread();
String threadName = Thread.currentThread().getName();
String myThreadName = MyThread.currentThread().getName();
（4）创建
多线程,需要使用
Runnable（是一个接口）----------------------------可能会有线程安全的问题
public class MyRunnable
immplements Runnable{
@Override
public void run(){
线程需要执行的内容...
}
}
MyRunnable myRunnable = new MyRunnable();
Thread thread1 = new Thread(myRunnable);
Thread thread2 = new Thread(muRunnable);
（5）启用多线程
thread1.start();
thread2.start();
（6）使进程休息一段时间：thread.sleep(1000);----休息1秒
（7）判断线程是否已经死亡了：
boolean flag = thread.isAlive();
（8）把正在运行的线程变为“可运行的线程”,在后面，紧接着还会运行run()方法的
thread.yield();
（9）解除线程阻塞：
tread.interrupt();
（10）当A线程在运行的时候，加入B线程，
此时A线程停止了，直到B线程运行结束之后，再运行A线程。
thread.join();
Thread thread = new MyThread();
@Override
public void run(){
线程需要执行的内容...
}
for(int i=0; i<100; i++){
System.out.println(Thread.currentThread().getName() + i);
thread.join();
}
（11）线程通信：
1、
和线程优先级相关,默认为 5 main()方法中的线程优先级最高
thread.getPriority();
thread1.setPriority(MIN_PRRIORITY);
thread2.setPriority(MAX_PRRIORITY);
2、
在同步方法里面，调用一些方法： 注：前面不需要加线程对象去调用
wait();
notify();
notifyAll();
（12）线程同步：线程和线程之间相互协作，消除线程安全问题
在进程类里面创建同步方法
public synchronized void method(){
方法实现...
}
@Override
public void run(){
method();
}
网络编程：Java中提供有网络类库
网络主机进行通信：IP地址，TCP/IP参考模型（TCP/IP协议）
应用层--传输层--IP层--网络接口层
服务器--------客户端（C/S，开发）
TCP/IP 编程：
域名：www.baidu.com
IP地址：定位主机 202.108.35.210（DNS域名服务器转化得到）
端口：定位程序
（1）获得域名和IP:
InetAddress address = InetAddress.getByName("www.baidu.com");
InetAddress address = InetAddress.getByName("202.108.35.210");
InetAddress address = InetAddress.getLocalHost();
（2）Socket网络套接字（IP和端口的集合）：需要和InputStream连用才能使得客户端和服务器进行交互
1、客户端使用Socket， 客户端--->文件
Socket socket = new Socket(address, 端口号);
InputStream in = socket.getInputStream();
OutputStream out = new FileOutputStream("文件名");
byte []buffer = new byte[1024];
int len = 0;
while((len = in.read(buffer))!=-1){
out.write(buffer,0,len);
}
socket.close();
2、服务器端使用ServerSocket, 文件--->服务器端
ServerSocket serverSocket = new ServerSocket(端口号);
Socket socket = serverSocket.accept();
InputStream in = new FileInputStream("文件名");
byte []buffer = new byte[1024];
int len = 0;
OutputStream out = socket.getOutputStream();
while((len = in.read(buffer))!=-1){
out.write(buffer,0,len);
}
out.close();
in.close();
socket.close();
serverSocket.close();
URL编程,（B/S）开发,URLConnetcion类，也是需要和InputStream连用
URL地址：http://对方主机地址:端口号/文件夹名/文件名
URL url = new URL("URL地址");
URLConnection urlConnection = url.openConnection();
InputStream in = urlConnection.getInputStream();
OutputStream out = new FileOutputStream("文件名");
byte []buffer = new byte[1024];
int len = 0;
while((len = in.read(buffer))!=-1){
out.write(buffer,0,len);
}
in.close();
out.close();
声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/从前慢现在也慢/article/detail/838181
推荐阅读
相关标签
