面向对象编程基础-优快云博客

本文链接：https://blog.youkuaiyun.com/u010773245/article/details/8967363

1.理解面向对象：

面向对象是相对面向过程而言，面向对象和面向过程都是一种思想；面向过程强调的是功能行为，面向对象是将功能封装进对象，强调具备了功能的对象；面向对象是基于面向过程的。

举一个生活中的常例如：我去饭店吃饭，喊服务员拿拿菜单点菜，然后服务员交给厨师去做，这就是一个面向对象；我调用服务员，服务员调用厨师，而厨师面向过程（做饭）；

开发就是找对象使用，如果没有就创建一个对象，开发的过程就是找对象，建立对象，使用对象，维护对象的关系

类和对象的关系：类：是对现实社会中事物的描述

对象：就是这类事物是实实在在的个体

成员变量和局部变量的区别：

作用范围成员变量：作用于整个类中；

局部变量：作用于函数中或语句中

在内存中的位置

成员变量：在堆内存中，因为对象的存在，才在内存中存在；

局部变量：存在栈内存中；

匿名对象的两种使用方式：

1>当对对象的方法调用一次时可以用匿名对象来完成下面代码标注匿名兑现过得使用

如果对一个对象进行多个成员调用，必须给这个对象起个名字

2>可以将匿名对象作为实际参数进行传递

举一个面向对象的例子：

<span style="font-size:18px;"><strong>public class Car {
  //描述颜色
  String color = "红色";
  // 描述轮胎
  int num= 4 ;
  //运行方法
  void run(){
   System.out.println(color + "---->"+num);
  }
 
void show(Car c){
 
c.color = "red";
 
c.num = 2;
 
c.run();
 
}
  public static void main(String[] args) {
   //创建一个新的对象，其实就是在队内产生一个实体
   Car c = new Car();//c就是一个类类型变量  注：类类型变量指向对象
   c.color = "蓝色";//在java中的智慧方式是对象.对象成员
   c.num = 5;// new Car().num = 5; 匿名对象
   c.run();
   System.out.println("------------------");
   Car c1 = new Car();
   c1.color = "黑色";
   c1.run(); //匿名对象的同种作用  new Car().run():
 
//匿名对象作为实际参数进行传递
 
show(new Car);
  }
 }
</strong></span>

面向对象程序（oop）的特点：封装，继承，多态

封装：即隐藏对象的属性和实现细节进队外提供公共访问方式

封装的好处：将变化隔离，便于使用，提高重用性，提高安全性

封装的原则：将不需要对外提供的内容都隐藏起来；

把属性都隐藏，提供公共访问对其访问

private：关键字用 private修饰的变量和方法只能在同类中访问（也可以提供一个公共的访问方式）

私有仅仅是封装的一种形式

构造函数

作用：可以用于给对象进行初始化；

构造函数的细节：当一个类中没有定义构造函数式，系统默认加一个空的构造函数；

什么时候定义构造函数：当分析是事物时，该事物具备一些特性或者行为那么将这些函数定义在构造函数中；

一个对象建立构造函数只运行一次，而一般方法可以被该对象调用多次；

构造代码块：

作用：给对象进行初始化，对象一建立就运行，优先于构造函数运行；

构造函数只是给对应的对象进行初始化，而构造代码块是给所有的对象进行初始化；

构造代码快的格式：{ 执行语句 }

构造代码块中定义的是：不同对象共性的初始化内容；

this 关键字：区别于局部变量和成员变量，代表所在函数所属对象的引用
this语句只能用于构造函数间，必须用于构造函数的第一行；

this的应用：当定义类中功能时，该函数内部要用到调用该函数的对象时，这时用this表示这个对象，本类功能内部使用到了本类对象都用this表示；

this语句例：this(name);

static 静态用法：是一个修饰符，用于修饰成员（成员变量，成员函数）
当成员被静态修饰后就多了一个调用方式，除了直接被对象调用外，还可以直接被类名调用；

被static修饰后的成员变量具备以下特点：

1>随着类的加载而加载；

2>优先于对象存在；

3>被所有对象所共享；

4>可以直接被类名调用；

静态方法只能访问静态成员，静态方法中不可以写this和super关键字；

非静态方法既可以访问静态成员也可以访问非静态成员；

静态方法的利与弊：

利：对对象的共享数据进行单独空间存储节省空间，可以直接类名调用；

弊：生命周期过长，访问出现局限性；

静态的应用：将功能代码用静态的方法封装起来提高重用性；

静态代码块：

特点：随着类的加载而执行，只执行一次

作用：给类进行初始化

格式： static{ 执行语句 }

静态代码块优先于静态代码块执行如下例：

<span style="font-size:18px;"><strong>public class Text {
	/*
	 *静态块  构造块  有参   无参的执行顺序
	 */
	private String name;
	static{
		System.out.println("a");
	}
	
	public Text(){
		System.out.println("c");
	}
	
	{
		System.out.println("b");
	}
	
	public Text(String name){
		System.out.println("d");
	}
	public static void main(String[] args) {
		
		new Text("你好");
	}
}
</strong></span>

执行结果==》a b d

