Java学习之基础

public abstract class 类名{}
public abstract 返回值类型 方法名(参数);

public synchronized void showDetails(){
    
}

public transient int limit=55;//不能持久化
public int limit_int=55;//能持久化

int a=(条件)? value is true: value id false

int a=10,b=-5,c=10;
double d=1.2,e=-1.6;
String str="20";
System.out.println(Math.abs(b));
System.out.println("ceil：大于等于最小整数;的使用前面是1.2后面是-1.6"+Math.ceil(d)+"||"+Math.ceil(e));
System.out.println("floor:小于等于最大整数;的使用前面是1.2后面是-1.6"+Math.floor(d)+"||"+Math.floor(e));
System.out.println("rint:返回参数最接近的整数;的使用前面是1.2后面是-1.6"+Math.rint(d)+"||"+Math.rint(e));
System.out.println("round:四舍五入;算法是Math.floor(x+0.5);前面是1.2后面是-1.6"+Math.round(d)+"||"+Math.round(e));
System.out.println("min的使用"+Math.min(a,b));
System.out.println("max的使用"+Math.max(a,b));
System.out.println("exp:e的几次幂的使用"+Math.exp(1));
System.out.println("log:e的对数lnX的使用"+Math.log(Math.exp(1)));//
System.out.println("pow:a的b次方"+Math.pow(a,b));
System.out.println("sqrt:求算是平方根"+Math.sqrt(25));
System.out.println("sin"+Math.sin(Math.PI/2));
System.out.println("asin"+Math.sin(1));
System.out.println("其余三角函数也是一样的");
System.out.println("toDegrees将参数转换位角度"+Math.toDegrees(Math.PI/2));
System.out.println("toRadians将角度转化为弧度"+Math.toRadians(90));
System.out.println("random取随机数"+Math.random());

byte[] bys=new byte[]{97,98,99,100};
String str2=new String(bys);
String str3=new String(bys,1,3);//前面是用来设置开始的位置的，后面是设置列表中的总长度的
System.out.println(str2);//abcd
System.out.println(str3);//bcd
//解决请求乱码是需要用到，在此先做了解
String str4=new String(str3.getBytes("ISO8859-1"),"utf-8");
String str="abcde";
char[] chs=str.toCharArray();
byte[] bytes=str.getBytes();
System.out.println("转化为char列表"+ Arrays.toString(chs) +"转化为字节"+ Arrays.toString(bytes));
String str5="Abcde";
//equals和equalsIgnoreCase的区别:equals比较内容，并且区分大小写，equalsIgnoreCase只比较内容，不区分大小写
System.out.println("equals||"+str.equals(str5)+"||eqaulsIgnoreCase||"+str.equalsIgnoreCase(str5));

