JAVA入门学习四

com.weiyigeek  #一般是域名倒着写多级包

#包的举例：
  # 学生：增加，删除，修改，查询
  # 老师：增加，删除，修改，查询

#从上面给出的案例我们可以有两种方案
#方案1：按照功能分
com.weiyi.add
  AddStudent
  AddTeacher

#方案2：按照模块分
com.hweiyigeek.teacher
  AddTeacher
  DeleteTeacher
  UpdateTeacher
  FindTeacher

package 包名;  #注意这里一般采用多级包用.分开即可
package com.weiyi.demo

#Step1.Java代码示例
package com.weiyi;  //字节码文件应该放入com/weiyi/路径中
class Demo1 {
  public static void main(String[] args)
  {
      System.out.println("Hello world! Java Package");
  }
}

#Step2.编译运行
> javac -encoding UTF-8 .Demo1.java
> mkdir com/weiyi
> copy Demo1.java com/weiyi/  #将编译生成的字节码文件复制到包路径中
> java com.weiyi.Demo1  #注意这里运行的时候需要包名+类名称
Hello world! Java Package

import java.util.Scanner
Scanner sc = new java.util.Scanner(System.in)

#com.weiyi 包
package com.weiyi;
public class Person {
  public String name;
  public int age;

  #构造方法
  public Person(){}
  public Person(String name,int age)
  {
    this.name = name;
    this.age = age;
  }
  
  public String getName(){
    return name;
  }
  public int getAge(){
    return age;
  }
} 

#com.demo 包
package com.demo;
public class Demo {
  public static void main(String[] args)
  {
    com.weiyi.Person p = new com.weiyi.Person("张三",23);  #注意这里是包名+类型进行调用其他包里 且类必须是公共类
    System.out.println(p.getName()+"---"+p.getAge());
  }
}

#编译步骤:
javac -encoding UTF-8 -d . Person.java  #先编译需要调用的包和类文件
javac -encoding UTF-8 -d . Demo.java  #在编译主函数类
java com.demo.Demo   #执行编译后的java文件注意任然带上包名称+类名称
张三---23

package com.weiyigeek;
//import java.util.*;  //*通配符会到该包下挨个匹配上就导入,即该包下的所以类都是对我们可见的;
import java.util.Scanner;  //推荐方式(开发中都是导入具体类)
class Package_import {
  public static void main(String[] args)
  {
    System.out.print("[导包学习]n请输入您的名字:");
    Scanner sc = new Scanner(System.in);
    String name = sc.next();
    System.out.println("您的名字是:"+name);
  }
}

//#执行结果
[导包学习]
请输入您的名字:WeiyiGeek
您的名字是:WeiyiGeek

//#com.weiyi  (外部包类)
package com.weiyi;
//#注意这里的修饰权限
public class Demo1 {
   private String love;
   public Demo1(){}
   public Demo1(String love){
     this.love = love;
   }
   public String getLove(){
     return love;
   }
   //#关键点 （protected）的修饰符
   protected void print(){
     System.out.println("这里是不能被不同包下的无关类访问的!");
   }
}

//com.weiye (集成外部包的类)
package com.weiye;
import com.weiyi.Demo1; //#注意这里需要导包使用
//#继承其他包里面类
public class Demo2 extends Demo1 {
  public Demo2(){}
  public Demo2(String love){
    //引用父类构造方法
    super(love);
  }

  public void method(){
    System.out.println("外部包继承类,访问父类中protected受保护的print方法!");
    print();
  }
}


