第一个java程序
public class helloworld{
public static void main(string [] args
{
system.out.println("helloworld");
}
}
如果说我们要 将一个 long long 类型的 数输出 那么我们要在这个数的后面 加上 L;
2.第二个 关于java中数据的输入
import java.util.scanner; //被称为导包//
scanner sc = new scanner(system .in); // 输入//
int i = sc.nextInt();接受数据
那么匿名的接受咋办呢?
这样 : int num = new scanner(system.in).nextint();
如果要定义一个方法的话 可以将匿名的对象传进去
example :
public void method(new scanner(scanner sc) 或者是 (student s) 又或是(arraylist<student> array);
记住这这个地方是传进去了一个对象 相当于是 student s = new student() ;
scanner sc = new scaner ();
然后用键盘录入:
int i = sc.nextint();
*****那如果要调用 这个的方法的话就是下面这种写法
method(new scanner (system.in) )
接下来关于三个和尚的问题 进行输入和输入;
import java.util.scanner
class puclic example 01{
public static void main(string [] agrs)
{
scanner.sc = new sacnner (system.in);
int weight1 = sc.nextint();
int weight2 = sc.nextint( );
int weight3 = sc.nextint();
int max = weight1 > weight2 ? weight1 : weight;
int max_weight = max > weight3 ? max : weight2;
system.out.println("max_weight " );
}
3.
第3个 关于一个循环的应用
<1 import.java.uitl.scanner
class public example 02{
public static void main(string[] args)
{
scanner sc = new scanner(system.in);
int n = sc.nextint();
int hour ,minutes;
for(int i = 1;i<= n;i++)
for(int j =0;j<n;j++)
system.out.println(hour + "小时" + minutes + " 分" );
}
4.关于菱形在Java中的打印
import.java.util.sacnner
public class example06{
public static void main(string[] args){
scanner sc = new scanner(system.in);
int n = sc.newint();
for(int i=1;i<=n;i++)
{
for(int j = 1;j<=n-i;j++)
{
system.out.println(' ');
}
for(int j = 1;j< i * 2 ;j++)
{
system.out.println("*");
}
}
}
4 .关于一个随机数random
import.java.util.random
pubic calss example 03
{
public static void main(string [] args)
{
random r = new random();
int number = r.nextint(10) + 1; //获取一个数 从 0 - 10 的 数字//
for(int i=0;i<n;i++)
{
int number =r .random(100) + 1;
// 表示 从0 到 100 的 随机一个数 如果不加 1 的话 那么就表示 0 - 99 的随机一个 数
}
}
}
5.关于Java中 数组的定义方式
import java.util.scanner
public class example 04{
public static void main(string[] args)
{
scanner sc = new scanner(system.in);
int N = sc .nextint();
int M = sc .nextint();
int arr[] = new int [N];
}
<1 索引越界 和 <2 空指针异常
<1 即访问了本来不应该存在于数组中的 下标
报错 : array index out of bounder exception
<2 比如说
int arr = null;
system.out.println("arr[0]");
即会报错 : non pointer exception
、
<3 数组的常见操作
1. 遍历整个数组 可以用到 arr.length
2.关于我定义的这个数组 比如说 int [] arr 那么这个arr将会在栈中开辟内存空间
如果 我将 这个 数组 给它赋值 int [] arr = {0,10,29,93} 那么后面的这个数字将会开辟到 堆空间去 ;
6. 关于c++中的函数在Java中的 重命名 —— 方法
<1
import.java.util.scanner
puclic class example 05
{
public static void main(string[] args)
{
int x = sc.nextint();
if(isevennumber(x))
system.out.println("Yes");
else
system.out.println("No")';
}
public boollean isevennumber(x)
{
scanner sc = new scanner(system);
int n = sc.nextint();
for(int i=0;I<n;i++)
{
if(i % 2 ==0)
{
return true;
break;
}
return false;
}
}
}
<2
如果说 定义了一个返回值为 void 的 一个方法的话
那么我可以 return 但是 return 代表的是 我这个 放法已经调用完毕 下面如果 有其他语句将不能执行
<3
关于方法重载
意为 1.同一个类中
2 .所定义的方法的名字相同
3.但是其中的参数的数量 或者 参数的种类不同
<4
要记得 数组 是一个 特殊的指针 那么 他在 方法当中被调用的时候 就会 随着 方法中 数值的改变而改变
定义的 时候和 c++中是一样的
<5 关于java中数组的输出方式
< 1
system.out.println("") 表示的是 我打印出一个东西 会自动变行
system.out.print("") 表示的是 打印出一个东西 他不会自动变行
system.out.print() 表示的是 换行 直接换行 相当于 c++中的 cout<<endl;
关于查找一个数所在位置的 索引
import java .util.scanner
public class example06
{
public static void main(string [] args){
scanner sc = new scanner(system.in);
int x = sc.nextInt();
int N = sc.nextInt();
int [] arr = new int[N];
system.out.println(get_index(arr , x );
public static int get_index(int [] arr,int number)
· {
int index = -1;
for(int i = 0 ; i < arr.length;i++)
{
if(number = index)
index = number;
}
return index;
}
}
< 6 关于 一个简单的反转函数
import java .util . scanner
public class example07
{
public static void main(string[] args)
{
scanner .sc = new scanner(system.in);
int n = sc.nextint();
int [] arr1 = new int [n];
int [] arr2 = new int [n]; // 转换后的数组
reverse(arr1,arr2);
for(int i=0;i<arr2.length;i++)
system.out.print(arr[i] + ",");
// 这只是一个简单的循环
public static void reverse(int [] arr1,int [] arr2)
{
for(int st = 0,ed = length -1;st <= ed ;st ++,ed --)
{
int temp = arr1[st];
arr2[ed] = arr1[st];
arr1[st] = temp;
}
或者
// 简单的双指针算法
for(int i = 0,j = arr1.length -1;i <= j;i++ , j--)
{
arr2[j] = arr1[i];
}
或者
// 边指变算 随着指针的移动 依次 用 j++来进行 填冲数组的操作
for(int i=arr1.length-1;i >= 0;i--)
{
int j = 0;
arr2[j++] = arr1[i];
}
}
}
}
}
关于 在数组中的一个位置 插入一个 数
eg : 给定 一个数 12 将 这个数插入到 索引为 2 的地方
import java.util.scanner
public static void example 08{
public class void main(string[] args)
{
scanner sc = new scanner(system.in);
int s =sc. nextInt();
}
}
}
***关于 java 中的 对象 封装***
< 1
首先 创建对象 相当创建 一个类 这个类 是 非测试类 所以并不 需要 加 static void main
eg1: 创建一个学生类 和类方法
class student {
private 可以对于一个类中的 一个成员名 也可以对 一个类 直接用
eg :
对于一个成员变量: private age ;
对于一个类 private class test {
string name;
int age;
int score;
int rage;
public void query(){
system.out.print(student . age);
}
}
eg2:
测试类
public class studentText{
publiuc static void main(string[] args)
{
创建一个新的类
sudent s = new student();
student s2 = s;
然后就可以在下面 改 类中对象 的值 对对象进行一系列 的操作
}
对类进行封装 和 对这个类的使用是在 两个不同的 大括号里面的
下面我来演示一下
首先 先定义一个 类 对这个类进行 封装
eg:
class people {
string name;
private int age; // 对于人来说 年龄是不可访问的;
private int idenity; // 身份证号 也是不可被外人 得到的;
修饰完 成员变量后 即可以 对这个成员 进行调用
public void output(string name)
{
this.name = name; // 这里面使用 this.name 代表的是 上面的 全类变量
这里面的 this 是为了 防止 局部变量 隐藏成员变量
}
在这个地方也可以 直接使用构造方法 其实是 和 上面的 成员方法是一样的
eg:
public people(string name,int age)
{
this.name = name;
this.age = age;
}
public void setAge(int a)
{
age = a;
}
public int getAge()
{
return age;
}
}
下一个类用于测试 访问
public class example09
{
public static void main(string[] agrs)
{
people p = new people();
people p1 = new people();
p.setAge(18);
p.getAge();
}
}
******一个完整的学生类******
public class student
{
private string name;
private int age;
public student (string name,int age)
{
this.name = name;
this.age = age;
}
public void setname(string name)
{
this.name = name;
}
public string getname()
{
return neme;
}
public void set_age(int age)
{
this.age = age;
}
public int get_age(int age)
{
return age;
}
}
***一个完整的学生类已经构建好了***
***关于 API 的使用以及练习***
<1
第一个就是关于 导包的问题
import java.util.scanner
scanner sc = new scanner(system.in);
int n = sc.nextInt();
//这是生成了一个整数
//生成一个字符串是类似的
string line = newLine();
string s = new string();
第二个就是生成随机数
import java.util.random
random r = new random();
int number = r.newInt(100) + 1;
关于 string 的 学习
1. string 并不需要导包 因为它在 java.lang包下
string s = new string();
char [] s1 = {a,b,c};
string s2 = new string(s1);
*****关于equals
system.out.println(s2.equals(s1));
返回的 将是 boolean 值 true or false;
*****关于charAt 这个其实相当于 在 c++中的 a[I];
*****关于stringBulider
那么为什么要用stringBuilder 呢 因为 string 是不可以改变的 这个是可以改变的
不用导包 直接定义
stringBulider line = new stringBulider("Wang");
也可以
stringBuilder sb = new stringBuilder();
之后 直接 sc.append("wang"); 就可以了
后面可以一直加
***sc.append("100") 什么类型的都有 并且最后都会被 合成字符串;
那这样 就可以 引入一个
******链式编程*****
即 : sc.append("wang").append("100").append("love ");
stringBulider 当然也可以转换回string 通过 ***tostring*** 来实现
stringBuilder sb = new stringBuilder();
sb.append("wang");
string sc = sb.tostring();// 可以将 stringBuilder 转为string
那么同理 stringBulider 当然也可以 转换为 string
eg : string s ="hello";
stringBuilder str = new stringBuilder (s);
eg:
scanner sc = new scanner (system.in);
string str = sc.nextstr();
for(int i = 0 ;i < str.length;i++)
system.out.print(str.charAt(i) );
关于stringBulider 的 一个 reverse 方法
要求传进去的是 string 类型的 通过 stringbuilder 来reverse 然后在从 string 中 传出去
eg:
import java.utli.scanner
public class example 09
{
scanner sc = new scanner(system.in);
string line = nextline();
public static string reverse(string s)
{
先来个复杂的做法
stringBuilder sb = new stringBuilder(s);
sb.reverse();
string s1 = sb.tostring;
return s1;
下面来一个简单的
return new stringBuilder(s).reverse().tostring(); 从始至终都是stringBuilder 所以一直一个成员
、
首先先解释一下
一开始 先 创建一个 stringBuilder(s) 然后 在这个对象上 转化 在 将转换后的成员 变string类型的;
}
}
<1 下面来一个 模拟客户登录 的操作 *******
import java.util.scanner
public class example10
{
string username = “wangyinan”;
int password = 001121;
scanner sc = new scanner(system.in);
int n = sc.nextInt();
system.out;println("请输入您的姓名");
int name = sc.nextInt();
system.out.println("请输入您的密码");
int psd = sc.nextInt();
for(int i = 0;i < n;i++)
{
if(name.equals(username) && psd.equals(password))
{
system.out.println("登陆成功");
break;
}
else {
if(n - i == 0)
{
system.out.println("您的账户已被锁定");
else
system.out.println("您还有 + ”n - i" +次机会 ")
}
}
}
******关于ArrayList 集合的应用*****
eg:
public class example11
{
public void main(string args[])
{
ArrayList<string> array = new ArrrayList<string>();
后面的那个 string 可以不用加
如果想要定义一个基本数据类型的 array的话 那么 我需要 向其中传入 他的 原本的包 例如 arraylist<integer> = new arraylist<>;
1.Array.add Array.add("hello");
Array.add("world");
Array.add("javaee");
or Array.add(1,java); /// 即在索引为一的位置加入了java这个元素
2.Array.remove(int index) 删除指定位置的元素 并返回被删除的元素
Array.set(1,"love"); 将1索引位置的数改为 love; 并返回被修改的元素
Array.get(1); 得到 1索引出的位置
Array.size(); 返回集合的长度
}
}
******Array 集合可以和 类结合使用******
eg:
public class student
{
private string name;
private int age;
public student (string name,int age)
{
this.name = name;
this.age = age;
}
public void setname(string name)
{
this.name = name;
}
public string getname()
{
return neme;
}
public void set_age(int age)
{
this.age = age;
}
public int get_age(int age)
{
return age;
}
}
public class example12
{
public class void main(string args[])
{
ArrayList<student> array = new ArrayList<student>();
student s = new student("王伊楠",18);
student s1 = new student("叶凡",20);
array.add(s);
array.add(s1);
for(int i = 0;i<array.size();i++)
{
student s = array.get(i);
system.out.println(s.getname() + "," + s.getage);
}
}
}
or 如果需要自动录入的话
import java.util.scanner
public class example 13
{
public static void main(string args[]);
addstudent(array);
addstudnet(array);
addstudent(array);
public void addstudent()
{
scanner sc = new scanner(system.in);
string name = sc.nextLine();
int age = sc.nextInt();
student s = new student();
s.set_name ("name");
s.set_age(age);
array.add(s);
}
}
关于一个很简单的学生管理系统
首先 定义一个学生类
public class student
{
private string name;
paivate int age;
private string address;
private int id;
public student (string name,int age,string address,int id)
{
this name = name;
this age = age;
this address = address;
this id = id;
}
public void set_name(string name)
{
this name = name;
}
public string get_name()
{
return name;
}
以此类推 写出剩余的get 和 set 方法
}
打印主界面
import java.util.scanner
public class manger
{
public void main(string args[]) 这是main 方法 主操作
{
ArrayList<student> array = new ArrayList<student>();
system.out.println("1 添加学生");
system.out.println("1 删除学生");
system.out.println("1 修改学生");
system.out.println("1 查看所有学生");
system.out.println("1 退出");
scanner sc = new scanner(system.in);
string line = sc.nextLine();
whiel(true) /// 这是个死循环 选择一个界面后还可以选择其他界面
{
switch(line)
{
case "1" :
add student(array);
break;
case "2" :
system.out.println("修改学生')
break;
case "3" :
system.out.println("删除学生')
break;
case "4" :
system.out.println("查找所有学生')
break;
case "5" :
system.out.println("谢谢使用');
break;
system.exit(0); ********这个的意思是结束Java虚拟机的意思 直接退出界面*********///
}
}
}
}
}
1.添加学生
public void addstudent(ArrayList<student> areay)
{
scanner sc = new scanenr(system.in);
system.out.println("请输入学生学号");
int id = sc.nextIine();
system.out.println("请输入学生姓名");
string name = sc.nextLine();
system.out.println("请输入学生地址");
string address = sc.nextLine();
system.out.println("请输入学生年龄");
int age = sc.nextInt();
student s = new student();
s.set_name(name);
s.set_age(age);
s.set_address(address);
s.set_id (id);
将学生添加到集合中去
array.add(s);
}
2.查找学生
public void findstudent()
{
if(array.size() == 0)
{
system.out.println("请先录入信息在查询信息");
return ; // 和c++一样 都是推出这个方法;
}
for(int i = 0;i < arry.length();i++) 这个时候已经在 前面的main方法中已经定义了一个 array了 所以已经把所i有学生的信息全部储存了
{
student s = array.get(i); /// 拿出一个学生的信息
system.out.println(s.get_id() + “\t”+ get_name() + "\t" + .....);
}
}
删除学生信息
public void deletestudent(ArrayList<student>array)
{
scanner sc = new scanner(system.in);
int id = sc.nextInt();
for(int i = 0;i < array.size();i++)
{
student s = array.get(i);
if(s.get_id().equals(id);
{
array.remove(i);
break;
}
}
}
删除学生信息的话 有可能学生已经被使用过了 那么就可以用下标查询
public void is_used(arraylist<student> array,int id)
{
scanner sc = new scanner(system.in);
int id = sc.nextint();
int index = - 1;
for(int i = 0 ; i < array.size(); i ++)
{
student s1 = array.get(i);
if(s1.getid().equals(id))
{
index = i;
break;
}
if(index = -1)
{
system,out.ptintln("输入的学生信息不存在")
}
else
array.remove(i);
}
}
修改学生信息
public void upadate(arrayList<student> arraay)
{
scanner sc = new scanner(system.in);
system.out.println("请输入学生的信息");
int id = sc.nextint();
student s = new student();
system.out.prinltn("请输入学生的年龄")
int age = sc.nextint();
s.setage(age);
system.out.prinltn("请输入学生的姓名")
string name = sc.nextline();
s.setname(name);
system.out.prinltn("请输入学生的"住址")
string address = sc.nextline();
s.setaddress(address);
for(int i = 0 ; i < array.size(); i ++)
{
student s1 = array[i];
if(s1.getid().euqals(id))
array.set(s1,s);
}
}
*****继承******
猫和狗
首先先定义一个 动物类
class animals
{
private int age;
private string name;
public animals(); // 无参构造方法
public animals(int age,string name)
{
this.name = name;
this.age = age;
}
public void setage(int age)
{
this age = age;
}
public int getage()
{
return age;
}
public void setname(string name)
{
this.name = name;
}
public string getname()
{
return name;
}
}
class cats extends animals
{
private int age;
private string name;
public cats()
public cats(int age , string name)
{
this.age = age;
this.name = name;
}
public void catchmouse()
{
system.out.println("我能抓老鼠");
}
}
class dogs extends animals
{
基本上与上面是一样的
所以直接写点不一样的
public void lookhouse()
{
system,out.println("我可以看门");
}
}
最后定义一个测试类
public class demo
{
public static void main(string[] args)
{
cats c1 = new cats();
c1.setname("加菲猫");
c1.catchmouse();
}
}
*******关于权限修饰符
public 可以在任何地方被访问到
protected 只能在 同一个类 和 子类中 被访问
private 只能在同一个类中
void 默认 只要在同一个包内
********关于final 和 static
public final void method() 那么这个方法 就不能被重写了
public final class fu 那么就说明这个fu类不能被子类继承
private final age = 20; 那么在下面的方法中 就不能改变age 的 值
final student s = new student ();
s.age = 100; 这个时候final 修饰的 s 是一个类 是引用 不能被变 但是这个类中的成员
变量可以改变
static string university ;
student.university = "西安科技大学";
什么意思的呢 就是说 被static 修饰的成员变量可以被每一变量访问到 意思就是每一个人的
university 都是 西安科技大学; 即student 这个类中的任何一个成员变量在不给他赋值之之前
他们的值都是一样的
静态成员方法只能访问静态成员方法
****关于多态****
{
只能在继承关系中被使用
animal a = new cat();
上述即被称为 多态
}
关于 string 和 int之间的相互转化
< 1 int 转为 string
int number = 100;
string s = "" + 100;
或者
string s = string.valueof(number);
<2 string转为 int
先转换为 integer 然后 再转换为 int
string s = "100";
integer i = integer.valueof(s);
int x = i.intvalue();
或者 直接调用 integer 中的 parseint();
int i = integer.parseint(s);
一个简单的例题
string s1 = "100 29 93 83 28";
string arr[ ] = s1.spilt(" ");
int [] arr1 = new int [arr1.length] ;
for(int i = 0 ; i < arr1.length ; i++)
{
arr1[i] = integer.parseint(arr[i]);
}
装箱与拆箱
Integer i = Integer.valueof(100);
什么是装箱呢 ?
就是 将以个 int 型的值直接赋给 integer
Integer i = 100;
这时候的 100 就已经成为了Integer 类型了
i += 100;这个 i 是 integer 类型的 但是 我们在 赋值的过程中 直接可以将 一个 Int 类型的 值直接加到他的身上 这个就叫做拆箱