String s1="userlyz";
String s2="userlyz";
String s3=s1;
String s4=new String("userlyz");
String s5=new String("userlyz");
char[] helloArray={'u','s','e','r','l','y','z'};
String helloString=new String(helloArray);
System.out.println("我的名字是".concat("userlyz"));
System.out.println("普通+号连接符");
String fs;
fs=String.format("%f,%d,%s",1.2,123,"Str");
System.out.println(fs);
System.out.println("输出此字符串的哈希值"+"userlyz".hashCode());
System.out.println("indexOf:返回指定字符第一次出现的索引，默认开始位置是0"+"useruser".indexOf('s')+"||"+"useruser".indexOf('s',2));
System.out.println("indexOf:中间指定的参数，也可以是字符串"+"useruser".indexOf("er")+"||"+"useruser".indexOf("er",4));
System.out.println("与之还有lastIndexOf指定字符最后一次出现的位置,他也是可以指定开始位置的"+"useruser".lastIndexOf("er"));
System.out.println("length:字符串长度"+"useruser".length());
System.out.println("matches(String regex)判断此字符串是否匹配给定的正则表达式"+"useruser".matches(""));
System.out.println("代替 replace(char oldchar,char newchar):用newchar代替所有出现的oldchar"+"useruser".replace('s','a'));
System.out.println("replaceAll(String regex,String replacement):用replacement代替所有符合正则表达式regex的字符"+"useruser".replaceAll("","lyz"));
System.out.println("replaceFirst(String argex,String replacement):用replacement代替第一个符合正则表达式的字符串"+"useruser".replaceFirst("","lyz"));
System.out.println("拆分  split:按照给定的正则表达式进行拆分，第二个是用来限制拆分"+"user,u,s,er".split(",",2)[0]+"|||"+"user,u,s,er".split(",",2)[1]+"||"+"user,u,s,er".split(",")[3]);
System.out.println("判断是否是指定前缀 startwith(String prefix,int toffset)"+"useruser".startsWith("us")+"||"+"useruser".startsWith("us",2));
System.out.println("substring(int beginIndex,int endIndex)"+"useruser".substring(3)+"||"+"useruser".substring(3,5));
System.out.println("toCharArray() 转换位新的字符数组"+"useruser".toCharArray()[7]);
System.out.println("toLowerCase() 转换成小写"+"USERLYZ".toLowerCase());
System.out.println("toUpperCase() 转换成大学"+"userlyz".toUpperCase());
System.out.println("trim()忽略前面空格和后面空格"+"    user   ".trim()+"|");
System.out.println("isEmpty() 判断字符串是否为空");

StringBuilder sb=new StringBuilder(10);
sb.append("userlyz..");
System.out.println(sb);
sb.append("?");//添加
System.out.println(sb);
sb.insert(8,"java");//插入
System.out.println(sb);
sb.delete(5,8);//删除
System.out.println(sb);
System.out.println("reverse() 字符串反转"+sb.reverse());
sb.replace(1,4,"lyz");//替换
System.out.println("替换之后的sb|"+sb);
sb.setCharAt(6,'Z');
System.out.println("设置索引处的字符设置"+sb);
sb.setLength(8);
System.out.println("修改长度之后|"+sb);
StringBuffer sf=new StringBuffer();
sf= (StringBuffer) sb.subSequence(1,4);
System.out.println("创建新的字符序列，为原序列的子序列"+sf);
String str=sb.substring(2,5);
System.out.println("返回一个新的String，可以只有开始值"+str);

多维数组  String[][] strs=new String[3][4];
double[] mylist={1.2,2.2,3.4,3.5};
double[] mylist_2={2.2,1.2,3.4,3.5};
List<Double> mylist_3=new ArrayList<>();
mylist_3.add(5.9);
mylist_3.add(6.7);
mylist_3.add(1.4);
for (double item :mylist){
    System.out.println(item);
}
System.out.println("equals的使用，只有当两个数组的顺序和内容都一样"+mylist.equals(mylist_2));
Collections.sort(mylist_3);
System.out.println("升序排列之后的mylist_3:"+mylist_3);

/*
日期时间
Date()
Date(long millisec)该参数是从1970年1月1日起的毫秒数
*/
Date mydate=new Date();
System.out.println("toString:显示日期和时间"+mydate.toString());
System.out.println("before after equals的使用："+
        new Date(99,1,12).before(new Date(99,2,18))+"||"+
        new Date(99,1,12).after(new Date(99,2,18))+"||"+
        new Date(99,1,12).equals(new Date(99,2,18)));
SimpleDateFormat ft=new SimpleDateFormat("GG yyyy-MM-dd hh:mm:ss SS E 一年中的第几周w 一个月中的第几周 W ");
System.out.println("SimpleDateFormat: 格式化日期 当前日期是"+ft.format(mydate));
//日期与毫秒的转换
Date date=new Date();
long time=data.getTime();
System.out.println("1970年1月1日以来的毫秒数"+time);
//获取当前的时间距1970年1月1日以来的毫秒值  long start = System.currentTimeMillis( );
//转换位日期对象
Date change_C_D=c.getTime();
System.out.println("转换之后的"+change_C_D);