//com.main (入口类)
package com.main;
import com.weiyi.Demo1;
import com.weiye.Demo2;
class Demo3 {
  public static void main(String[] args)
  {
    //示例1.不同包下(无关类)不能访问外部包下的除了public修饰的类和方法
    Demo1 demo1 = new Demo1("计算机");
    demo1.getLove();
    //demo1.print()  #将会报错由于不同包下的无关类不能调用外部包里面受保护的类


    //示例2.不同包下(继承子类)可以访问外部包下受保护的类protected
    Demo2 demo2 = new Demo2("运动");
    demo2.method();     //关键点
}

[[email protected] F:Study-PromgramJAVADemosrc]$javac -encoding utf-8 -d . Demo1.java
[[email protected] F:Study-PromgramJAVADemosrc]$javac -encoding utf-8 -d . Demo2.java
[[email protected] F:Study-PromgramJAVADemosrc]$javac -encoding utf-8 -d . Demo3.java

$java com.main.Demo3
外部包继承类,访问父类中protected受保护的print方法!
这里是不能被不同包下的无关类访问的!

// 键盘输入案例
import java.util.Scanner; //导入包
class Demo_Input {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);  //#实例化Scanner类eclipse控制器输入输出类型
        System.out.print("请输入一个整数a: ");
        int x = sc.nextInt();   //将键盘输入的值存储进入到x中 （整形）
        System.out.print("请输入一个整数b: ");
        int x1 = sc.nextInt();
        System.out.print("请输入您的名字：");
        String n = sc.next(); //字符串类型
        System.out.println("名字为"+n+" ,a + b = "+(x+x1));
        sc.close();  //释放内存
    }
}
//########### 执行案例 ###############
// 请输入一个整数a: 110
// 请输入一个整数b:120
// 请输入您的名字：WeiyiGeek
// 名字为WeiyiGeek ,a + b = 230

import static 包名….类名.方法名;  #可以直接导入到方法的级别

#基础实例
import static java.util.Arrays.sort; #静态导致

#可以直接调用
int[] arr = {11,588,687,47,10}
sort(arr);  #//直接使用静态方法名称即可

class Demo_InnerClass {
  public static void main(String[] args)
  {
    //示例1.外部类要访问内部类必须是 外部类.内部类 来创建对象 (内部类极其访问特点)
    Outer.Inner demo = new Outer().new Inner(); //内部类对象 (关键点)
    demo.method();  //调用内部类方法

    //实例2.其他类无法访问外部类中私有成员内部类
    //Outer.PriInner demo1 = new Outer().new PriInner();   //会报错

    
    //实例3.可以采用Outer类中的公用方法，调用其私有内部类中的方法;
    Outer demo2 = new Outer();
    demo2.print();


    //实例4.实例化外部类中的静态成员内部类
    //外部类.内部类 对象名称 = new 外部类.内部类对象;
    Outer.StaInner demo3 = new Outer.StaInner(); //关键点
    demo3.method();
    //还有一种情况静态的内部类和内部类中的静态方法
    Outer.StaInner.print();
  }
}

//关键点：创建内部类
class Outer {
  //内部类可以看做外部类的成员
  private int number=1024;
  //(1)内部类的 公共(默认)
  class Inner {
    public void method(){
      System.out.println("内部类: 类中类!n"+"内部类可以访问外部类的私有成员number:"+number);
    }
  }

  //(2)内部类的 私有
  private class PriInner{
    public void method(){
      System.out.println("私有内部类的公共方法n"+"外部类是无法访问的,除非为本类公共方法调用！");
    }
  }
  //本类的公共方法
  public void print(){
    System.out.println("私有内部类: 外部类中的公共方法 - 调用私有的内部类里面的方法");
    PriInner i = new PriInner();
    i.method();
  }

  
  //############ 分割 #############
  //(3)静态内部类
  static class StaInner {
    public void method(){
      System.out.println("静态内部类: 以进入内部类之中");
    }
    //还有一种:静态内部类中的静态方法
    public static print(){
      System.out.println("静态内部类: -> 静态方法");
    }
  }
}

//###执行结果#####
公共内部类: 类中类!
内部类可以访问外部类的私有成员number:1024

私有内部类: 外部类中的公共方法 - 调用私有的内部类里面的方法
私有内部类的公共方法
外部类是无法访问的,除非为本类公共方法调用

静态内部类: 以进入内部类之中
静态内部类: -> 静态方法

//内部类之所以能获取到外部类成员，是因为他可以获取到外部类的引用外部类名.this
class InnerClassTest {
  public static void main(String[] args) {
    Outer.Inner oi = new Outer().new Inner();
    oi.show();  //调用内部中的方法
  }	
}
//要求：使用已知的变量在控制台输出30，20，10。
class Outer {
  public int num = 10;
  class Inner {
    public int num = 20;
    public void show() {
      int num = 30;
      //关键点
      System.out.println(num);            //(1)就近原则方法中的变量;
      System.out.println(this.num);       //(2)类中的成员变量
      System.out.println(Outer.this.num); //(3)外部类.成员变量
    }
  }
}

