java afconsole_Java ——基础语法

package myhello; //本类所在的包的路径

import af.util.AfMath;//导入对应的类

import java.util.Random;//导入随机数的类

public classHelloWorld

{public static voidmain(String[] args)

{int a = 8;inti;int total = 0;int score = 80;

System.out.println(a > 8);//空语句 只有一个 ;

;//复合语句 {} 包含的

{

;

}//if 语句

if (score > 60)

System.out.println("及格");elseSystem.out.println("不及格");for (i = 1; i <= 100; i++)

{

total+= i *i;

}

System.out.println(total);//break 为跳出单层循环//创建数据对象

int[] b = new int[30];//等号右侧：创建了一个数组对象//等号左侧：变量 b 称为该对应的引用//称作 变量 b 指向了一个对象//有时也简称为： b 是一个对象，或 b 是对象的名字

b[1] = 1;

b[2] = 2;

b[3] = 3;int[] arr = { 1, 2, 3, 4};

System.out.println(arr.length);//arr[4] = 128; 数组越界//对应与引用

int[] c = { 11, 11, 11, 11};int[] d =c;//c 指向了一个对象//c 和 d 指向相同的对象//c 和 d 都是该对象的引用

d[3] = 30;for (int k = 0; k < 4; k++)

{

System.out.print(c[k] + " ");

}//空对象//null 表示一个引用不指向任何对象

int[] e = { 1, 2, 3, 4};int[] f =e;

e= null;//空指针错误

/** for (int t = 0; t < 4; t++) { System.out.print(e[t]+" "); }*/

for (i = 0; i < 4; i++)

{

System.out.print(f[i] + " ");

}//类 class//类：类型，描述某一类事物的共性//对象：一个具体实例//用来描述一种数据类型//一个class可以若干基本类型的组合

Student s1 = newStudent();

s1.id= "20181109";

s1.name= "Jenrry";

s1.sex= true;

s1.cellphone= "555";//Student 是一个类型//所有的 Student 都有 id,name,sex,cellphone这几个属性//s1是一个Student 类型的对象//数组

Student[] s2 = new Student[5];//类的嵌套

s1.cards.bankCardNumber = "123";

s1.cards.schoolCardNumber= "456";//java 会有默认值//类的方法//类.属性：描述 类有什么//类.方法：描述 类能做什么//属性命名一般使用名词性短语 方法一般是动词性短语

Student s3 = newStudent();

s3.show();

s3.show2(15);//获取最大指

int[] a1 = { 1, 2, 3};int[] aa1 = { 123, 546, 145, 789};int result = 0;for (i = 0; i < a1.length; i++)

{if (a1[i] >result)

{

result=a1[i];

}

}

System.out.print("\n");

System.out.print("最大值：" +result);

MyMath a2= newMyMath();

System.out.print("\n");

a2.getMax(aa1);int result2 =a2.getMax2(aa1);

System.out.print("\n");

System.out.print("最大值：" +result2);//return语句执行后，函数不再往下执行，直接退出方法

MyMath n = newMyMath();

boolean res=n.check2(aa1);

System.out.print("结果为：" +res);//给定一个int值，结果打印一个三角形

MyMath n2 = newMyMath();

System.out.print("\n");

n2.print(10);

n2.print(-1);//数组里能被8整除

int[] arr2 = { 10, 20, 30, 40, 50, 60, 70, 80, 90, 100};

MyMath n3= newMyMath();int[] result3 =n3.find8(arr2);//返回类型可以是一个对象

Student stu = n.createNew("2324", "你好");//像素

Screen s = newScreen();

s.height= 768;

s.width= 1366;int p =s.pixel(s.width, s.height);

System.out.println("像素值是：" +p);//用 that指定

int p2 =s.pixel2(s);

System.out.println("像素值2是：" +p2);//当前对象 this

int p3 =s.pixel3();

System.out.println("像素值3是：" +p3);//显示从 m，n之前所有的质数 用到this

MyMath n4 = newMyMath();

n4.showPrimes(400, 500);//this. 一般可以省略 重名不能省略//有一个换游戏币的机器，可以投1元、5、10元，最后按出货按钮，可以吐出游戏币//每个游戏币=1元人民币

Machine n5 = newMachine();

n5.insertCash(5);

n5.insertCash(10);

n5.insertCash(50);//出货

int coins =n5.exchange();

System.out.println("拿到了" + coins + "个游戏币");//用户输入：数组data//把打他数组里面，所有的质数都放到result

PrimeFilter filter = newPrimeFilter();int[] a4 = { 128, 38, 103, 89};int[] a5 = { 34, 8, 11, 29};

filter.put(a4);

filter.put(a5);int[] numbers =filter.values();//对象=属性+方法//属性就是数据//方法就是算法//对象就是数据和算法的整合体//给它所需的数据>>让它干活>>取出结果//面向对象程序设计//访问修饰符//public private//可见性//private 不可访问，即不可见//public 可以访问，即可见//构造方法//用于构造对象的方法 当创建对象时调用的方法//规则: 方法名与类名相同；无返回值

Student2 stu2 = new Student2("123", "Jenrry", true);//默认构造方法 无参数//如果没有构造方法，java编译器会默认一个空的构造方法

/** public Student2() {

*

* }

**/

//对象的销毁//程序员只管创建对象，不管销毁对象，对象的销毁由系统自动完成//当对象不再被使用时，由垃圾回收机制GC自动回收 GC: Garbage Collect//对象不再被使用。即对象失去引用//extends 继承//在 java语言里，用exends来表示两个类的父子关系//public class B extends A//表示B继承A//A:父类 B:子类//当B继承于A时，自动继承A中的public 属性/方法

MyVideoFile file = newMyVideoFile();

file.size= 123034;

file.name= "文档";

file.duration= 120;

file.info();

file.play();

file.stop();//重写//如果父类的方法不满足要求，则可以在子类里重写一遍

file.info();//父类构造方法//子类会先调用父类构造方法 再调用子类的构造方法//可以用 super 制定调用哪个构造方法//创建一个对象时，构造方法被调用

Child ch = newChild();

System.out.println("exit");//单根继承//java语言里，一个类只能extend是一个父类//继承只能有1个父亲，但是可以有一个继承链//即 A -> B -> C -> D ……//看继承链 右键 Quick Type Hierarchy//在 java 语言中，Object 类是所有类的父类 上面的快捷键可以展示出来//如果一个类没有指定父类，则它默认父类就是 Object//重写 toString() 方法//toString() 是 Object 的一个方法

Student Stu = newStudent();

Stu.id= "1234";

Stu.name= "4567";

Stu.sex= true;

System.out.println(Stu);//重写 toString 函数，修改 Stu 显示的格式//多态//java里，包含：重载 Overload ；重写 Override ；泛型//有一个饼干，是苹果味饼干

Pie pi = newApplePie();//有一个宝宝

Baby bb = newBaby();//宝宝要吃饼干

bb.eat(pi);//语法上：//1. 子类转换成父类顺理成章(隐式转换)//如上 Pie pi = ApplePie();//2. 父类转换成子类型要谨慎 需要显式转换//多态

MyVideoFile f1 = newMyVideoFile();

f1.name= "abc.mp4";

f1.size= 14000;

f1.duration= 130;

MyFile file2=f1;

file2.info();//注意 当调用一个方法是，不是看引用(声明)的类型，而是看对象的实际类型//file 指向的是一个MyVideoFile对象，因而调用的是子类的info()方法//在 java里，由于所有的类型都是Object的直接或者间接子类//所以。 Object x = new MyVideoFile(); 是没有问题的。//包//右键点击包名， show in -> System Explorer//建立目录是用 . 分隔//一个类XXX，对应的文件是 XXX.java//类的全路径： af.util.AfMath//类的文件路径： af/util/AfMath.java//导入类

AfMath a8 = newAfMath();//类改名//左窗口右键对应的类 -> refactor->rename//改属性名、方法名 对应属性/方法 右键-> refactor -> rename//快捷键//注释：选中要注释的行 ctrl+ ///查看定义： CTRL+鼠标点击//打开提示： ATL+ ///格式化选中代码： CTRL+SHIFT+F//静态方法(全局方法)//该方法与类的关系不大。随便拷贝到别的类里也仍然可以运行，没有语法错误；没有this对象//动态方法//该方法与类关系密切。如果拷贝到别的类里就失去意义，有语法错误。//静态方法用 static 修饰//静态方法调用无需创建对象，因为是一个全局的

boolean result5 = Example.isPrime(123);//Math 类//有很多数据计算相关的静态方法//和 String类似，Math 也是 java 语言自带的类//abs(a): 求a的绝对值//pow(a,b): 求a的b次幂//sqrt(a) : 求a的平方根//round(a): 四舍五入//sin/cos/tan://应用 Math.//程序入口：//main 方法，仅有一个格式//可以有多个，用于类的调试//如有多个 入口需指定//字符串//字符串长度 String s = ""; int n = s.length();//注：中文字符和英文字符都只占一个字符//空字符串和null是两回事；空字符串是一个正常的字符串对象；null不指向任何对象//截断 substring(begin,end) ; s.substring//相等 equals 注：不能使用 == 符号来验证//比较 compareTo//忽略大小写比较 compareToIgnoreCase()//格式化 format//查找 indexOf//前缀 startWith()//后缀 endsWith//基本类型与包装类型//在java里面。每一个基本类型都对应一个包装类型//long -> Long//int -> Integer//short -> Short//byte -> Byte//double -> Double//float -> Float//boolean -> Boolean//包装类型： 将对应的基本类型封装在内，得到一个类大概就是这种形式//class Integer//{//private int value = 0;//... Getter/Setter/...方法//}//使用Integer等包装类，就可以统一用“对象”的思路；来处理问题//所有的类都是Object的子类，Interger也是，但 int，double，boolean 却不是,他们是基本的数据类型//Java是面向对象的编程语言，一切都是对象，但是为了编程的方便还是引入了基本数据类型，为了能够将这些基本数据类型当成对象操作，Java为每一个基本数据类型都引入了对应的包装类型//基本类型和包装类型的转换//Integer ai= new Integer(10);//int bi = ai.intValue();// //也可以简写，java支持自动转换//Integer ki =123;//int mi = ki;//数值-> String//int -> String//String s = String.valueOf(123);//String -> int//int a = Integer.valueOf("123");//为什么要设计这些包装类：//1. 提供一些用于转换的方法；//2. 将所有类型统一成类的范围，都是Object的子类//控制台//在上个世纪，在图形界面出现之前、一种基于文字的用户交互界面

AfConsole cf = newAfConsole();

cf.print("请输入用户名：");

String username= cf.readString("");

cf.print("请输入密码：");

String password= cf.readString("");if (password.equals("123456"))

{

cf.println(username+ "，你好！欢迎进入系统！");

}else{

cf.println("密码错误！");

}//随机数//Random 类是JDK里自带的基本类//java.util.Random//使用Random可以生成随机数//Random rand = new Random();//int s = rand.nextInt(1000);//nextInt(1000)表示生成一个0~1000 的随机数

Random rand = newRandom();for (i = 0; i < 3; i++)

{int sr = rand.nextInt(1000);

System.out.println("生成随机数：" +sr);

}//抽3个人获奖 ，不能重复

int[] resultr = new int[3];int count = 0;

Random rand2= newRandom();while (count < 3)

{//抽一个幸运员工。sra是它的号码

int sra = rand2.nextInt(95);//检查sra是否已经中过奖，检查sra是否在result里

boolean exist = false;for (i = 0; i < count; i++)

{if (resultr[i] ==sra)

{

exist= true;break;

}

}if(exist)

{continue;

}else{

resultr[count]=sra;

count++;

}

}//字符//一个字符 char c1 = 'A';//字符编码//地球上所有的文字和符号都有一个编码Unicode，其中，把 0 -128 之前的称为 ASCII码，仅英文、数字、英文标点符号等，对应键盘上的按键//字符与字符串//String -》 char//String str = "afanihao阿发你好";//char ch = str.charAt(8);//下标从0开始计数//char[] chs= str.toCharArray();//char -> String//char[] chs = {'阿','发'.'你'.'好'};//String str = new String(chs,1,3);//str += '的';//在字符串字符中查找字符//String str ="afanihao阿发你好";//int p = str.indexOf('发');//System.out.println("位置" + p);//容器:存储对象的东西//容器是一个设计上的术语，不是一个语法的概念//比如说，数组就是一个容器//链表： 一种组织数据的方式

Monkey m1 = new Monkey(100, "100");

Monkey m2= new Monkey(200, "200");

Monkey m3= new Monkey(300, "300");

Monkey m4= new Monkey(400, "400");

m1.next=m2;

m2.next=m3;

m3.next=m4;

m4.next= null;

Monkey node=m1;while (node != null)

{

System.out.println("链表中的节点：" +node);

node=node.next;

}//链表插入和删除节点//1.插入到末尾

Monkey m5 = new Monkey(500, "500");

m4.next=m5;//正规写法，从头开始

Monkey tail =m1;while (true)

{if (tail.next == null)break;

tail=tail.next;

}

tail.next=m5;//2.插到头节点之后

Monkey head =m1;

m5.next=m1.next;

m1.next=m5;//3.插到300 之后

node =m1;while (node != null)

{if (node.id == 200)

{

m5.next=node.next;

node.next=m5;break;

}

node=node.next;

}//插入节点//有头链表：用一个固定的加节点来充当头节点。//此节点不算作链表长度，仅用于简化算法//有头链表的构造//创建一个假节点，作为链表的头节点

Monkey head1 = new Monkey(0, "0");

head1.next=m1;//遍历

Monkey m =head1.next;while (m != null)

{

System.out.println("链表");

m=m.next;

}//有头链表：插入节点//直接插入假节点后面

m5.next =head1.next;

head1.next=m5;//有头链表：删除节点200

Monkey node1 =head.next;

Monkey prov=head1;while (node1 != null)

{if (node1.id == 200)

{

prov.next=node1.next;break;

}

prov=node1;

node1=node1.next;

}//或者采用如下

Monkey node3 =head1;while (node.next != null)

{if (node.next.id == 200)

{

node.next=node.next.next;break;

}

node=node.next;

}//链表只是容器的一种实现方法

}

}