// 初始化 Date 对象
Date date = new Date();
//c的使用   输出结果 星期一 七月 04 10:15:35 CST 2022
System.out.printf("全部日期和时间信息：%tc%n",date);
//F的使用  输出结果2022-07-04
System.out.printf("年-月-日格式：%tF%n",date);
//D的使用  输出结果07/04/22
System.out.printf("月/日/年格式：%tD%n",date);
//r的使用  输出结果10:15:35 上午
System.out.printf("HH:MM:SS PM格式（12时制）：%tr%n",date);
//T的使用  输出结果10:15:35
System.out.printf("HH:MM:SS格式（24时制）：%tT%n",date);
//R的使用  输出结果10:15
System.out.printf("HH:MM格式（24时制）：%tR",date);

Date D_S_date = new Date(12354356000000L);
DateFormat D_S_df = new SimpleDateFormat("yyyy年MM月dd日");
String str = D_S_df.format(D_S_date);
System.out.println("转换之后的String"+D_S_date);//转换之后的StringFri Jun 30 13:33:20 CST 2361
String str_de = "2020年12月11日";
DateFormat S_D_df = new SimpleDateFormat("yyyy年MM月dd日");
Date S_D_date = S_D_df.parse(str);
System.out.println("转换之后的Date"+S_D_date);//转换之后的DateFri Jun 30 00:00:00 CST 2361

Calendar c=Calendar.getInstance();//默认是当前日期
System.out.println("默认是当前日期"+c);
c.set(2001,5,9);
System.out.println("设置的日期"+c);
Calendar c=Calendar.getInstance();
System.out.println(c.get(Calendar.DATE));
System.out.println(c.get(Calendar.HOUR_OF_DAY));
c.add(Calendar.DATE,-3);
c.set(Calendar.DATE,-3);
System.out.println(c.get(Calendar.DATE));
Date date=c.getTime();//Calendar转换
System.out.println(date);

Pattern p1=Pattern.compile("dog");
Matcher m1=p1.matcher("dog dog dog ddogdddogg");
String output=m1.replaceAll("cat");
System.out.println(output);

public static void main(String[] args) {
    printMax(34,3,3,2,56.5);
    printMax(new double[]{1,4,2});
    printMax();
}
public static void printMax(double... numbers){
    if(numbers.length==0){
        System.out.println("您没有提交参数");
        return;
    }
    double result=numbers[0];
    for(double item:numbers){
        if(item>result){
            result=item;
        }
    }
    System.out.println("参数序列中最大值是"+result);
}

protected void finalize() throws java.long.Throwable
{
   // 在这里终结代码
}

char c;
// 使用 System.in 创建 BufferedReader
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
System.out.println("输入字符, 按下 'q' 键退出。");
// 读取字符
do {
    c = (char) br.read();
    System.out.println(c);
} while (c != 'q');

try{
    //程序代码
}catch(ExceptionName e1){
    //catch代码块
}

//-------------------多重捕获块
try{
    //程序代码
}catch(异常类型1 异常变量1){
    //异常类型1之后执行的代码块
}catch(异常类型2 异常类型2){
    //异常类型2之后的代码块
}...
例
try {
    file = new FileInputStream(fileName);
    x = (byte) file.read();
} catch(FileNotFoundException f) { // Not valid!
    f.printStackTrace();
    return -1;
} catch(IOException i) {
    i.printStackTrace();
    return -1;
}

public void deposit(double amount) throws RemoteEXception,InsufficientFundsException
{
    // Method implementation 可以有一个异常，也可以有多个异常
}

try{
    
}catch(异常类型1 异常变量1){
    
}finally{
    //程序代码
}

try(resources declaration){
    //代码块
}catch(EXceptionType e1){
    //异常块
}

//-----------例子
String line;
try(BufferedReader br = new BufferedReader(new FileReader("test.txt"))) {
    while ((line = br.readLine()) != null) {
        System.out.println("Line =>"+line);
    }
} catch (IOException e) {
    System.out.println("IOException in try block =>" + e.getMessage());
}

