面向对象

继承
让我们更加容易实现类的扩展。
是extends关键字，子类继承父类
要点：
1.Java中继承只有单继承
2.子类继承父类，可以得到父类的全部属性及普通方法，除了父类的构造器，但是不一定能直接访问，比如父类的私有属性 及方法
3.如果定义一个类时，没有调用extends关键字，它的父类默认java,lang.Object.
4.使用Ctrl加T可以查看继承层次

class large{	//父类
	String name;
	int height;
	public void big() {		//父类方法
		System.out.println("大的");
	}
}
class small extends large{		//子 类继承父类，属性及普通方法
	String hobby;
	public small(String name,int height,String hobby) {//子类构造器
		this.name=name;
		this.height=height;
		this.hobby=hobby;
	}
}
public class testExtends {
	public static void main(String[] args) {
		small sm=new small("测试",1,"测试");
		sm.big();	//子类继承父类父类方法
	}
}
> 编译结果"大的"

instanceof
测试左边的对边是否时右边类的对象`

 System.out.println(sm instanceof large); 
 System.out.println(sm instanceof small)

两个结果都为true

重写（override）
要点：
1.方法名，形参列表相同。
2.返回值子类小于父类

class front{
	public void move() {
		System.out.println("动起来");
	}
	public void stop() {
		System.out.println("停止");
	}
	public large ii() {		//父类返回值
		return new	large();
	}
}
class queen extends front{
	public void move() {			//实现重写父类方法
		System.out.println("跑起来");
	}
	public small ii() {		//重写了父类的返回值，返回值子类小于等于父类
		return new	small("1",1,"1");
	}
}
public class testOverride {
	public static void main(String[] args) {
		queen qu=new queen();
		qu.move();
	}
}

多态
1.多态是方法的多态，不是属性的多态，与属性无关
2.多态的三个条件：继承，方法重写，父类引用指向子类对象

public class testPolym {
	public static void main(String[] args) {
		Animal a=new Animal();
		animalCry(a);
		Dog d=new Dog();
		animalCry(d);
		animalCry(new Cat());
	}
	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关键字
1.修饰方法：该方法不可被子类重写，但是可以重载
2.修饰类：修饰的类不能被继承

封装
用private修饰属性，方法的将被本类私有

public class testFengzhuang {
	private int age;
	private String name;
	private boolean man;
	
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		if(age>1&&age<130) {
			this.age = age;
		}else {
			System.out.println("错误");
		}
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
}

数组的初始化
1.数组也是对象
2.默认初始化，动态初始化，静态初始化

public class testShuzu {
	public static void main(String[] args) {
		int a[];
		boolean b[];
		String n[];
		double d[];
		int c[]=new int[10];//索引下标[0.length-1]{0.1.2.3.4.5.6.7.8.9}
		//通过循环初始化数组
		for(int i=0;i<c.length;i++) {
			c[i]=i*10;
		}
		//通过循环读取数组里面元素的值
		for(int i=0;i<c.length;i++) {
			System.out.println(c[i]);
		}
		User[] u=new User[3];
		u[0]=new User(100,"测试1");
		u[1]=new User(200,"测试2");
		u[2]=new User(300,"测试3");
		for(int i=0;i<u.length;i++) {
			System.out.println(u[i].getName());
			System.out.println(u[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;
	}	
}
> 输出结果：0，10，20，30，40，50，60，70，80，90
> 100，测试1，200，测试2，300，测试3

1.静态初始化

	int[] a= {1,2,33};
	ce[] c= {new ce(100,"测试1"),new ce(200,"测试2") };

2.默认初始化

int[] a1=new int[3];//默认给元素赋值，赋值规则和成员变量默认赋值一样

3.动态初始化

int[] a2=new int[3];//先分配空间
		a2[0]=1;//给元素赋值
		a2[1]=2;
		a2[2]=3;

foreach循环（只用于读取数组，不能修改元素的值）

		String[] s= {"w","w","w"};
		for(String S:s) {
			System.out.println(S);
		}
`` `