封装_使用细节_javabean的规则
同一包下的两个类
1 package cn.sxt.oo;
2 public class PersonEncapsulation {
3 private int id;
4 private String name;
5 private int age;
6 private boolean man;
7
8 public void setName(String name){
9 this.name=name;
10 }
11 public String getName(String name){
12 return this.name;
13 }
14 public void setAge(int age){
15 if(age>=1&&age<=130){
16 this.age=age;
17 }else{
18 System.out.println("请输入正常的年龄");
19 }
20 }
21 public int getAge(){
22 return this.age;
23 }
24 }
1 package cn.sxt.oo;
2 //测试封装
3 public class TestEncapsulation {
4 public static void main(String[] args) {
5 H h = new H();
6 S s=new S();
7
8 PersonEncapsulation p = new PersonEncapsulation();
9 p.setAge(14);
10 System.out.println(p.getAge());
11 }
12 }
13 class H{
14 public void Huamn(){
15 return ;
16 }
17 }
18 class S{
19 public void e(){}
20 }
多态:指的是同一个方法调用,由于对象不同可能会有不同的行为。现实生活中,同一个方法,具体实现
会完全不同。
1.多态是方法的多态,不是属性的多态(多态与属性无关)。
2.多态的存在要有3个必要条件:继承,方法重写,父类引用指向子类对象。
3.父类引用指向子类对象后,用该父类引用调用子类重写的方法,此时多态就出现了。
1 package cn.sxt.oo;
2 public class TestDuotai {
3 public static void main(String[] args) { //main方法
4 Animal a= new Animal(); //创建对象
5 animalCry(a);
6 Dog d = new Dog();
7 animalCry(d);
8 animalCry(new Cat());
9 }
10 static void animalCry(Animal a){
11 a.shout();
12 }
13 /* static void animalCry(Animal a){
14 a.shout();
15 }
16 static void animalCry(Animal a){
17 a.shout();
18 } */
19 }
20 class Animal{
21 public void shout(){ //构造叫的方法
22 System.out.println("叫了一声!");
23 }
24 }
25 class Dog extends Animal{ //狗继承动物
26 public void shout(){ //构造叫的方法
27 System.out.println("旺旺!");
28 }
29 }
30 class Cat extends Animal{ //猫继承动物
31 public void shout(){
32 System.out.println("喵喵喵!");
33 }
34 }
final修饰变量和方法和类:
父类的方法如果加final,子类不能重写;
父类前加final,子类不能继承
数组的使用_内存状态_动态初始化和遍历
数组是相同类型数据的有序集合。数组描述的是相同类型的若干个数据,按照一定的先后次序排列组合而成。
其中,每一个数据称作一个元素,每个元素可以通过一个索引(下标)来访问它们。
数组的三个基本特点:
1.长度是确定的,数组一旦被创建,它的大小就是不可以改变的。
2.其元素必须是相同类型,不允许出现混合类型。
3.数组类型可以是任何数据类型,包括基本类型和引用类型。
数组变量属引用类型,数组也可以看成是对象,数组中的每个元素相当于该对象的成员变量。
1 package cn.sxt.arrays;
2 public class e {
3 public static void main(String[] args) {
4 int[] a = new int[10];
5 int i;
6 for (i=0;i<10;i++){
7 a[i]=i;
8 //System.out.println(a[i]);
9 }
10
11 //System.out.println(a[i]); //改变变量i 的值,如下 i=9,取第10个值
12 System.out.println(a[9]);
13 }
14
15 }
1 package cn.sxt.arrays;
2 public class Test1 {
3 public static void main(String[] args) {
4 int[] arr01 = new int[10]; //声明一个整数的数组
5 String[] arr02= new String[5];
6 arr01[0] = 3555;
7 arr01[1] = 1;
8 arr01[2] = 520;
9
10 //通过循环初始化数组
11 for (int i=0;i<10;i++){
12 arr01[i]=i;
13 //System.out.println(arr01[i]);
14
15 //通过循环读取数组里面元素的值
16 for (i=0;i<10;i++){
17 arr01[i]=i;
18 System.out.println(arr01[i]);
19 }
20 }
21 User[] arr03=new User[3]; //也可以定义User数组
22 arr03[0] = new User(1000,"zqf");
23 arr03[1] = new User(1001,"zqf");
24 arr03[2] = new User(1002,"zqf");
25 for(int i=0;i<arr03.length;i++){
26 System.out.println(arr03[i].getId());
27 }
28 }
29 }
30 class User{
31 private int id;
32 private String name;
33
34 public User(int id, String name) {
35 super();
36 this.id = id;
37 this.name = name;
38 }
39 public int getId() {
40 return id;
41 }
42 public void setId(int id) {
43 this.id = id;
44 }
45 public String getName() {
46 return name;
47 }
48 public void setName(String name) {
49 this.name = name;
50 }
51
52 }
数组的初始化方式总共有三种:静态初始化,动态初始化,默认初始化
1 package cn.sxt.arrays;
2 //测试静态初始化
3 public class TestJingtai {
4 public static void main(String[] args) {
5 //静态初始化(两种)
6 int[] a = {2,4,65};
7 cn.sxt.arrays.User[] b= {new User(1001,"zqf"),
8 new User(1,"d"),
9 new User(2,"s")};
10
11 //默认初始化
12 int[] c = new int[3];
13 //动态初始化 按照下标,挨个赋值
14 int[] a1= new int[2];
15 a1[0] = 1;
16 a1[1] = 2;
17 }
18 }
数组的遍历__foreach循环
1 package cn.sxt.arrays;
2 public class e {
3 public static void main(String[] args) {
4 int[] a = new int[10];
5 for (int i=0;i<10;i++){
6 a[i]=i;
7 }
8 //foreach用于遍历循环数组
9 for(int b:a){
10 System.out.println(b);
11 }
12 }
13 }