封装_使用细节_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());
}
同一包下的两个类
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(){}
}
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();
} */
}
会完全不同。
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("喵喵喵!");
}
}
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,子类不能继承
父类的方法如果加final,子类不能重写;
父类前加final,子类不能继承
数组的使用_内存状态_动态初始化和遍历
数组是相同类型数据的有序集合。数组描述的是相同类型的若干个数据,按照一定的先后次序排列组合而成。
其中,每一个数据称作一个元素,每个元素可以通过一个索引(下标)来访问它们。
数组的三个基本特点:
1.长度是确定的,数组一旦被创建,它的大小就是不可以改变的。
2.其元素必须是相同类型,不允许出现混合类型。
3.数组类型可以是任何数据类型,包括基本类型和引用类型。
数组变量属引用类型,数组也可以看成是对象,数组中的每个元素相当于该对象的成员变量。
package cn.sxt.arrays;
数组是相同类型数据的有序集合。数组描述的是相同类型的若干个数据,按照一定的先后次序排列组合而成。
其中,每一个数据称作一个元素,每个元素可以通过一个索引(下标)来访问它们。
数组的三个基本特点:
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]);
}
}
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;
}
}
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;
}
}
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);
}
}
}
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);
}
}
}