【Java编程进阶之路--面向对象】

活动地址：CSDN21天学习挑战赛

• 1、面向对象是什么
• 2.类与对象的关系
• 3.方法回顾加深
• • 3.1 方法的定义
  • 3.2方法调用
• 4.调用方法的传参
• 5 this关键字
• 6.构造器
• 7.内存分析
• 总结

面向过程的思维模式
面向过程的思维模式是简单的线性思维，思考问题首先陷入第一步做什么、第二步做什么的细节中。这种思维模式适合处理简单的事情，比如：上厕所。

面向对象的思维模式
面向对象的思维模式说白了就是分类思维模式。
思考问题首先会解决问题需要哪些分类，然后对这些分类进行单独思考。最后，才对某个分类下的细节进行面向过程的思索。

如果一个问题需要多人协作一起解决，那么你一定要用面向对象的方式来思考！

对于复杂的事物，为了从宏观上把握，从整体上合理分析，需要使用面向对象的思路来分析整体系统。但是具体到围观操作，任然需要面向过程的思路去处理。

Java的编程语言是面向对象的，采用这种语言进行编程称为面向对象编程(Object-Oriented
Programming, OOP)。

面向对象编程的本质就是：以类的方式组织代码，以对象的组织(封装)数据

类是一个模板：抽象，对象是一个具体的实例
例如: Person类、Pet类、Car类等，这些类都是用来描述/定义某一类具体的事物应该具备的特点和行为
对象是抽象概念的具体实例

Student s = new Student(1L,"tom",20); 
s.study();
Car c = new Car(1,"BWM",500000);
c.run();

对象s就是Student类的一个实例,对象c就是Car类的一个具体实例,能够使用的是具体实例,而不是类。类只是给对象的创建提供了一个参考的模板而已。但是在java中,没有类就没有对象,然而类又是根据具体的功能需求,进行实际的分析,最终抽象出来的.

方法一定是在类中的，属于类的成员

修饰符 返回类型 方法名(参数列表)异常抛出类型{...}

• 修饰符
  public ，static ，abstract，final都是，一个方法可以有多个修饰符。例如：程序入口main（）方法，使用了public static两个修饰符、
• 返回类型
  方法执行完如果有要返回的数据，那么就要声明返回数据的类型，如果没有就返回类型写void、

public String sayHello(){ 
   return "hello";
 }
 public int max(int a,int b)
 { 
    return a>b?a:b; 
 }
 public void print(String msg){
  System.out.println(msg);
 }

• break和return的区别

return 语句的作用
(1) return 从当前的方法中退出，返回到该调用的方法的语句，继续执行。
(2) return 返回一个值给调用该方法的语句，返回值的数据类型必须与方法的声明中的返回值的类型一致。
（3）return 可加，可不加参数，主要目的用于中断函数执行，返回调用函数处

break 在循环体中，强行结束循环的执行，就是结束整个循环过程，不在判断执行循环条件是否成立，直接转向循环语句下面的语句
break 在switch 语句体内，跳出switch语句体。

• 抛出异常类型

如果方法中的代码在执行过程中，可能会出现一些异常情况，那么就会在方法上把这些异常声明并抛出。也可以同时声明多个异常，使用逗号隔开即可。

public void readFile(String file)throws IOException{ }
public void readFile(String file)throws IOException,ClassNotFoundException{ }

• 静态方法
  用static修饰符的方法就是静态方法。调用这种方法的时候，可以使用对象调用，也可以使用类来调用，但是推荐类进行调用，

public class Student{ 
	public static void say(){}
 }
 main: Student.say();

• 非静态方法
  没有使用static修饰符修饰的方法,就是非静态方法. 调用这种方法的时候,是"一定"要使用对象的。因为非静态方法是属于对象的。(非静态属性也是一样的)

public class Student{ 
public void say(){}
 }
 main: 
 Student s = new Student();
  s.say();

• 类方法的调用
  同类型方法可以直接调用

