初始面向对象02

上一篇文章我们基本了解了什么是面向对象和面向对象的一些基本的定这章我们继续了解面向对象构造器,了解构造器我们先了解一下new这个关键字 。new的作用就是创建对象具体分为三步：第一步，在对中开辟一个空间，成员属性鬼祟对象进入堆内存中并赋默认值；第二步，调用这个类的构造器为对象初始化信息（如果没有写构造器，编译器默认提供一个无参构造）；第三步：将地址返回引用。所以在这里就可以了解到 ，构造器只能在创建对象的时候被调用 （注意:不是用来创建对象的）下面我们看下构造器的写法,格式如下:

修饰符 类名(参数列表){
	构造器......
}

构造器是个没有返回值类型,没有void,可以添加return的特殊方法,且方法名必须和类保持一致,并且不能和static,final,obstract一起使用。构造器的作用就是为了给对象初始化信息，跟随new使用的（上面说过），看一段代码

class Test01{
	int age
	public Test01(){//定一个无参的构造器
	}
	public Test01(int _age){//定一个有参的构造器
		age=_age;
		System.out.println(age);
	}
}

上面一段代码我们定了一个无参构造又定义了一个有参构造.在这里我们知道方法是可以重载的,构造器作为一个特殊的方法当然可以构成重载,所以我们可以用重载定义多个构造器来为我们为对象初始化信息(这个比创建对象后在调用属性赋值快,而且简单)所以构造器可以帮助我们简化代码。另外如果有显示定义的构造器，编译器不会在为我们提供构造器。看下如下代码

public claa Test02{
	public static void main(String[] args){
		Test03 test =new Test03();//调用无参构造
		Test03 test =new Test03("张三","男",19);//调用构造器,比创建对象调用属性赋值看着简单,整洁
	}
}
class Test03{//创建一个类
	String name;
	Strung gender;
	int age;
	public Test03(){//无参构造
	}
	public Test03(String name,Strung gender){//有参构造
	this.name = name;
	this.gender = gender;
	}
	public Test03(String name,String gender,int age){
	this(name.gender);//this关键字调用参数列表为(String a,String b)的构造器 下面会讲
	this.age =age;
	}
}

上面一段代码中,我们使用到this这个关键字,this在面向对象中是个很重要的关键字,它的含义是 指代当前的new的对象
this使用在构造器中:调用本类中的其他构造器(上面一段代码),必须在构造器首行使用(this(参数列表));
this使用在成员方法汇中|构造器中:区分同名变量问题,this指代当前对象|当前调用方的对象。（如果出现同名的成员变量和局部变量问题，如果想指代成员变量必须使用this）。
注意：1.不能使用this关键字进行构造器之间的相互调用（不能1调2,2调3,3在调1）
2.this和static 不能同时使用。
Static：静态的
static修饰变量：静态变量|类变量；（只能修饰成员变量不能修饰局部变量）
static修饰方法：静态方法|类方法
使用方法：
1.类名.属性名|方法名（）；
2.对象名.属性名|方法名（）；
注意：（静态变量是属于类的，成员变量是属于方法的）。
静态变量是第一份的在类第一次使用的时候就初始化了。在静态的内容中我们可以直接使用静态的内容，不能直接使用非静态的内容，可以根据对象使用。在非静态的内容中，可以直接使用非台的内容，也可以直接使用非静态的内容。

public class Test04{
	static int age =10;
	int money = 100;
	public static void test(){
		Test04 tes = new Test04();//在静态方法中不能直接用非静态的内容,只能通过对象使用
		System.out.println("我是静态方法"+age);
		System.out.println("我是静态方法"+tes.money);
	}
	public void test01(int a , int b){
		age = a;//非静态可以直接使用静态内容
		money = b;
		System.out.println("我是非静态方法"+age);
		System.out.println("我是非静态方法"+money);
	}
}