封装的举例：用到上面介绍的内容：

<span style="font-size:18px;"><strong>public class Person {
	
	private String name;
	private int age;//成员变量
	private static String country = "cn";//静态变量
	
	static{
		//静态块
	}
	
	{
		//构造快
	}
	
	public static String getCountry() {
		return country;
	}
	public static void setCountry(String country) {
		Person.country = country;//静态方法中不能用this、super关键字
	}
	public Person(){//无参构造
		
	}
	public Person(String name){
		this.name = name;
	}
	public Person(String name, int age,String country){//有参构造
		this(name);//调用上面给的this.name  this语句的使用
		this.age = age;
		this.country = country;
	}
	
	public void setName(String name){
		this.name = name;
	}
	public String getName(){
		return name;
	}
	public void setAge(int age){
		this.age = age;
	}
	public int getAge(){
		return age;
	}
	
	public void speak(){//非静态方法既可以访问静态变量也可以访问静态变量
		
		System.out.println("姓名"+ this.name +"--->"+ "年龄"+this.age+"-->"+country);
	}
	public static void show(){//静态方法只能访问静态变量
		System.out.println("国家" + country);
	}
	
	//this代表本类对象
	public boolean campare(Person p){
		return this.age == p.age;
	}
}
public class PersonDemo {

	public static void main(int x){
		
	}
	public static void main(String[] args) {
		
		Person p = new Person();//调用无参构造
		p.setName("张三");
		p.setAge(20);
		p.speak();//调用非静态方法
	
		Person p1 = new Person();//调用有参构造
		p1.setName("李四");
		p1.setAge(6);
		p1.speak();
		Person.show();//静态方法的调用
		Person.getCountry();//类名直接调用静态变量
		
		System.out.println(p.campare(p1));
	}
}
</strong></span>

单例模式

<span style="font-size:18px;"><strong>public class Person {
	
	private String name;
	private int age;//成员变量
	private static String country = "cn";//静态变量
	
	static{
		//静态块
	}
	
	{
		//构造快
	}
	
	public static String getCountry() {
		return country;
	}
	public static void setCountry(String country) {
		Person.country = country;//静态方法中不能用this、super关键字
	}
	public Person(){//无参构造
		
	}
	public Person(String name){
		this.name = name;
	}
	public Person(String name, int age,String country){//有参构造
		this(name);//调用上面给的this.name  this语句的使用
		this.age = age;
		this.country = country;
	}
	
	public void setName(String name){
		this.name = name;
	}
	public String getName(){
		return name;
	}
	public void setAge(int age){
		this.age = age;
	}
	public int getAge(){
		return age;
	}
	
	public void speak(){//非静态方法既可以访问静态变量也可以访问静态变量
		
		System.out.println("姓名"+ this.name +"--->"+ "年龄"+this.age+"-->"+country);
	}
	public static void show(){//静态方法只能访问静态变量
		System.out.println("国家" + country);
	}
	
	//this代表本类对象
	public boolean campare(Person p){
		return this.age == p.age;
	}
}

public class PersonDemo {

	public static void main(int x){
		
	}
	public static void main(String[] args) {
		
		Person p = new Person();//调用无参构造
		p.setName("张三");
		p.setAge(20);
		p.speak();//调用非静态方法
	
		Person p1 = new Person();//调用有参构造
		p1.setName("李四");
		p1.setAge(6);
		p1.speak();
		Person.show();//静态方法的调用
		Person.getCountry();//类名直接调用静态变量
		
		System.out.println(p.campare(p1));
	}
}
</strong></span>

单例模式：

<span style="font-size:18px;"><strong>单例设计模式：解决一个类在内存中只用一个对象
 
例：饿汉式   Student一进内存就已经创建好了对戏那个
 
public class Student {
 
 private int age;
  
  private static Student s = new Student();
  private Student(){}
  public static Student getStudent(){
   return s;
  }
  public void setAge(int age){
   this.age = age;
  }
  public int getAge(){
   return age;
  }
 }
 

public class StudentDemo {
 
 public static void main(String[] args) {
   
   Student s1 = Student.getStudent();
   Student s2 = Student.getStudent();
   s1.setAge(25);
   
   System.out.println(s1.getAge());
   System.out.println(s2.getAge());
   
  }
 }
 
单例模式2   懒汉式  Student类 进内存，对象还没有存在，只用调用getInfo方法时，才建立对象
 
public class Student {
 
 private int age;
  //模式2 懒汉式
  private static Student s = null;
  private Student(){}
  public static Student getInfo(){
   if(s == null){
    s = new Student(); 
   } 
   return s;
  }
  public void setAge(int age){
   this.age = age;
  }
  public int getAge(){
   return age;
  }
 }
 
public class StudentDemo {
 
 public static void main(String[] args) {
   
   Student s1 = Student.getInfo();
   Student s2 = Student.getInfo();
   Student s3 = Student.getInfo();
   s1.setAge(25);
   
   System.out.println(s1.getAge());
   System.out.println(s2.getAge());
   System.out.println(s3.getAge());
   
  }
 }
</strong></span>

面向对象--封装