try(Scanner scanner=new Scanner(new File("textRead.txt"));PrintWriter writer=new PrintWriter(new File("textWrite.txt"))){
    while(scanner.hasNext()){
        writer.print(scanner.nextLine());
    }

}

class MyException extends Exception{
    //
}
例：package day_7_4;

import java.io.*;
import java.util.Scanner;

public class demo_error {
    public static void main(String[] args) {
        CheckingAccount c=new CheckingAccount(101);
        System.out.println("Depositing $500...");//输入存入
        c.deposit(500);
        try{
            System.out.println("\nWithdrawing$100...");
            c.withdraw(100);
            System.out.println("\nWithDrawing$600...");
            c.withdraw(600);
        } catch (InsufficientFundsException e) {
            System.out.println("Sorry, but you are short$"+e.getAmount());
            //throw new RuntimeException(e);
            e.printStackTrace();
        }
    }
}

class InsufficientFundsException extends Exception{
    private double amount;
    public InsufficientFundsException(double amount){
        this.amount=amount;
    }
    public double getAmount(){
        return amount;
    }
}
class CheckingAccount
{
    //balance为余额，number为卡号
    private double balance;
    private int number;
    public CheckingAccount(int number)
    {
        this.number = number;
    }
    //方法：存钱
    public void deposit(double amount)
    {
        balance += amount;
    }
    //方法：取钱
    public void withdraw(double amount) throws InsufficientFundsException
    {
        if(amount <= balance)
        {
            balance -= amount;
        }
        else
        {
            double needs = amount - balance;
            throw new InsufficientFundsException(needs);
        }
    }
    //方法：返回余额
    public double getBalance()
    {
        return balance;
    }
    //方法：返回卡号
    public int getNumber()
    {
        return number;
    }
}

class Person{}
class Student  extends Person{}

public interface A{
    public void eat();
    public void sleep();
}
public interface B{
    public void show();
}
public class C implements A,B{ 
}

class Person{
    public void study(){
        System.out.println("父类的学习");
    }
}
class Student extends Person{
    //父类若有study方法就重写，如果没有就报错
    @Override
    public void study() {
        super.study();
    }
}

public static void main(String[] args) {     
      Animal a = new Cat();  // 向上转型  父类指向子类
      a.eat();               // 调用的是 Cat 的 eat
      Cat c = (Cat) a;//向下转型
   
      c.work();        // 调用的是 Cat 的 work
  }  
public static void show(Animal a)  {
      a.eat();  
        // 类型判断
        if (a instanceof Cat)  {  // 猫做的事情 
            Cat c = (Cat)a;  
            c.work();  
        } else if (a instanceof Dog) { // 狗做的事情 
            Dog c = (Dog)a;  
            c.work();  
        }  
    } 

//----------------接口环境和普通类环境都是可以的，这个实例是接口环境-----
abstract class Animal {  
    abstract void eat();  
}  
  
class Cat extends Animal {  
    public void eat() {  
        System.out.println("吃鱼");  
    }  
    public void work() {  
        System.out.println("抓老鼠");  
    }  
}  

abstract class A_Per{
    void hello(){
        System.out.println("helloworld");
    }
    abstract void hello_demo();
}
class A_Stu extends A_Per{

    @Override
    void hello_demo() {
        System.out.println("helloworld");
    }
}

enum Color
{
    RED, GREEN, BLUE;
 
    // 构造函数
    private Color()
    {
        System.out.println("Constructor called for : " + this.toString());
    }
 
    public void colorInfo()
    {
        System.out.println("Universal Color");
    }
}
 
public class Test
{    
    // 输出
    public static void main(String[] args)
    {
        Color c1 = Color.RED;
        System.out.println(c1);
        c1.colorInfo();
    }
}

