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

第一个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 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         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     {
      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            {
      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<

     关于查找一个数所在位置的  索引    

    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     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;  //  身份z号 也是不可被外人 得到的；
    
    修饰完 成员变量后 即可以  对这个成员 进行调用 
    
    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 array  =  new ArrrayList();
    后面的那个 string 可以不用加 
    如果想要定义一个基本数据类型的 array的话 那么 我需要 向其中传入 他的 原本的包 例如 arraylist  = 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 array = new ArrayList();

    student s = new student("王伊楠"，18);
    student s1 = new student("叶凡"，20)；

    array.add(s);
    array.add(s1);

    for(int i = 0;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 array = new ArrayList();
    
    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 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(ArrayListarray)
{
    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 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 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 类型的 值直接加到他的身上 这个就叫做拆箱