The eighth day

封装_使用细节_javabean的规则
同一包下的两个类

package cn.sxt.oo;
public class PersonEncapsulation {
 private int id;
 private String name;
 private int age;
 private boolean man;
 
 public void setName(String name){
  this.name=name;
 }
 public String getName(String name){
  return this.name;
 }
 public void setAge(int age){
  if(age>=1&&age<=130){
  this.age=age;
 }else{
  System.out.println("请输入正常的年龄");
 }
 }
 public int getAge(){
  return this.age;
 }
}

package cn.sxt.oo;
//测试封装
public class TestEncapsulation {
 public static void main(String[] args) {
  H h = new H();
  S s=new S();
  
  PersonEncapsulation p = new PersonEncapsulation();
  p.setAge(14);
  System.out.println(p.getAge());
 }
}
class H{
 public void Huamn(){
  return ;
 }
}
class S{
 public void e(){}
}

多态：指的是同一个方法调用，由于对象不同可能会有不同的行为。现实生活中，同一个方法，具体实现
会完全不同。
      1.多态是方法的多态，不是属性的多态（多态与属性无关）。
      2.多态的存在要有3个必要条件：继承，方法重写，父类引用指向子类对象。
      3.父类引用指向子类对象后，用该父类引用调用子类重写的方法，此时多态就出现了。

package cn.sxt.oo;
public class TestDuotai {
 public static void main(String[] args) {       //main方法
  Animal a= new Animal();                    //创建对象
  animalCry(a);                             
  Dog d = new Dog();
  animalCry(d);
  animalCry(new Cat());
 }
 static void animalCry(Animal a){     
  a.shout();
 }
/* static void animalCry(Animal a){
  a.shout();
 }
 static void animalCry(Animal a){
  a.shout();
 }         */
}
class Animal{
 public void shout(){                         //构造叫的方法
  System.out.println("叫了一声！");
 }
}
class Dog extends Animal{                        //狗继承动物
 public void shout(){                         //构造叫的方法
  System.out.println("旺旺！");
 }
}
class Cat extends Animal{                       //猫继承动物
 public void shout(){
  System.out.println("喵喵喵！");
 }
}

final修饰变量和方法和类：
  父类的方法如果加final，子类不能重写；
  父类前加final，子类不能继承

数组的使用_内存状态_动态初始化和遍历
  数组是相同类型数据的有序集合。数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成。
  其中，每一个数据称作一个元素，每个元素可以通过一个索引（下标）来访问它们。
数组的三个基本特点：
 1.长度是确定的，数组一旦被创建，它的大小就是不可以改变的。
 2.其元素必须是相同类型，不允许出现混合类型。
 3.数组类型可以是任何数据类型，包括基本类型和引用类型。
数组变量属引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。

package cn.sxt.arrays;
public class e {
 public static void main(String[] args) {
  int[] a = new int[10];
  int i;
  for (i=0;i<10;i++){
   a[i]=i;
   //System.out.println(a[i]);
  }
   
  //System.out.println(a[i]);    //改变变量i 的值，如下 i=9，取第10个值
  System.out.println(a[9]);
 }
 
}

package cn.sxt.arrays;
public class Test1 {
 public static void main(String[] args) {
  int[] arr01 = new int[10];  //声明一个整数的数组
  String[] arr02= new String[5]; 
  arr01[0] = 3555;
  arr01[1] = 1; 
  arr01[2] = 520;
  
  //通过循环初始化数组
  for (int i=0;i<10;i++){
   arr01[i]=i;
   //System.out.println(arr01[i]);
  
  //通过循环读取数组里面元素的值
  for (i=0;i<10;i++){
   arr01[i]=i;
   System.out.println(arr01[i]);
  }
  }
  User[] arr03=new User[3];   //也可以定义User数组
  arr03[0] = new User(1000,"zqf");
  arr03[1] = new User(1001,"zqf");
  arr03[2] = new User(1002,"zqf");
  for(int i=0;i<arr03.length;i++){
   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;
 }
 
}

数组的初始化方式总共有三种：静态初始化，动态初始化，默认初始化

package cn.sxt.arrays;
//测试静态初始化
public class TestJingtai {
 public static void main(String[] args) {
  //静态初始化(两种)
  int[]  a = {2,4,65};   
  cn.sxt.arrays.User[] b= {new User(1001,"zqf"),
    new User(1,"d"),
    new User(2,"s")};
  
    //默认初始化
  int[] c = new int[3];
  //动态初始化   按照下标，挨个赋值
  int[] a1= new int[2];
  a1[0] = 1;
  a1[1] = 2;
 }
}

数组的遍历__foreach循环

package cn.sxt.arrays;
public class e {
 public static void main(String[] args) {
  int[] a = new int[10];
  for (int i=0;i<10;i++){
   a[i]=i;
  }
  //foreach用于遍历循环数组
  for(int b:a){
   System.out.println(b);
  }
 }
}