从0基础开始学习Java第4天

今天学习的东西也是挺多的，通过学习新东西，让自己每天都很充实，感觉玩游戏的日子真的是太无聊了，现在感觉就不错，通过谢谢小程序，让自己有成就感。
1、equals
equals可以通过重写，去实现判断相等的条件，
而==若指对象，则判断地址是否相同，若是数值，就直接比较数值

public class TestEqual {
 public static void main(String[] args) {
 Object obj;
  String str; 
  User u1=new User(110, "小明","abcabc" );
  User u2=new User(110, "小红", "cbdcbd");
  System.out.println(u1==u2);
  System.out.println(u1.equals(u2)); 
  String str1=new String();
  String str2=new String();
  System.out.println(str1==str2);
  System.out.println(str1.equals(str2)); 
  }
}
class User{
 int id;
 String name;
 String pwd;
 public User(int id, String name, String pwd) {
  super();
  this.id = id;
  this.name = name;
  this.pwd = pwd;
 }
 //重写equals
 @Override
 public boolean equals(Object obj) {
  if (this == obj)
   return true;
  if (obj == null)
   return false;
  if (getClass() != obj.getClass())
   return false;
  User other = (User) obj;
  if (id != other.id)
   return false;
  return true;
 } 
}

这个程序将object根类里面的equals进行了重写，可以实现自己想要的功能。

2、类的继承
类的继承使用extends关键词。
子类可以继承父类的所有东西但是不一定都能用。我的理解是，内存空间中分为三个部分，栈，堆，方法区。
其中方法区是用来存放类的，包括类的静态属性，静态方法，常量等等。当子类继承父类时，父类的这些东西都被子类继承，就想集合的关系，父类包含于子类，子类包含父类，父类是范围小的那一个，但不是父类所有的东西，子类都可以用，例如被private关键词修饰的就不能被子类使用。

public class TestExtends {
 public static void main(String[] args) {
  Student stu=new Student();
  stu.name="小明";
  stu.height=175;
  stu.rest();
  Student stu2=new Student("小红",160,"电子信息");
  stu2.study();
  System.out.println(stu2 instanceof Student);
  System.out.println(stu2 instanceof Person);
  System.out.println(stu2 instanceof Object);
  System.out.println(new Person() instanceof Student);
  }
}
class Person{
String name;
 int height;
 public void rest() {
  System.out.println("每天11点睡觉！");
 }
}
class Student extends Person
{
 String major;
 public void study() {
  System.out.println("每天学习Java!");
 }
 public  Student() {
 }
 public  Student(String name,int height,String major) {
  this.name=name;
  this.height=height;
  this.major=major;
 }
 }

3、object根类
所有的类都是源自object根类来的，可以说，object是所有类的祖宗了。做个小实验，重写根类里面的toString()方法。

public class TestObject {
 public static void main(String[] args) {
  TestObject to=new TestObject();
  System.out.println(to.toString());
  Persion2 p2=new Persion2("小明", 18);
  System.out.println(p2.toString());
 }
   public String toString() {
         return "重写根类Object的toString()方法";
     }
}
class Persion2{
 String name;
 int age;
 @Override
   public String toString() {
        return name+"年龄："+age;
    }
    public  Persion2(String name,int age) {
  this.name=name;
  this.age=age;
 }
}

4、方法的重写
忽然才发现，我写的顺序有问题，不过不想改了，写CSDN的博客感觉很麻烦，传代码都只能一小段一小段的复制。

public class TestOverride {
 public static void main(String[] args) {
  Horse hurse=new Horse();
  hurse.run();
 }
}
class Vehicle{
 public void run() {
  System.out.println("跑。。。");
 }
 public void stop() {
  System.out.println("停。。。");
 }
 public Person whoIsPsg() {
  return new Person();
 }
}
class Horse extends Vehicle{
 public void run() {//重写要保持方法名、形参一致
  System.out.println("用4个蹄子跑。。。");
 }
 //子类返回值小于或等于父类可以
 public Student whoIsPsg() {
  return new Student();
 }
 //子类返回值大于父类不行
 //public Object whoIsPsg() {
  //return new Object();
 //}
 }

5、super
super是直接父类对象的引用。可以通过super来访问父类中被子类覆盖的方法或属性.

public class TestSuper {
  public static void main(String[] args) {
   new ChildClass().f();
  }
}
class FatherClass{
 public int value;
 public void f(){
  value=100;
  System.out.println("FatherClass.value="+value);
 }
}
class ChildClass extends FatherClass{
 public int value;//
 public void f() {//重写了父类的f方法
  super.f();//访问父类的f方法
  value=200;
  System.out.println("ChildClass.value="+value);
  System.out.println(value);
  System.out.println(super.value);//访问父类的属性
 }
}

还有一个小例子

public class TestSuper02 {
 public static void main(String[] args) {
  System.out.println("开始创建第一个ChildClass对象");
  new ChildClass2();
 }
}
class FatherClass2{
 public  FatherClass2() {
  System.out.println("创建FatherClass");
 }
}
class ChildClass2 extends FatherClass2{
 public  ChildClass2() {
  //构造方法的第一句总是super,写不写都加这句话
  //所以隐藏了
  //super();会先调用父类的构造器
  System.out.println("创建ChildClass");
 }
}

6、修饰符
这里不上程序了，因为我的程序为了测试，都被分散在多个class了，还在不同的包里面，比较麻烦。所以，直接说也是可以的。
*private:私有的，智能在同一个类中被访问
*default:表示没有修饰词，默认都是这个，可以被同一个包中的所有类访问
*protected:可以被同一个包的所有类以及不同包的子类访问
*public：最开放，可以被项目内所有类访问
*
*类的属性一般是用private修饰，外部使用使用set和get方法访问
类的属性可以这样做
写属性
public void setX(int x)
{
this.x=x;
}
读属性
public void getX()
{
return this.x;
}
7、数组
数组也是对象，被存放在堆空间。

public class TestArray {
 public static void main(String[] args) {
  //初始化
  int[] arr01=new int[10];
  String [] arr02=new String[5];
  User [] arr03=new User[3];
  //赋值
  for(int i=0;i<arr01.length;i++){
   arr01[i]=i*2;
   System.out.println(arr01[i]);
  }
  //初始化user类型数组
  arr03[0]=new User(110,"小明");
  arr03[1]=new User(111,"小红");
  arr03[2]=new User(112,"小文");
  for (int i = 0; i < arr03.length; i++) {
   System.out.println(arr03[i].getName());
   System.out.println(arr03[i].getId());
  }
  }
}
class User{
 private int id;
 private String name;
 public User(int id, String name) {
  super();
  this.id = id;
  this.name = name;
 }
 public int getId() {
  return id;
 }
 public void setId(int id) {
  this.id = id;
 }
 public String getName() {
  return name;
 }
 public void setName(String name) {
  this.name = name;
 }
 }

8、foreach遍历数组
注意，foreach只能读数组，但不能修改数组。

public class TestArray3 {
 public static void main(String[] args) {
  int[] arr01=new int[10];
  for(int i=0;i<arr01.length;i++){
   arr01[i]=i*2;
   System.out.println(arr01[i]);
  }
  System.out.println("******************************");
  //foreach
  for(int m:arr01)
  {
   System.out.println(m);//没有下标，所以没法去更改数值，只能引用
  }
  }
}

今天学的新知识（也不算新知识，有很多学C语言的时候学过了）差不多就这些，一上午的时间，敲了敲代码，跟着视频学。
然后下午动手写了一个打飞机的小游戏，我还不知道怎么上传到CSDN工程，我学一下，然后发上来，做个纪念。