关于 java的学习 ——入门—— 较详细

最新推荐文章于 2024-07-18 09:20:04 发布

wyn66666

最新推荐文章于 2024-07-18 09:20:04 发布

阅读量690

点赞数 6

分类专栏：初学类文章标签： eclipse

本文链接：https://blog.csdn.net/m0_63699273/article/details/124505377

版权

初学类专栏收录该内容

1 篇文章 0 订阅

订阅专栏

第一个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）;

一个简单的例题