block块
{}定义在方法中叫做局部代码块|普通语句块.执行的时机:方法调用时
{}就是一个作用域,同一个作用域下变量不同名
{}定义在类中方法外----->构造块
执行时机:创建对象的时候
构造块中代码先于构造器执行,如果有多个构造块,从上到下执行

public class Test05{
	{
		System.out.prinln("我是构造块");
	}
	public Test06(){
		{
			System.out.prinln("我是代码块");
		}
	}
}

static{}定义在类中方法外------->静态快
执行时机:类第一次加载的时候。静态块只执行一次，在类第一次加载的时候如果存在多个静态块从上到下执行。

public class Test06{
	 static{
		System.out.prinln("我是静态块");//静态快先于构造块执行
	}
	{
		System.out.prinln("我是构造块");//先于构造器执行
	}
	public Test06(){
		{
			System.out.prinln("我是代码块");
		}
	}

上面一段代码,注释解释了一下三个块先后的顺序,正常情况下,代码是先加载类执行静态块----->main方法----->构造块----->构造器----->普通语句块;当然也有一些特殊情况 就是带参构造器执行的时候,是先传参然后在构造块 =----->构造器。
Private
私用的 修饰的内容只能在当前类中使用。所以我们在使用的时候需要为私有的字段提供一对公开的访问方式：设置器 setter；获取器 getter。

public class Test07{
	private int age;
	int money;
	public Test07(){
	}
	public Test07(int age ,int money){
	this.age = age;
	this.money=money;
	System.out.println(age+"------>"+money);
	}
	public void setAge(int a){
		age = a;
	}
	public int getAge(){
		return age;
	}
	
}
class Test08{
	public static void main(String[] args){
		 Test07 tes = new Test07(16,500);//创建对象,并初始化信息
		 tes.setAge(18);//设置年龄的值
		 System.out.println(tes.getAge());//得到年龄的值
		 tes.money = 1000;
	}
}

其实用这些优点:提高代码的复用性,安全性
模板类:javabean:
1.修饰类的default|public
2.至少提供一个空构造
3.属性的私有化
4.对外提供公共的访问方式
竟然说了prviate,那么我们就了解一下剩下的权限修饰符:
__________ 本类 ________ 同包类_____不同包类_______ 不同包其他类
public ---------Y -------------------Y--------------------Y--------------------------Y
protected ------Y -------------------Y-------------------Y
default ----------Y -------------------Y
private----------Y
以上权限修饰符只能修饰成员,不能修饰局部.
能够修饰类的只有default | public
比较特殊的pretected:
1.同包类中直接使用
2.不同包下的子类,鼻血通过继承关系才能使用
继承
目的:为了简化代码。
子类一旦继承父类，就可以使用父类的内容，java中是单继承：一个子类只能继承一个父类，一个父类可以被多个子类继承，多实现。
之类|派生类：继承父类的类
父类|基类|超类：被继承的类
使用继承：

子类 extends 父类；
//类是对对象的抽象;父类是对子类的抽象

单继承的有点:简单单继承的
单继承的缺点:不便于后期维护

public class Extends01 {
	public static void main(String[] args) {
		Cat cat = new Cat();
		cat.name = "小花";
		cat.type = "折耳";
		cat.sleep();
		Dog dog = new Dog();
		dog.name = "阿黄";
		dog.type = "巴哥";
		dog.see();
		Brid bird = new Brid();
		bird.fly = "会飞";
		bird.type = "八哥";
		bird.shout();
	}
}

class Animals {
	String animal;
	String name;
	String type;

	public void shout() {
		System.out.println("动物的吼叫声");
	}

	public void sleep() {
		System.out.println("酣眠");
	}
}

class Cat extends Animals {
	String climp;

	public Cat() {
	}

}

class Dog extends Animals {
	public Dog() {

	}

	public void see() {
		System.out.println(name+"看家");
	}
}

class Brid extends Animals {
	String fly;

	public Brid() {

	}
}