//#####局部内部类访问局部变量的问题#####
class Demo_localInnerClass {
    public static void main(String[] args)
    {
        Outer o = new Outer();
        o.method();
    }
}

//外部类
class Outer {
    //公共的成员方法
    public void method() {
        final int number = 1024;
        //外部类中的成员方法声明的类,我们叫做局部内部类;
        class Inner {
            public void print(){
                System.out.println("局部内部类(调用方法中的成员变量必须加上final使之成为常量)："+number);
            }
        }
        //局部内部类的调用必须在同一个成员方法中实例化
        Inner i = new Inner();//局部内部类,只能在其所在的方法中访问;
        i.print();
    }
}

//#执行结果
E:githubProjectStudy-PromgramJAVADemosrc>javac -encoding UTF-8 Demo_localInnerClass.java
E:githubProjectStudy-PromgramJAVADemosrc>java Demo_localInnerClass
局部内部类(调用方法中的成员变量必须加上final使之成为常量)：1024

//new 类名() 继承这个类
//new 接口名() 实现这个接口（重写方法）
new 类名或者接口名(){
  重写方法;
}

class AnonmouseInnerClass {
  public static void main(String[] args)
  {
    System.out.println("Hello World!");
    Outer demo = new Outer();  //外部类
    demo.method();  //调用匿名内部类

  }
}

//匿名类实现的接口
interface Inter {
  public void show1();
  public void show2();
}

//匿名类的外部类
class Outer {
  //建立一个公共的方法,匿名内部类重写多个方法调用
  public void method(){
    //简化版的内部类(匿名内部类)
    new Inter() {
      //重写实现接口中第一个方法
      public void show1() {
        System.out.println("匿名内部类: 重写实现接口中第一个方法");
      }
      //重写实现接口中第一个方法
      public void show2() {
        System.out.println("匿名内部类: 重写实现接口中第二个方法");
      }
    }.show1();  //方式1(关键点)实现两个方法输出需要上面这块代码重写一次;

    
    //方式2:此种方法存在弊端
    Inter i = new Inter(){
       public void show1() {
        System.out.println("匿名内部类: 重写实现接口中第一个方法");
      }
      //重写实现接口中第一个方法
      public void show2() {
        System.out.println("匿名内部类: 重写实现接口中第二个方法");
      }
      /** 弊端的产生:写一个自定义的方法
      public void show3() {
        System.out.println("匿名内部类: 自定义的方法");
      }
      **/
    };  //注意此处需要 ";"

    i.show1(); //编译看接口中定义的show1方法,运行看子类中的show1方法
    i.show2(); //编译看接口中定义的show2方法,运行看子类中的show2方法
    //i.show3(); //这里不能采用这样的形式由于编译看父类接口中定义的方法，而接口中没有这样的方法，所以会产生错误;
    //如果向下强转需要与子类的类名,而这里是匿名内部类;
  }
}

$javac -encoding UTF-8 AnonmouseInnerClass.java
$java AnonmouseInnerClass
Hello World!
匿名内部类: 重写实现接口中第一个方法
匿名内部类: 重写实现接口中第一个方法
匿名内部类: 重写实现接口中第二个方法

class Demo_AnonmouseClass {
  public static void main(String[] args){
      //实例1.调用PersonDemo中的method方法
      PersonDemo pd = new PersonDemo();
      pd.method(new Student());

      //实例2.匿名内部类实现参数传递
      pd.method(new Person(){
          public void show() {
              System.out.println("匿名内部类的调用!");
          }
      });
  }
}

//抽象类(abstract)或者接口(interface)都可以;
abstract class Person {
  public abstract void show();
}
//有名称的类
class PersonDemo {
  public void method(Person p)  //Person p = new Student
  {
    p.show();
  }
}
//继承重写
class Student extends Person {
  public void show(){
    System.out.println("有名称的类");
    System.out.println("有名称的类型调用!");
  }
}

src> javac -encoding UTF-8 Demo_AnonmouseClass.java
src> java Demo_AnonmouseClass
有名称的类
有名称的类型调用!
匿名内部类的调用!

class Demo_AnonmouseInnerClass1 {
    public static void main(String[] args){
    //方式1：由于show方法是静态
    //链式编程每次调用方法后还能继续调用方法,证明调用方法返回的是对象;
    Outer.method().show();

    //方式2:强制转换
    Inter i = Outer.method();
    i.show();
    }
}

