抽象类
package ChouXiangLei;
abstract class Person {
abstract void eat();
}
class Chinese extends Person{
@Override
void eat() {
System.out.println("chinese实现的eat");
}
}
public class Abstract {
public static void main(String[] args) {
Person p = new Chinese();
// Person p = new Person();
p.eat();
//使用Chinese类来创建抽象类的对象
}
}
package ChouXiangLei;
abstract class Person1{
public Person1() {
System.out.println("person的构造函数");
}
Person1(String name,int age){
this.name = name;
this.age = age;
}
String name;
int age;
// void introduce(){
// System.out.println("我的名字:"+name+",年龄:"+age);
// }
abstract void introduce();
abstract void eat();
}
class Chinese1 extends Person1{
String address;
Chinese1(){
super();
System.out.println("Chinese的构造函数");
}
public Chinese1(String name, int age, String address) {
super(name, age);
this.address = address;
}
@Override
void eat() {
System.out.println("吃饭");
}
@Override
void introduce() {
// super.introduce();
// System.out.println("我的名字:"+name+",年龄:"+age);
// 默认是调用父类方法,现在不是抽象方法,改成抽象方法的话就不能用super了,父类方法中也不能写sout
System.out.println("我的名字:"+name+",年龄:"+age);
//现在用的就是子类中实现的抽象方法
//抽象方法中没有具体的函数方法体,相当于只提供一个接口,**抽象就是没有具体的实体**
//***Java抽象类可以提供某些方法的部分实现***,但是接口不可以,必须全部实现
//interface中只能定义方法,而不能有方法的实现,而在抽象类中则可以既有方法的具体实现,又有没有具体实现的抽象方法
}
}
public class Test {
public static void main(String[] args) {
Person1 p = new Chinese1();
p.eat();
p.name = "zhagnsan";
p.age = 18;
//在这里要有构造的函数进行值传递
p.introduce();
}
}
存钱
package cunqian;
public class Account {
private double balance = 0;
public void deposit(double money){
double newBalance = balance + money;
try {
Thread.sleep(10);
}catch (InterruptedException e){
e.printStackTrace();
}
balance = newBalance;
}
public double getBalance(){
return balance;
}
}
//存钱类AddMoneyThread
package cunqian;
public class AddMoneyThread implements Runnable {
//主类 cunqian.Account
private Account account;
private double money;
public AddMoneyThread(Account account, double money) {
this.account = account;
this.money = money;
}
@Override
public void run(){
account.deposit(money);
}
}
//测试类Test01
package cunqian;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class Test01 {
public static void main(String[] args) {
Account account = new Account();
ExecutorService service = Executors.newFixedThreadPool(100);
for (int i=1; i <= 100; i++){
service.execute(new AddMoneyThread(account,i));
}
service.shutdown();
while (!service.isTerminated()){}
System.out.println("账户余额:"+account.getBalance());
}
}
扑克
package pocker;
//扑克类
//pokerTest运行类
class Poker{
private static String[] suites = {"黑桃","红桃","草花","方块"};
private static int[] faces = {1,2,3,4,5,6,7,8,9,10,11,12,13};
private Card[] cards;
/*
创建扑克牌构造器
*/
public Poker(){
cards = new Card[52];
for(int i=0;i<suites.length;i++){
for(int j=0;j<faces.length;j++){
cards[i*13+j] = new Card(suites[i],faces[j]);
}
}
}
//洗牌
public void shuffle(){
for(int i = 0, len = cards.length;i < len; i++){
int index = (int)(Math.random()*len);
Card temp = cards[index];
cards[index] = cards[i];
cards[i] = temp;
}
}
//发牌
public Card deal(int index){
return cards[index];
}
public class Card{
private String suite;
private int face;
public Card(String suite, int face){
this.face = face;
this.suite = suite;
}
@Override
public String toString(){
String faceStr = "";
switch(face){
case 1:faceStr = "A";break;
case 11:faceStr = "J";break;
case 12:faceStr = "Q";break;
case 13:faceStr = "K";break;
default:faceStr = String.valueOf(face);
}
return suite+faceStr;
}
}
}
package pocker;
class PokerTest{
public static void main(String[] args) {
Poker poker = new Poker();
poker.shuffle(); //洗牌
Poker.Card c1 = poker.deal(0); //发第一张牌
Poker.Card c2 = poker.new Card("红心", 1); //自己创建一张牌
System.out.println(c1);
System.out.println(c2);
}
}
抽象类
abstract class
Person {
abstract void eat();
}
class Chinese extends Person{
@Override
void eat() {
System.out.println("chinese实现的eat");
}
}
public class Abstract {
public static void main(String[] args) {
Person p = new Chinese();
// Person p = new Person();
p.eat();
//使用Chinese类来创建抽象类的对象
}
}
时间函数
import java.text.SimpleDateFormat;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.Date;
public class DateFormatTest {
public static void main(String[] args) {
SimpleDateFormat oldFormatter = new SimpleDateFormat("yyyy/MM/dd");
Date date1 = new Date();
System.out.println(oldFormatter.format(date1));
DateTimeFormatter newFormatter = DateTimeFormatter.ofPattern("yyyy/MM/dd");
LocalDate date2 = LocalDate.now();
System.out.println(date2.format(newFormatter));
}
}
import java.time.Clock;
import java.time.LocalDateTime;
import java.util.Calendar;
import java.util.spi.CalendarDataProvider;
public class DateTimeTest {
public static void main(String[] args) {
Calendar cal = Calendar.getInstance();
System.out.println(cal.get(Calendar.YEAR));
System.out.println(cal.get(Calendar.MONTH));
System.out.println(cal.get(Calendar.DATE));
System.out.println(cal.get(Calendar.HOUR_OF_DAY));
System.out.println(cal.get(Calendar.MINUTE));
System.out.println(cal.get(Calendar.SECOND));
//从上往下是年月日,时分秒
//java8后的
LocalDateTime dt = LocalDateTime.now();
System.out.println(dt.getYear());
System.out.println(dt.getMonthValue());
System.out.println(dt.getDayOfMonth());
System.out.println(dt.getHour());
System.out.println(dt.getMinute());
System.out.println(dt.getSecond());
//年月日,时分秒
System.out.println("-----------------------------------------------------");
//获得毫秒数
Calendar.getInstance().getTimeInMillis();
System.out.println(System.currentTimeMillis());
System.out.println(Clock.systemDefaultZone().millis()); //java 8
System.out.println("-----------------------------------------------------");
//获得某月的最后一天
Calendar time = Calendar.getInstance();
int last = time.getActualMaximum(Calendar.DAY_OF_MONTH);
System.out.println(last);
}
}
文件
import java.io.File;
public class fileList {
//列出目录下的所有文件
public static void main(String[] args) {
File f = new File("D:\\360极速浏览器下载");
/*要保证是一个完整的路径,绝对路径,相对路径和好像不行 */
System.out.println(f);
for (File temp:f.listFiles()){
if (temp.isFile()){
System.out.println(temp.getName());
}
}
}
}
判断素数
public class sushu {
public static void main(String[] args) {
for (int i=1; i < 201; i++){
boolean b = false;
for (int j=2; j < i-1; j++){
int k = i%j;
if (k==0){
b = true;
}
}
if (!b){
System.out.println(i);
}
}
}
}
/*
* 输出1-200的素数,素数就是除了一跟本身其余的都不能跟他整除*/
数组
public class Array {
public static void main(String[] args) {
int arr[][] = {{1,2,3},{2,3,4},{3,4,5}};
for (int i = 0; i < arr.length; i++){
for (int j = 0; j < arr[i].length; j++){
System.out.println(arr[i][j]);
}
}
}
}
//使用数组的.length属性代替数组长度,二维数组也可以用,
冒泡排序
import java.util.Arrays;
public class ArrayMaoPao {
public static void main(String[] args) {
int[] ns = {28,12,89,73,65,18,96,50,8,36};
System.out.println(Arrays.toString(ns));
for (int i=0; i < ns.length; i++){
for (int j=0; j < ns.length-i-1; j++){
if (ns[j] > ns[j+1]){
int tmp = ns[j];
ns[j] = ns[j+1];
ns[j+1] = tmp;
}
}
}
System.out.println(Arrays.toString(ns));
}
}
泛型
import java.util.ArrayList;
public class FanXing {
public static void main(String[] args) {
ArrayList<String> arrayList = new ArrayList<>();
arrayList.add("abc");
arrayList.add("bcd");
arrayList.add("cde");
//arraylist对象使用.add方法添加数据
for (int i = 0; i< arrayList.size(); i++){
//arraylist的长度对象用size,而不是length,不过两者功能相似
System.out.println(arrayList.get(i));
// 获取arraylist对象时,使用new出来的选项.get(下标)
// 一般使用一个变量来承接这个arraylist.get()对象。
// arrayList就是动态数组
//***泛型,任一类型的数据,ArrayList<String> 就是一个任意类型的泛型,不一定要用String
}
}
}
ArrayList就是个泛型类,ArrayList作为集合可以存放各种元素,如Integer, String,自定义的各种类型等,但在我们使用的时候通过具体的
规则来约束,如我们可以约束集合中只存放Integer类型的元素,如 List iniData = new ArrayList<>()
泛型、迭代器
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
public class collection {
public static void main(String[] args) {
Set<String> set = new HashSet<String>();
set.add("a");
set.add("b");
set.add("c");
Iterator<String> it = set.iterator();
int i;
for(i = 0; i < set.size(); i++){
boolean b = it.hasNext();
if (b){
String s = it.next();
System.out.println(s);
}else{
//因为上面使用的set.size()来确定长度,所以并不会产生b为false的情况
//i加到3,循环就停止了,所以不会执行if判断,自然也就没有else
System.out.println(i);
}
}
//使用循环,从第一个开始取,取到最后一个,自动下一个
// boolean b1 = it.hasNext();
// if (b1){
// String s = it.next();
// System.out.println(s);
// }
// boolean b2 = it.hasNext();
// if (b2){
// String s = it.next();
// System.out.println(s);
// }
// boolean b3 = it.hasNext();
// if (b3){
// String s = it.next();
// System.out.println(s);
// }else{
// System.out.println("没有这个元素了");
// }
// 迭代器的使用
// it.hasNext();
// 如果这个游标后面有元素就返回true,否则,false;
// it.next();
// 返回游标所指位置的下一个元素,取出元素
}
}
Map和HashMap
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class MapTest {
public static void main(String[] args) {
HashMap<String,String> hashMap = new HashMap<String,String>();
Map<String,String> map = hashMap;
// 映射就是一每一个元素包含一个键对象和一个值对象,键不能重复,值可以重复
// 使用put往里存放元素,用get得到数据
map.put("1","a");
map.put("2","b");
map.put("3","c");
map.put("4","d");
int i = map.size();
// System.out.println(i);
System.out.println(map.get("2"));
// 取出是根据key的值取出,全部取出有点麻烦,不会
}
}
99乘法表
public class ChengFaBiao {
public static void main(String[] args) {
for (int i = 1;i <= 9; i++){
for (int j=1;j <= i; j++){
System.out.print(j+"*"+i+"="+(i*j));
System.out.print("\t");
}
System.out.println();
}
}
}
猴子吃桃 (循环逆使用)
public class Monkey_peach {
public static void main(String[] args) {
int[] peach = new int[10];
peach[9] = 1;
for (int i = peach.length-1;i > 0; i--){
peach[i-1] = 2*(peach[i] + 1);
}
//从后往前推
int sum = 0;
for (int i = 0;i < peach.length;i++){
// System.out.println(peach[i]);
sum += i;
}
System.out.println("桃子数:"+sum);
}
}
/**
* 猴子吃桃问题,第一天吃掉一半,第二天吃掉剩下的一半多一个,以后类推,到第十天只剩一个桃,一共有几个
*/
水仙花
public class ShuiXianHua {
public static void main(String[] args) {
for (int i=100;i < 1000;i++){
int n1,n2,n3;
int k = i;
n1 = k / 100;
k %= 100;
n2 = k / 10;
k %= 10;
n3 = k;
//分别求出个十百位来,用于下面的相乘和比较
if (i == (getCube(n1)+getCube(n2)+getCube(n3))){
System.out.println(i);
}
}
}
public static int getCube(int n){
return n*n*n;
}
}
/**
* 水仙花数是一个三位数,就是各个数字的立方和等于这个数字本身
*/
最大公约数和最小公倍数
import java.util.Scanner;
public class CommonDivisor {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
System.out.println("请输入一个数:");
int a = in.nextInt();
System.out.println("请输入二个数:");
int b = in.nextInt();
System.out.println(a+b+"最大公约数是:"+getMaxCommon_Divisor(a,b));
System.out.println(a+b+"最小公倍数是:"+getMincommon_multiple(a,b));
}
private static int getMincommon_multiple(int a, int b) {
return (a*b) / getMaxCommon_Divisor(a,b);
}
private static int getMaxCommon_Divisor(int a, int b) {
int max = Math.max(a,b);
int min = Math.min(a,b);
int mod = max % min;
if (mod == 0){
return min;
}else {
return getMaxCommon_Divisor(mod,min);
}
}
}
/**
* 输入两个正整数,求最大公约数和最小公倍数
*/
线程
public class Main {
public static void main(String[] args) {
Thread t = new MyThread();
t.start(); // 启动新线程
}
}
class MyThread extends Thread {
@Override
public void run() {
System.out.println("start new thread!");
}
}
//从Thread派生出一个新的类,并重新run方法,就可以实现线程的具体操作
线程执行具体代码方法二
public class Main {
public static void main(String[] args) {
Thread t = new Thread(new MyRunnable());
t.start(); // 启动新线程
}
}
class MyRunnable implements Runnable {
@Override
public void run() {
System.out.println("start new thread!");
}
}
将数组排序后存放到新数组
import java.util.Arrays;
public class Demo {
public static void main(String[] args) {
int arr[] = {77,98,768,908,354,789,576};
int b[] = new int[6];
//创建一个新数组对象
Arrays.sort(arr);
for (int i = 0; i < arr.length - 1; i++){
b[i] = arr[i];
}
System.out.println(Arrays.toString(b));
}
}
StringBuffer和StringBuilder 的使用
import java.util.StringJoiner;
public class StringBuffer {
public static void main(String[] args) {
StringBuilder sb = new StringBuilder(1024);
for (int i = 0; i < 1000; i++){
sb.append(i);
sb.append(",");
}
String s = sb.toString();
// System.out.println(s);
var sb1 = sb;
System.out.println(sb1);
var sb2 = new StringBuilder(1024);
sb2.append("Mr").append("Bob!").insert(0,"hello,");
//在StringBUilder上进行链式拼接,insert 在0的位置插入这个字符串
// System.out.println(sb2);
System.out.println("sb2.toString() = " + sb2.toString());
// StringBuffer是早期StringBuilder的线程安全版本,两者作用"相同。
String[] names = {"Bob", "Alice", "Grace"};
var sj = new StringJoiner(",");
//StringJoiner是java提供的专门用来拼接字符串的类,在字符串中添加括号里的内容,调用add方法进行添加
for (String name : names){
sj.add(name);
}
// System.out.println(sj.toString());
var sj1 = String.join(",", names);
System.out.println(sj1);
//静态的jion方法,和Stringjioner方法类似
}
}
Math类
import java.util.ArrayList;
import java.util.Random;
public class MathTest {
public static void main(String[] args) {
// System.out.println(Math.abs(-100));//求绝对值 100
// System.out.println(Math.max(88, 999));//求最大值,只能在两个中比较 999
// System.out.println(Math.min(88, 999));//求最小值,只能在两个中比较 88
// System.out.println(Math.pow(2,10));//计算平方,2的10平方 1024.0
// System.out.println(Math.sqrt(16)); //开平方 4.0
// System.out.println(Math.random()); //在0-1之间生成一个随机数
// System.out.println(Math.random()*10);
Random r = new Random();
ArrayList<String> arrayList = new ArrayList<String>();
arrayList.add(String.valueOf(r.nextInt())); //将r.nextInt() 转换为String的值
arrayList.add(String.valueOf(r.nextInt(10)));
arrayList.add(String.valueOf(r.nextFloat()));
r.nextFloat();
r.nextDouble();
for (int i = 0; i < arrayList.size(); i++){
System.out.println(arrayList.get(i));
}
}
}