//------输出------
Constructor called for : RED
Constructor called for : GREEN
Constructor called for : BLUE
RED
Universal Color

Map<String ,String > map=new HashMap<String,String>();
map.put("1","value1");
map.put("2","value2");
map.put("3","value3");

//第一种：普通遍历，二次取值；
System.out.println("通过Map.keySet遍历key和value");
for(String key:map.keySet()){
    System.out.println("key="+key+"and value="+map.get(key));
}

//第二种
System.out.println("通过Map.entrySet使用iterator迭代器遍历key和value");
Iterator<Map.Entry<String,String>> it =map.entrySet().iterator();
while(it.hasNext()){
    Map.Entry<String,String> entry=it.next();
    System.out.println("key="+entry.getKey()+"and value="+entry.getValue());
}

//第三种：推荐，尤其是容量大的时候
System.out.println("通过Map.entrySet遍历key和value");
for(Map.Entry<String,String> entry:map.entrySet()){
    System.out.println("key="+entry.getKey()+" and value="+entry.getValue());
}

//第四种
System.out.println("通过Map.values()遍历所有的value,但是不能遍历key");
for(String v:map.values()){
    System.out.println("value="+v);
}

ArrayList<E> objectName=new ArrayList<>();
//例：
ArrayList<String> sites=new ArrayList<String>();
sites.add("添加");
sites.add("添加2");
sites.add("添加3");
System.out.println("获取"+sites.get(0));
sites.remove(2);//删除，删除之后，index后的元素都往前挪一位；
System.out.println("size()方法，获取列表的长度"+sites.size());
for(int i=0;i<sites.size();i++){//遍历列表
    System.out.println(sites.get(i));
}
for(String item:sites){//通过for-each遍历数组
    System.out.println(item);
}

LinkedList<String> sites=new LinkedList<String>();
sites.add("userlyz");
sites.add("github");
sites.add("io");
System.out.println(sites);//[userlyz, github, io]
sites.addFirst("lyz");
System.out.println(sites);//[lyz, userlyz, github, io];还有addLast(E)添加到链表的末尾
sites.removeFirst();
System.out.println(sites);//[userlyz, github, io];还有removeLast()删除链表的末尾元素
System.out.println("getFirst获取头部元素"+sites.getFirst());//getLast获取尾部元素
//遍历方法和遍历ArrayList差不多

HashSet<String> sites=new HashSet<>();
sites.add("userlyz");
sites.add("github");
sites.add("io");
sites.add("io");
System.out.println(sites);//[github, io, userlyz]
System.out.println("contains:判断元素序列中是否有给定的值"+sites.contains("github"));
sites.remove("io");
System.out.println("remove() 删除元素"+sites);
//size()计算元素个数
//for-each来迭代HashSet中的元素

//遍历map
Map<String ,String> map=new HashMap<>();
map.put("邓超", "孙俪"); map.put("李晨", "范冰冰"); map.put("刘德华", "柳岩");
Set<String> keySet=map.keySet();
for(String key :keySet){
    System.out.println(map.get(key));
}
//删除元素 remove();删除所有键值对  clear();计算元素个数 size();
//containsKey()containsValue() 检查hashMap中是否存在指定的key/value对应的映射关系
//

// 创建集合
ArrayList<String> sites = new ArrayList<String>();
sites.add("Google");
sites.add("Runoob");
sites.add("Taobao");
sites.add("Zhihu");

// 获取迭代器
Iterator<String> it = sites.iterator();

// 输出集合中的第一个元素
System.out.println(it.next());
//循环集合元素
while(it.hasNext()) {
    System.out.println(it.next());
}

