1.封装：
注意：默认的是同一个包的所有类都能访问（上面的四个修饰符并不都是包含关系 具体情况具体分析吧）；
protect不同包的子类也能访问（因为他子类哪里有一个星号），同一个包不是子类也能访问；
2.封装的普通思想：
例子:
package cn.wang;
/**
* 测试封装
* @author Wang
*
*/
public class Person0 {
private String name ;
private int age;
private boolean man;
public String getName() {//封装的基本手段get 和set方法
return this.name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
if(age>=0&&age<=130) {//高内聚的体现
this.age = age;
}
else {
System.out.println("请输入正确年龄！不要撒谎哦！");
}
}
public boolean isMan() {//对于这个布尔类型的来说要把get改成is
return man;
}
public void setMan(boolean man) {
this.man = man;
}
}
package cn.wang;
/**
* 测试封装0，访问Person0的属性
* @author Wang
*
*/
public class TestEncapsulation {
public static void main(String[] args) {
Person0 per = new Person0();
per.setName("Wangtong");
System.out.println(per.getName());
per.setAge(-15);//设个是设置不上的
System.out.println(per.getAge());//会输出默认值为0
}
}
//Wangtong
//请输入正确年龄！不要撒谎哦！
//0
注意;想上面类中没有只有属性和set，get方法没有其他复杂方法我们称她为javabean；
3.多态：（polymorphism）
4.对象的转型：
3和4的例子：
package cn.wang;
/**
* 测试多态与对象的转型
* @author Wang
*
*/
public class TestPoly {
public static void main(String[] args) {
Animal a = new Animal();
animalCry(a);
Animal D = new Dog();//创建对象的时候也可以这样 b还是狗的对象；编译器在这里认为Dog向上转型 转为Animal了；
animalCry(D);//JVM运行的时候才知道D是Dog，但是我们写代码的时候都是先通过编译然后才运行
//D.seedoor();//这一句他会说The method seedoor() is undefined for the type Animal编译的时候就过不去；
Dog D2 = (Dog)D; //这个就是向下转换为强制转换；
D2.seedoor();
Cat C = new Cat();//在这里会实现最后一个要求，
animalCry(C);//就是父类引用指向子类后用该父类引用调用子类重写的方法；
}
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("汪汪汪/");
}
public void seedoor() {
System.out.println("看门/");
}
}
class Cat extends Animal{
public void shout() {
System.out.println("喵喵喵/");
}
}
5.final
6.数组；
注意：数组就是对象不是可以看成 对象；
package cn.DKF.arrays;
/**
* 数组的测试
* @author Wang
*
*/
public class Test01 {
public static void main(String[] args) {
int [] arr01;//声明一个数组 建议这样写
int arr02[];//还可以这样声明；
arr01 = new int[10];//给数组分配空间
String[] arr03 = new String[10];
int[] arr04 = new int[10];//我们一般都是声明与给空间写到一起的；
for(int i=0;i<arr01.length;i++) {//数组的遍历初始化
arr01[i] = 10 * i;
}
//arr01[11] = 100;会抛异常 java.lang.ArrayIndexOutOfBoundsException 数组索引越界
for(int i=0;i<arr01.length;i++) {//数组遍历读取；
System.out.println(arr01[i]);
}
User[] arr05 = new User[3];//会在堆中生成arr05数组并有3个空间
arr05[0] = new User(100,"wangtong");//在这是在堆中建立一个User对象里面是100，wangtong；然后把他的地址给arr05[0];
arr05[1] = new User(101,"wangtong1");//同上
arr05[2] = new User(102,"wangtong2");//同上
for(int i=0; i<arr05.length; i++) {//还是遍历
System.out.println(arr05[i].getName());
}
}
}
class User{
int id;
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;
}
}
7.数组的初始化：
例子：
package cn.DKF.arrays;
/**
* 数组的三种赋值方法
* @author Wang
*
*/
public class Test02 {
public static void main(String[] args) {
//静态初始化
int[] a = {2,3,4};
User[] b = {
new User(1000,"wangyajie"),
new User(1001,"lishaung")
};
//默认初始化
int[] c = new int[3];//默认进行赋值和成员变量的默认赋值规则一致，int默认0，boolean默认False，String默认是null；
//动态初始化
int[] d = new int[2];
a[0] = 1;
a[1] = 2;
//后两个都要先动态分配空间；
}
}
7.for-each（注意是读取）
package cn.DKF.arrays;
/**
*
* 数组的遍历操作与for-each
* @author wang
*
*/
public class Test03 {
public static void main(String[] args) {
int[] a = new int[3];
for(int i=0; i<a.length; i++) {//遍历初始化；
a[i] = 10*i;
}
for(int i=0; i<a.length; i++) {//遍历读取；
System.out.println(a[i]);
}
System.out.println("#################");
for(int temp:a) {//for-each 注意她只能用于数组和集合的读取而不能用作初始化；
System.out.println(temp);
}
}
}