//匿名内部类要实现的接口
interface Inter {
    void show();
}

//外部类
class Outer {
    public static Inter method() {
        //注意这里返回的是一个匿名内部类，将重写接口方法（相当于是一个子类）
        return new Inter(){
            public void show() {
                System.out.println("匿名内部类的面试题!");
            }
        };
    }
}

javac -encoding utf-8 Demo_AnonmouseInnerClass1.java
java Demo_AnonmouseInnerClass1
匿名内部类的面试题!
匿名内部类的面试题!

public class Object
Class Object是类Object结构的根。每个班都有Object作为超类,所有对象（包括数组）都实现了这个类的方法。

public int hashCode() 返回对象的哈希码值。 
#Object的hashCode()默认是返回内存地址的，但是hashCode()可以重写，所以hashCode()不能代表内存地址的不同
System.identityHashCode(Object)  #方法可以返回对象的内存地址,不管该对象的类是否重写了hashCode()方法。

public final class getClass()  #返回此Object的运行时类。 
#返回的类对象是被表示类的static synchronized方法锁定的对象。

实际结果的类型是Class<? extends |X|>其中|X|是静态类型上其表达的擦除getClass被调用
#可以通过Class类中的一个方法，获取对象的真实类的全名称 public String getName()

public String toString()  #返回该对象的字符串表示,由于默认情况下的数据对我们来说没有意义，一般建议重写该方法。

public String toString() {
  return getClass().getName() + "@" + Integer.toHexString(hashCode());
  #左边类名 @ hashcode的十六机制整数
}

public boolean equals(Object obj)  #指示其他某个对象是否与此对象“相等”。 

equals方法在非空对象引用上实现等价关系：
自反性：对于任何非空的参考值x,x.equals(x)应该返回true 。
它是对称的：对于任何非空引用值x和y, x.equals(y)应该返回true当且仅当y.equals(x)回报true 。
传递性：对于任何非空引用值x,y和z,如果x.equals(y)回报true个y.equals(z)回报true ，然后x.equals(z)应该返回true 。
它是一致的: 对于任何非空引用值x和y,多次调用x.equals(y)始终返回true或始终返回false ，没有设置中使用的信息equals比较上的对象被修改。对于任何非空的参考值x ， x.equals(null)应该返回false 。

public class Demo2 {
  public static void main(String[] args) {
    //示例1：hashCode() 的使用
    Object obj1 = new Object();
    System.out.println("Object 对象："+obj1.hashCode());
    System.out.println("Object 对象地址："+System.identityHashCode(obj1));
  
    //示例2.getclass() 的使用
    Person g = new Person(1,"WeiyiGeek");
    Class demo = g.getClass(); //获取对象的字节码文件
    System.out.println("Person 类名称:"+demo.getName()); //获取类名称

    //示例3.toString() 的使用
    String info = g.toString();
    System.out.println(info);
    System.out.println(g); //如果直接答应对象的引用，会默认调用toString方法
    
    
    //示例4.equals() 的使用
    //Object中的equals方法比较对象的地址值,没有什么意义，我们需要重写他；
    //因为在开发中我们通常比较对象中的属性值,我们认为相同属性是同一对象,这样我们就需要重写他;
    Person g1= new Person(1,"WeiyiGeek");
    System.out.println(g1.equals(g));  //实际还是采用下面==方式比较,但我们对方法进行了重写
    System.out.println(g1 == g );  //如果equals
  }

}

class Person {
  public String name;
  public int num = 1;
  public Person() {
    super();
  }
  public Person(int num,String name) {
    this.num = num;
    this.name = name;
  }
  //关键点1
  @Override
  public String toString() {
    System.out.println("重写toString方法：num = "+num);
    return super.toString();
  }
  //关键点2 : 重写object中的equals方法
  @Override
  public boolean equals(Object obj) {
    //向下转型
    Person s = (Person)obj;
    return this.name.equals(s.name) && this.num == s.num;
  }
}

#示例1：hashCode() 的使用
Object 对象：366712642
Object 对象地址：366712642

#示例2.getclass() 的使用
Person 类名称:Person

#示例3.toString() 的使用
重写toString方法：num = 1
[email protected]
重写toString方法：num = 1
[email protected]

#示例4.equals() 的使用
true
false