#### hello
执行 javac Hello.java 生成 Hello.class
```
// Hello 要与文件名相同
public class Hello{
// 程序执行的起点
public static void main(String[] args){
System.out.print("Hello world");
}
}
```
#### 数据类型
1.基本类型
整数型 byte short int long
浮点型float double
字符 char
布尔boolean
2.引用数据类型
字符串 数组 类 接口
#### 关键字/标识符/常量
```
关键字
标识符
不使用数字开头
常量
字符串常量 双引号 'aaaaa'
整数常量
浮点数常量
字符常量 单引号引起来的 只能有一个 'a' 'b'
布尔常量 true false
空常量 null
```
#### 变量
* 变量名称不能重复
* float和long类型变量 F L 不能丢
* byte short 数值不能超过范围
* 没有赋值的变量不能直接使用
* 变量使用不能超过作用域范围
```
public class Bianliang{
public static void main(String[] args) {
int num1,num2;
// int num1=1,num2=2;
num1 =10;
num2 = num1 +10;
System.out.println(num2);
System.out.println("-----------");
byte num3 = 30;
System.out.println(num3);
short num4 = 10;
System.out.println(num4);
long num5 = 20000;
System.out.println(num5);
float num6 = 2.5F;
System.out.println(num6);
double num7 = 2.5F;
System.out.println(num7);
char zf1 = 'A';
System.out.println(zf1);
boolean var1 =true;
System.out.println(var1);
}
}
```
#### 类型
自动转换
* 从小->大
强制转换
int num=(int)100L;
(要转换的类型)范围大的数据
* 注意:
强制使用不推荐使用
#### 运算符
```
加减乘除取余
+
-
*
/
%
自增自减
++ --
赋值运算符
=
+=
-=
*=
/=
%=
比较运算符
==
<
>
<=
> =
! =
逻辑运算符
&& 与
|| 或
! 非
三元运算符
数据类型 变量名称=条件判断?表达式a:表达式b
```
#### 方法
```
public static void 方法名称(){
}
```
```
public class Fangfa{
public static void main(String[] args) {
//调用方法
farmer();
}
// 定义方法
public static void farmer(){
System.out.println("111");
System.out.println("222");
System.out.println("333");
}
public static void coo(){
System.out.println("cook");
System.out.println("321");
System.out.println("123");
}
}
```
#### 流程(if/switch/for/while)
```
if(表达式){
}else{
}
if(表达式){
}else if(表达式){
}else{
}
switch(表达式){
case 常量值:
语句体;
break;
default:
语句体;
break;
}
for(;;){
}
while(条件判断){
}
do{
}while(条件判断);
```
#### 方法调用
方法调用:
1. 单独调用
2. 打印调用
3. 赋值调用
重载
```
名称相同,
1. 参数列表不同
2. 参数类型不同
```
```
public class Fangfa0111{
public static void main(String[] args) {
int a=1;
int b=2;
System.out.println("-----");
System.out.println(summ(a, b));//两数相加
System.out.println(sum_lian(100));//1-某数的之和
get_num_hello(5);
}
public static int summ(int a,int b){
int c = a+b;
return c;
}
public static int sum_lian(int a){
int c=0;
for(int i=0;i<=a;i++){
c = c+i;
}
return c;
}
public static void get_num_hello(int a){
for(int i=1;i<=a;i++){
System.out.println("Hello");//1-某数的之和
}
}
// 重载(名称相同,参数列表不同)
public static int cz_sum(int a,int b){
int c = a+b;
return c;
}
public static int cz_sum(int a,int b,int c){
int dd = a+b+c;
return dd;
}
public static int cz_sum(int a,int b,int c,int d){
int dd = a+b+c+d;
return dd;
}
}
```
#### 数组arr
1. 是一种引用数据类型
2. 数组中的多个数据,类型必须统一
3. 数组长度不可改变
初始化
1. 动态初始化(指定长度)
2. 静态初始化(指定内容)
数据类型[] 数组名称 = new 数据类型[数据长度]
```
public class Arr{
public static void main(String[] args) {
// 动态初始化
int[] arrayA = new int[300];
double[] arrayB = new double[10];
String[] arrayC = new String[5];
//静态初始化
int[] arrayD = new int[] {1,2,4,5,6,7};
int[] arrayE = {1,2,4,5,6,7};
//读取
System.out.println(arrayE[1]);
//赋值
arrayA[1] = 50;
System.out.println(arrayA[5]);//默认0 '' 0.0
System.out.println(arrayA[1]);//50
//获取长度
System.out.println(arrayD.length);
//数组遍历
for(int i=0;i<=arrayD.length;i++){
System.out.println(arrayD[i]);
}
//数组的最值
//数组反转(使用第三方)
}
public static void get_sum(int[] arrayA){
}
}
```
#### object
导入包
import 包名称.类名称
如果同目录下不用写
Student stu = new Student()
stu.a
stu.a()
```
public class Obj{
public static void main(String[] args) {
int[] arrayD = new int[] {1,2,4,5,6,7};
// System.out.println(arrayD.toString());
Student stu = new Student();
stu.aa();
System.out.println(stu.bb);
}
}
```
#### random
random 随机数
int r = rand.nextInt();随机生成正负
int r2 = rand.nextInt(10);//0-9
```
public class Random1{
public static void main(String[] args) {
// 生成随机数()
Random rand = new Random();
int r = rand.nextInt();
System.out.println("随机数是:"+r);
int r2 = rand.nextInt(10);
System.out.println("随机数是:"+r2);//0-9
}
}
```
#### scanner
键盘输入
1.导包
import
2.创建
3.使用
```
import java.util.Scanner;
public class Scann{
public static void main(String[] args) {
String str = "dsds";
//创建
Scanner sc = new Scanner(System.in);
//使用
//获取键盘输入数据
// int num = sc.nextInt();
// System.out.println(num);
//求两个数的和
System.out.print("请输入num1:");
int num1 = sc.nextInt();
System.out.print("请输入num2:");
int num2 = sc.nextInt();
int c = num1+num2;
System.out.println(c);
}
}
```
#### arraylist idea
```
import zf.com.Student;
import java.util.ArrayList;
/**
arraylist 使用
1. 自定义学生类
2. 创建集合 ,用来存学生对象
3. 根据类创建4个学生对象
4.将4个学生对象加到 add
5.遍历集合 for size get
*/
public class Arraylist_demo {
public static void main(String[] args) {
ArrayList<Student> list = new ArrayList<Student> ();
Student one = new Student("a",20);
Student two = new Student("b",22);
Student three = new Student("c",24);
Student four = new Student("d",25);
list.add(one);
list.add(two);
list.add(three);
list.add(four);
for (int i = 0; i < list.size(); i++){
Student stu = list.get(i);
System.out.println("姓名:"+stu.getName()+",年龄:"+stu.getAge());
}
}
}
```
```
import java.util.ArrayList;
/**
Arraylist
System.out.println(list);//[aa, bb, cc]
printList(list);//{aa@bb@cc}
*/
public class Arraylist_demo1 {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<String> ();
list.add("aa");
list.add("bb");
list.add("cc");
System.out.println(list);//[aa, bb, cc]
printList(list);//{aa@bb@cc}
}
/**
定义方法三要素
1.返回值名称
2.方法名称
参数列表
*/
public static void printList(ArrayList<String> list){
System.out.print("{");
for (int i = 0; i < list.size(); i++){
String name = list.get(i);
if(i==list.size()-1){
System.out.print(name);
System.out.print("}");
break;
}
System.out.print(name+"@");
}
}
}
```
```
import java.util.Random;
import java.util.ArrayList;
/**
一个大集合存入20个随机数字,筛选其中偶数元素,
放入小集合中
*/
public class Arraylist_demo2 {
public static void main(String[] args) {
ArrayList<Integer> list = new ArrayList<Integer> ();
Random r = new Random();
for (int i = 0; i < 20; i++) {
list.add(r.nextInt(100+1));
}
ArrayList<Integer> smallList = getsmalllist(list);
System.out.println(smallList);
System.out.println(smallList.size());
}
/**
* 接受大集合,返回小集合
*/
public static ArrayList<Integer> getsmalllist(ArrayList<Integer> biglist){
ArrayList<Integer> smalllist = new ArrayList<Integer> ();
for (int i = 0; i < biglist.size(); i++) {
int num = biglist.get(i);
if (num %2==0){
smalllist.add(num);
}
}
return smalllist;
}
}
```
```
import zf.com.Person;
import java.util.ArrayList;
/**
定义一个数组,用来存储3个Person对象
数组缺点:一旦创建,长度不可改变
ArrayList 集合
ArrayList<Integer> list = new ArrayList<Integer> ();
<> 泛型 定义数据的类型
长度可随意改变
ArrayList 打印,直接是值
向集合中加数据 .add
获取数据 .get
删除 .remove
获取长度 .size()
*/
public class Arraylist_person {
public static void main(String[] args) {
Person[] array = new Person[3];
Person one = new Person("'迪丽热巴'",18);
Person two = new Person("'鹿晗'",23);
Person three = new Person("'陈赫'",22);
array[0] = one;
array[1] = two;
array[2] = three;
System.out.println(array[0]);//地址值
System.out.println(array[1]);
System.out.println(array[2]);
System.out.println(array[0].getName());//'迪丽热巴'
ArrayList<String> list2 = new ArrayList<> ();
list2.add("aa");
list2.add("bb");
list2.add("cc");
System.out.println(list2);
}
}
```
```
import java.util.Scanner;
/**
输入一个字符串,统计各种字符串出现的次数
1. 输入Scanner
2.键盘输入的字符串 String str = sc.next()
3.定义四个变量,用来代表各种字符穿心的次数
4.对字符串一个个进行检查 String->char[] 方法: toCharArray()
5.遍历char[] 进行判断
6.打印出现的次数
*/
public class Scanner_test {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.print("请输入一个字符串");
String input = sc.next();
int dx = 0;
int xx = 0;
int sz = 0;
int qt = 0;
char[] charArray= input.toCharArray();
for (int i = 0; i <charArray.length; i++ ){
char c =charArray[i];
if ('A'<=c && c<='Z' ){
dx++;
}else if ('a'<=c && c<='z'){
xx++;
}else if ('0'<=c && c<='9'){
sz++;
}else {
qt++;
}
}
System.out.println("大写字母有:"+dx);
System.out.println("小写字母有:"+xx);
System.out.println("数字有:"+sz);
System.out.println("其他有:"+qt);
}
}
```
#### static
```
import zf.com.Static_t;
import java.util.Arrays;
/**
* Arrays工具类
Arrays.sort(arr1); 排序
toString(数组) 数组->字符
sort 排序 (小到大)
*/
public class Static_demo {
public static void main(String[] args) {
Static_t a = new Static_t();
Static_t b = new Static_t();
String str = "sdijsncdkncksdmco324";
char[] arr1 = str.toCharArray();
Arrays.sort(arr1);
for (int i = 0; i < arr1.length; i++) {
System.out.println(arr1[i]);
}
}
}
```
#### string
```
/**
String字符串类
equals 比较
equalsIgnoreCase 比较 忽略大小写
length 长度
concat 拼接字符串相当于+
charAt 获取指定索引位置的单字符
indexof 字符串首次出现的位置
substring 截取
tocharArray() 字符串改为字节数组
getBytes() 当前字符串底层的字节数组
replace 替换
split 切割 字符串->数组
数组->字符串
*/
public class String_test {
public static void main(String[] args) {
String a = "Hello";
String b = "Hello";
String c = "hello";
String d = "hello,asasakndsknd,k4ji2o3n435no4n532o532";
System.out.println(a.equals(b));//true
System.out.println(a.equals(c));//false
System.out.println(a.equalsIgnoreCase(c));//true 忽略大小写
System.out.println(a.length());
System.out.println(a.concat("'aaaa'"));//Hello'aaaa'
System.out.println(a.charAt(2));//l
System.out.println(a.indexOf("o"));//4
System.out.println(d.substring(5));// asasakndskndk4ji2o3n435no4n532o532
System.out.println(d.substring(5,10));// asas
// cahr[] aa = d.toCharArray();
String dd = d.replace("hello","mc");
System.out.println(dd);
System.out.println("-----");
String[] arr1 = d.split(",");
System.out.println(arr1.length);
System.out.println(arr1[1]);
}
}
```
#### 面向对象
面向对象
封装/继承/多态
继承
1. 单继承
2. 多级继承
```
public class Demo {
public static void main(String[] args) {
Zi zi = new Zi();
zi.show();
zi.method();
}
}
```
#### 继承
```
public class Zi extends Fu{
int num = 20;
//重写方法
@Override
public void method() {
super.method();//调用父类的
System.out.println("子类方法");
}
public void show() {
int num = 30;
System.out.println(num);//30 当前
System.out.println(this.num);//20 子类的
System.out.println(super.num);//10 父类的
}
}
```
#### Math
Math.abs(double num) 取绝对值
.ceil 向上取整
.floor 向下取整(抹零)
.round 四舍五入
PI 圆周率
```
public class MathTest {
public static void main(String[] args) {
double min =-10.8;
double max =5.9;
for (int i = (int) min ; i < max; i++) {
int abs = Math.abs(i);
if (abs > 6 || abs < 2.1){
System.out.println(i);
}
}
}
}
```
#### 抽象方法
抽象方法
abstract
抽象类和方法的使用
1. 不能直接创建new抽象对象
2. 必须用一个子类继承父类抽象父类
3.子类覆盖重写父类当中的抽象方法 去掉abstract关键字
4. 创建子类对象进行使用
final 最后赋值
```
public abstract class Chouxiang {
//抽象方法
public abstract void eat();
}
```
public > protected > default > private