private static <E> void printArray(E[] inputarray){
    for(E element:inputarray){
        System.out.println(element);
    }
}
public static void main(String[] args) {
    // 创建不同类型数组： Integer, Double 和 Character
    Integer[] intArray = { 1, 2, 3, 4, 5 };
    Double[] doubleArray = { 1.1, 2.2, 3.3, 4.4 };
    Character[] charArray = { 'H', 'E', 'L', 'L', 'O' };

    System.out.println( "整型数组元素为:" );
    printArray( intArray  ); // 传递一个整型数组

    System.out.println( "\n双精度型数组元素为:" );
    printArray( doubleArray ); // 传递一个双精度型数组

    System.out.println( "\n字符型数组元素为:" );
    printArray( charArray ); // 传递一个字符型数组
}

public static void main(String[] args) {
    List<String> name=new ArrayList<String>();
    List<Integer> age=new ArrayList<Integer>();
    List<Number> number=new ArrayList<Number>();
    name.add("userlyz");
    age.add(21);
    number.add(919);
    getData(name);
    getUperNumber(age);
    getUperNumber(number);
}
public static void getUperNumber(List<? extends Number> data){//限定泛型的范围
    System.out.println(data.get(0));
}
public static void getData(List<?> data){
    System.out.println(data.get(0));
}

public static void main(String[] args) {
    SerializeDemo();
    DeserializeDemo();
}
//序列化对象
public static void SerializeDemo(){
    Emloyee e=new Emloyee();
    e.name="userlyz";
    e.address="河南郑州";
    e.SSN=111222333;
    e.number=101;
    System.out.println(e.SSN);
    try{
        FileOutputStream fileout=new FileOutputStream("employee.ser");
        ObjectOutputStream out=new ObjectOutputStream(fileout);
        out.writeObject(e);
        out.close();
        fileout.close();
        System.out.println("已经保存完毕");
    } catch (IOException ex) {
        ex.printStackTrace();
    }
}
//反序列化对象
public static void DeserializeDemo(){
    Emloyee e=null;
    try{
        FileInputStream fileIn=new FileInputStream("employee.ser");
        ObjectInputStream in=new ObjectInputStream(fileIn);
        e= (Emloyee) in.readObject();
        in.close();
        fileIn.close();
    } catch (IOException ex){
        ex.printStackTrace();
        return ;
    } catch (ClassNotFoundException ex) {
        System.out.println("没有找到员工类或者IO异常");
        ex.printStackTrace();
        return;
    }
    System.out.println("反序列化对象");
    System.out.println("姓名"+e.name);
    System.out.println("地址"+e.address);
    System.out.println("SSN"+e.SSN);
    System.out.println("number:"+e.number);
}

class Emloyee implements Serializable{
    public String name;
    public String address;
    public transient int SSN;
    public int number;
    public void mailCheck(){
        System.out.println("发送邮件到"+name+"||"+address);
    }
}

try
{
    URL url = new URL("http://www.runoob.com/index.html?language=cn#j2se");
    System.out.println("URL 为：" + url.toString());
    System.out.println("协议为：" + url.getProtocol());
    System.out.println("验证信息：" + url.getAuthority());
    System.out.println("文件名及请求参数：" + url.getFile());
    System.out.println("主机名：" + url.getHost());
    System.out.println("路径：" + url.getPath());
    System.out.println("端口：" + url.getPort());
    System.out.println("默认端口：" + url.getDefaultPort());
    System.out.println("请求参数：" + url.getQuery());
    System.out.println("定位位置：" + url.getRef());
}catch(IOException e)
{
    e.printStackTrace();
}

try
{
    URL url = new URL("https://www.runoob.com/");
    URLConnection urlConnection = url.openConnection();//
    HttpURLConnection connection = null;
    if(urlConnection instanceof HttpURLConnection)
    {
        connection = (HttpURLConnection) urlConnection;
    }
    else
    {
        System.out.println("请输入 URL 地址");
        return;
    }
    BufferedReader in = new BufferedReader(
            new InputStreamReader(connection.getInputStream()));//返回URL的输入流，用于读取资源
    String urlString = "";
    String current;
    while((current = in.readLine()) != null)
    {
        urlString += current;
    }
    System.out.println(urlString);
}catch(IOException e)
{
    e.printStackTrace();
}

