面向对象

面向对象

一、面向对象和面向过程的区别

都是一种思维方式,是一种思想

面向过程:关注应该如何实现?然后一步一步的实现

面向对象:关注应该招谁来完成?只关注对象,对象如何实现不关注

面向对象是依托于面向过程的

二、面向对象的优点

1. 更符合显示生活的思维方式|角度
2. 面向对象的思维方式更贴近于管理者,面向过程的思维方式体现在执行者
3. 面向对象可以将复杂的问题简单化

三、构造器

1)、作用

为对象初始化信息,但不是创建对象的作用

注：只能跟随new一起使用

new在这一过程中所做的事情:

1. 在堆中为对象开辟空间,成员属性会跟随对象进入到堆内存中,并赋默认值
2. 调用构造器为对象初始化信息
3. 把地址反回给引用

2)、格式

修饰符   类名([参数列表]){
           方法体;
          }

public Dog(String dogName){
		System.out.println("我是带参数构造啊hahaha");
		if(dogName=="哈哈"){
			return;  //提前结束方法
		}
		name=dogName;
}

3)、案列

如果没有在类中自定义构造器,编译器会默认为我们提供一个空构造(没有参数),如果类中有自定义构造器,编译器就不会在为你提供任何构造器包括空构造

一个类中的多个构造器可以构成重载,调用的时候匹配实参,构造器没有返回值类型,也不需要void,可以根据需求添加return,但是不能返回数据

public Dog(String dogName){
		System.out.println("我是带参数构造啊");
		if(dogName=="哈哈"){
			return;  //提前结束方法
		}
		name=dogName;
	}
	
	public Dog(String dogName,String dogType,String dogColor){
		System.out.println("我是带3个参数构造啊");
		name=dogName;
		color=dogColor;
		type=dogType;
	}

构造器不能被final,abstract,static修饰,如果修饰符为private,只能在当前类中创建对象

class Dog{
	public String name;
	public String type;
	public String color;
	
	//空构造
	private Dog(){
		System.out.println("我是空构造啊");
	}
	public void wang(){
		Dog d=new Dog();
		System.out.println("一只名字为"+name+"的"+color+"的"+type+"在wangwangwang叫");
	}
}

四、this关键字

this 代表当前对象(当前new的对象)本身,存储当前对象的地址

1)、this的使用

• 构造器中使用,调用本类中的其他构造器 this(参数列表) -->实参

public Flower(String color,String type,int age) {
		System.out.println("我是3个参数构造器");
		this.color=color;
		this.type=type;
		this.age=age;
	}
	
	public Flower(String color,String type,int age,int num) {
	
	//调用上一个Flower(String color,String type,int age)构造器
		
		this(color,type,age);
		System.out.println("我是4个参数构造器");
		this.num=num;
	}

• 区分同名变量问题

public class Hello {
    String s = "Hello";
 
    public Hello(String s) {
       System.out.println("s = " + s);	//s=Helloworld!
       System.out.println("1 --> this.s = " + this.s);	//1-->this.s=Hello
       this.s = s;//把参数值赋给成员变量，成员变量的值改变
       System.out.println("2 --> this.s = " + this.s);	//2-->this.s=Helloworld!
    }
 
    public static void main(String[] args) {
       Hello x = new Hello("HelloWorld!");
       System.out.println("s=" + x.s);//验证成员变量值的改变
    }
}

注：成员方法中,this代表当前调用成员方法的对象
           如果同名,不使用this调用,默认发生就近原则
           如果不存在同名问题,使用成员变量,前面默认省略了this

2)、this的作用

简化代码

注：

• 必须在首行
• 构造器之间不能相互调用

五、static关键字

1)、定义

在类中，用 static 声明的成员变量为静态成员变量，它为该类的公用变量，在第一次使用时被初始化，对于该类的所有对象来说，static 成员变量只有一份。

2)、静态内容的使用

• 类名.静态变量名|静态方法名([参数列表])|静态方法名([参数列表])
• 对象.静态变量名|静态方法名([参数列表])

public class StaticDemo01 {
	static int id = 15;  //静态变量
	int age=10;  //成员变量
	public static void main(String[] args) {
		System.out.println(id);
		StaticDemo01 s=new StaticDemo01();
		
		change();  //  id=16  age=11
		System.out.println(s.age);   // 10
		System.out.println(s.id);    // 16
		System.out.println(StaticDemo01.id);  //16
		
		s.test();  
		System.out.println(s.age);   
		System.out.println(s.id);   
	}
	//静态的内容
	public static void change(){
		id++;
		StaticDemo01 s=new StaticDemo01();
		s.age++;
		System.out.println(id+"--->"+s.age);  
	}
	//成员内容
	public void test(){
		id++;
		this.age++;   // this指代调用成员方法的对象
		System.out.println(this.id+"-->"+this.age); //
	}
}

注：

• 静态的内容中可以直接使用静态的内容,但是不能直接使用成员的内容,通过对象去使用。
• 如果是在成员的内容中,可以直接使用静态的内容,也可以直接使用成员的内容

六、block构造块

1)、定义

即 {} -->作用域，可分为：

语句块	位置	执行时机
普通语句块	方法中	调用方法
构造块	类中方法外	创建对象
静态块	类中方法外	类加载

2)、关于执行

1.先于构造器的代码执行,编译时默认自动把构造块中的代码编译到要执行的构造器代码的最上方,如果存在多个构造块,从上到下以执依次

2.在类第一次加载完成之后执行,只执行一次,先于main方法执行,如果存在多个静态块,从上到下依次执行

public class BlockTest02 {
	public static int a = 0;
	{
		a = 10;
		System.out.println("3、非静态代码块执行a=" + a); //10
	}	
	static {
		a = 6;
		System.out.println("1、静态代码块执行a=" + a); // 6
	}
	public BlockTest02() { 
		this(a); 
		System.out.println("5、"+a);  //10
		System.out.println("6、无参构造方法执行a=" + a); // 10
	}
	public BlockTest02(int n) { 
		System.out.println("4、"+n); // 6
	}	
	public static void main(String[] args) {
		System.out.println("2 main"); // main
		BlockTest02 tsc = new BlockTest02();	
	}
}

运行结果：