public void a(){
 b(); 
 }
public void b(){ }

public static void a(){
 b(); 
}
public static void b(){ }

静态方法不能直接调用非静态方法，反之则可

public static void a(){
 //b();报错 
 }
 public void b(){ 
 a(); 
 }

总结：类中方法中的调用，两个方法都是静态或者非静态都可以互相调用，当一个方法是静态，一个方
法是非静态的时候，非静态方法可以调用静态方法，反之不能。

• 值传递和引用传递
  【示例：值传递】

public class Test{ 
public static void changeNum(int a){
      a = 10; 
 }
 public static void main(String[] args){
  int a = 1; 
  System.out.println("before: a = "+a); //1 
  changeNum(a); 
  System.out.println("after: a = "+a); //1 
  } 
}

【示例：引用传递】

public class Demo03 {
 public static void changeName(Student s){ s.name = "tom";
  }
  public static void main(String[] args){
	   Student s = new Student(); 
	   System.out.println("before: name = "+s.name); //null 
	   changeName(s); 
	   System.out.println("after: name = "+s.name); //tom 
   } 
   }
   class Student{
    String name;
}

• this在类中的作用
  【区别成员变量和局部变量】

public class Student{ 
	private String name;
	 public void setName(String name){ 
	 //this.name表示类中的属性name 
	      this.name = name; 
	 }
	  }

【调用类中的方法】

public class Student{ 
private String name;
 public void setName(String name){ 
 this.name = name; 
 }
 public void print(){ 
 //表示调用当前类中的setName方法 
    this.setName("tom");
    } 
  }

注：默认情况下,setName(“tom”)和this.setName(“tom”)的效果是一样的.
【调用类中的构造器】

public class Student{ 
   private String name; 
public Student(){ 
//调用一个参数的构造器,并且参数的类型是String    
  this("tom");
 }
 public Student(String name){
   this.name = name;
   } 
 }

注:this的这种用法,只能在构造器中使用.普通的方法是不能用的.并且这局调用的代码只能出现在构造器中的第一句

 public class Student{ 
   private String name; 
   //编译报错,因为this("tom")不是构造器中的第一句代码. 
   public Student(){
 	System.out.println("hello"); 
   this("tom"); 
  }
  public Student(String name){
    this.name = name;
    } 
 }

注:这句话是要这么来描述的,s1对象中的this和s1相等,s2对象中的this和s2相等,因为类是模板,模板中写的this并不是只有一个,每个对象中都有一个属于自己的this,就是每个对象中都一个属于自己的name属性
一样。

public class Student{
	 private String name; 
	 public void test(){ 
	 System.out.println(this); 
 }
 public static void main(String[] args) {
  Student s1 = new Student();
  Student s2 = new Student(); 
   s1.test();
   s2.test(); 
    } 
  }

类中的构造器也称为构造方法，是在进行创建对象的时候必须要调用的。并且构造器有以下俩个特点:

1. 类名相同
2. 没有返回值
   存在有参构造器时，无参构造器必须要写出来！

• 构造器之间的调用
  使用this关键字,在一个构造器中可以调用另一个构造器的代码。

public class Student{ 
private String name;
 public Student(){
  this();
   }
   public Student(String name){
    this.name = name; 
    } 
  }

我们在编写类的时候没有写构造器,那么在编译之后也会自动的添加一个无参构造器,这个无参构造器也被称为默认的构造器。

但是已经编写了有参构造器就会报错。

public class Student{
 private String name; 
 public Student(String name){
  this.name = name;
   } }
   main:
    //编译报错,因为没有无参构造器
     Student s = new Student();

构造器快捷键：alt + insert

栈 stack：
栈是由系统自动分配，速度快！栈是一个连续的内存空间！
堆 heap：

1. 放置new出来的对象！
2. 堆是一个不连续的内存空间，分配灵活，速度慢！
   方法区(也是堆)：

接下来更新java三大特性