System.out.println("开始发送了啊");
// 创建Properties 类用于记录邮箱的一些属性
Properties props = new Properties();
// 表示SMTP发送邮件，必须进行身份验证
props.put("mail.smtp.auth", "true");
//此处填写SMTP服务器
props.put("mail.smtp.host", "smtp.qq.com");
//端口号，QQ邮箱端口587
props.put("mail.smtp.port", "587");
// 此处填写，写信人的账号
props.put("mail.user", "*********@qq.com");
// 此处填写16位STMP口令
props.put("mail.password", "*********");

// 构建授权信息，用于进行SMTP进行身份验证
Authenticator authenticator = new Authenticator() {

    protected PasswordAuthentication getPasswordAuthentication() {
        // 用户名、密码
        String userName = props.getProperty("mail.user");
        String password = props.getProperty("mail.password");
        return new PasswordAuthentication(userName, password);
    }
};
// 使用环境属性和授权信息，创建邮件会话
Session mailSession = Session.getInstance(props, authenticator);
// 创建邮件消息
MimeMessage message = new MimeMessage(mailSession);
// 设置发件人
InternetAddress form = new InternetAddress(props.getProperty("mail.user"));
message.setFrom(form);

// 设置收件人的邮箱
InternetAddress to = new InternetAddress("*********@qq.com");
message.setRecipient(MimeMessage.RecipientType.TO, to);

// 设置邮件标题
message.setSubject("这是一个标题");

// 设置邮件的内容体
message.setContent("这是接下来的内容", "text/html;charset=UTF-8");

// 最后当然就是发送邮件啦
Transport.send(message);
System.out.println("发送完成了");

class RunableDemo implements Runnable{
    private Thread t;
    private String threadName;
    public RunableDemo(String threadName){
        this.threadName=threadName;
        System.out.println("创建线程"+this.threadName);
    }

    @Override
    public void run() {
        System.out.println("线程运行了:"+this.threadName);
        try {
            for (int i=4;i>0;i--){
                System.out.println("Thread"+this.threadName+","+i);
                Thread.sleep(50);
            }
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println("线程"+this.threadName+"退出了");
    }
    public void start(){
        System.out.println("Starting"+this.threadName);
        if(t==null){
            t=new Thread(this,this.threadName);
            t.start();
        }
    }
}

class DisplayMessage implements Runnable{
    private String message;
    public  DisplayMessage(String message){
        this.message= message;
    }
    @Override
    public  void    run(){
        while(true){
            System.out.println(message);
        }
    }
}

class Demo_Callable implements Callable<Integer>{

    @Override
    public Integer call() throws Exception {
        int i=0;
        for (;i<100;i++){
            //Thread.sleep(100);
            System.out.println(Thread.currentThread().getName()+"|+|"+i);
        }
        return i;
    }
}

//主函数----------------------------------
Demo_Callable demo_callable=new Demo_Callable();
FutureTask<Integer> ft=new FutureTask<>(demo_callable);
for (int i=0;i<100;i++){
    System.out.println(Thread.currentThread().getName()+" 的循环变量是"+i);
    if(i==20){
        new Thread(ft,"有返回值的线程").start();
    }
}
try{
    System.out.println("子线程的返回值:"+ft.get());
} catch (ExecutionException e) {
    e.printStackTrace();
}

public static void main(String[] args) {
        Student s=new Student("1",2,"3");
        p(s);
    }
    public static void p(Object obj){
        Class c1=obj.getClass();
        try{
            Method method=c1.getDeclaredMethod("ppp");//外部类中的private方法名是 ppp
            method.setAccessible(true);
            method.invoke(obj);
        }catch (Exception e){
            e.printStackTrace();
        }
    }

out: for(;;){
    int index=0;
    while (true){
        index++;
        if(index==1){
            break out;
        }
        
    }
}

String str= String.format("整数：%d  小数%.1f  字符串%s",1,12D,"333" );
System.out.println(str);