面向对象

1、对于面向对象思想，强调的是对象（实体）

特点：面向对象就是一种常见的思想，符合人们的思考习惯

          面向对象的出现，将复杂问题简单化

          面向对象的出现，让曾经过程的执行者变成了对象的指挥者

 2、类与对象：用java语言将现实生活中对事物的描述通过类的形式表现出来。（对事物的描述往往只关注两方面：属性和行为)

              类：对事物的描述(事物的属性和行为)

              对象：该事物的实例,在java中用new来创建

              匿名对象：没名字的对象 例：new Car();  

对象创建图解

一个对象的内存图解

扫描二维码关注公众号，回复： 433681 查看本文章

两个对象的内存图解

三个对象的内存图解

匿名对象：就是创建对象的时候,没有名字的对象

                匿名对象在实际开发中,只使用一次,不要使用多次 ,否则可能会造成内存溢出的现象;

代码演示

package org.westos.noname;
/**
 * 匿名对象:
 * 		就是创建对象的时候,没有名字的对象
 * @author Administrator
 *
 */
//定义一个学生类
class Student{
	
	String name ;
	int age ;
	
	public void show() {
		System.out.println(name+"---"+age);
	}
}

//学生类的测试类
public class StudentDemo {
	
	public static void main(String[] args) {
		
		//创建一个学生类对象
		Student s = new Student() ;//该对象名s
		s.name = "高圆圆" ;
		s.age = 28 ;
		s.show(); 
		
		System.out.println("------------------");
		//匿名对象(开发中经常使用),没有名字的对象
		System.out.println(new Student());//org.westos.noname.Student@70dea4e
		new Student().name = "赵又廷" ;
		
		/**
		 * 匿名对象在实际开发中,只使用一次,不要使用多次 ,否则可能会造成内存溢出的现象;
		 */
		new Student() ; //一直给堆内存开辟空间 
		new Student () ;
		
	}
}

构造函数：

               函数名与类名相同、不用定义返回值类型、没有具体的返回值类型

               作用：给对象进行初始化，多个构造函数以重载的形式存在

               一个类中如果没有构造函数，那么系统将会自动调用该类的默认构造函数(该默认构造函数是无参的)，如果有自定义的构造函数，那么系统就不会调用默认构造函数。

               构造函数与一般函数的区别：构造函数，对象在创建的时候就会调用所对应构造函数来对对象进行初始化，而一般函数在对象创建后等到需要函数功能时才调用。

注意事项：
   1)之前没有写无参构造,系统会默认提供无参构造
   2)如果我们定义了无参构造或者有参构造,系统不会再提供无参构造;定义一个类的时候,永远给出无参构造函数;

无参构造函数

package org.westos.构造方法;
/**
 * 构造方法作用:
 * 		就是给对象进行初始化
 * 
 * 构造方法也属于类的组成:
 * 			成员变量
 * 			构造方法
 * 			成员方法
 * 
 * 构造方法:
 * 		1)方法名和类名相同
 * 		2)构造方法,连void都没有
 * @author Administrator
 *
 */
//创建一个学生类
class Student{
	
	//构造方法
	public Student() {
		System.out.println("这是一个无参构造方法...");
	}
}
public class ConstructorDemo {
	
	public static void main(String[] args) {
		
		//创建一个学生对象
		Student s = new Student() ;
		System.out.println(s);//包名.类名@十六进制数据;
	}
}

有参构造函数

package org.westos.构造方法;
/**
 * 构造方法的注意事项:
 * 		1)之前没有写无参构造,系统会默认提供无参构造
 * 		2)如果我们定义了无参构造或者有参构造,系统不会再提供无参构造;定义一个类的时候,永远给出无参构造函数;
 * 
 * 
 * 构造方法是可以重载的:
 * 
 * 面试题:
 * 		有一个学生类:Student  里面有一些属性
 * 在测试类中创建学生类对象,经历了哪些属性:
 * 		Student s = new Student() ;
 * 		
 * @author Administrator
 *
 */
//创建一个老师类
class Teacher{
	
	private String name ;
	private int age ;
	
	//SetXXX()/GetXXX()方法:公共访问方法
	
	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	//无参构造
	public Teacher() {
		System.out.println("老师类的无参构造..");
	}
	
	//有参构造
	public Teacher(String name) {                   //第一种有参构造函数
		this.name = name;
		
		System.out.println("带一个String类型参数的有参构造");
	}
	   
	public Teacher(int age) {                       //第二种有参构造函数
		this.age =age ;
		System.out.println("带一个int类型参数的有参构造");
	}
	
	//带两个参数
	public Teacher(String name,int age) {           //第三种有参构造函数
		this.name =name ;
		this.age = age ;
		System.out.println("带两个参数的有参构造...");
	}
}

//测试类
public class ConstructorDemo2 {

	public static void main(String[] args) {
		
		//创建一个老师类对象
		Teacher t = new Teacher() ; 
		t.setName("张三");
		t.setAge(27);
		System.out.println(t.getName()+"----"+t.getAge());
		System.out.println("----------");
		
		/**
		 * 给成员变量有两种方式:
		 * 	1)setXXX()公共的访问方法
		 * 	2)可以通过有参构造函数进行赋值
		 */
		t = new Teacher("高圆圆") ;                         //第一种有参构造函数  
		t.setAge(28);
		System.out.println(t.getName()+"----"+t.getAge());
		System.out.println("----------------");
		
		t= new Teacher(27) ;                             //第二种有参构造函数
		t.setName("赵又廷");
		System.out.println(t.getName()+"----"+t.getAge());
		
		System.out.println("----------------");
		
		Teacher t2 = new Teacher("高圆圆", 27) ;           //第三种有参构造函数
		System.out.println(t2.getName()+"----"+t2.getAge());
		
		
		
		
		
	}

this关键字  

1)每个类的每个非静态方法(没有被static修饰)都会隐含一个this引用名称，它指的是调用这个方法的对象(当前对象)。

2)当在方法中去使用本类中的非static属性时，都会隐含地使用this关键字。 

3)this可以看作是一个变量，它就是当前对象的引用

  this关键字的用法一：

当类中某个非静态方法中的参数名跟该类中的某个成员变量名相同时，为了避免参数的作用范围覆盖了成员变量的作用范围，必须明确地使用this关键字来指定成员变量。

package org.westos.this关键字;
/**
 * 定义变量,方法,类,接口,做到见名知意
 * 在手机类的公有方法中,对应的局部变量名称应该做到见名知意
 * 
 * 虽然做到见名知意了,但是局部变量会将成员变量隐藏掉,Java提供一个关键字:this
 * 
 * 		this:代表是当前类的对象,或者是当前类对象的引用,解决了局部变量隐藏成员变量的情况
 * 
 * @author Administrator
 *
 */
//手机类
class Phone{
	
	//私有修饰
	private String brand ;
	private int price ;
	private String color ;
	
	//成员方法
	//提供公共的访问方法
	public void setBrand(String brand) {
//		brand = brand ;
		this.brand = brand;
	}
	
	//获取手机品牌
	public String getBrand() {
		return brand ;
	}
	
	public void setPrice(int price) {
//		price = price ;
		this.price = price ;
	}
	public int getPrice() {
		return price ;
	}
	
	public void setColor(String color) {
		//color = color ;
		this.color = color ;
	}
	public String getColor() {
		return color ;
	}
	
}

//测试类
public class Test {
	
	public static void main(String[] args) {
		
		//创建手机类对象
		Phone p = new Phone() ;
		p.setBrand("华为");
		p.setPrice(1999); 
		p.setColor("黑白");
		
		System.out.println(p.getBrand()+"---"+p.getPrice()+"----"+p.getColor());
		System.out.println("-----------------------");
		
		Student s = new Student() ;
		s.setName("高圆圆");
		s.setAge(28); 
		s.setsId("xx002");
		s.setGender('女');
		s.setTitle("学习委员");
		
		System.out.println(s.getName() + "----" + s.getAge() + "----" + s.getsId() + "----" + s.getGender() + "----"
				+ s.getTitle());
	}
}

  this关键字的用法二

        如果某个构造方法中的第一条语句为this(…)的形式，

        那么这个构造方法将调用本类中的其他构造方法

package org.westos.this关键字;
/**
 * 学生类:
 * 		姓名,年龄,学号,性别,title(学生的职位)
 * 		学习,打游戏...
 * 
 * 
 * :
 * 		
 * @author Administrator
 *
 */
public class Student {
	
	//成员变量
	private String name ;
	private int age ;
	private String sId;
	private char gender ;
	private String title ;
	
	////提供setXXX/getXXX()方法  :先手写 ,快捷键:alt+shift+s+r
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public String getsId() {
		return sId;
	}
	public void setsId(String sId) {
		this.sId = sId;
	}
	public char getGender() {
		return gender;
	}
	public void setGender(char gender) {
		this.gender = gender;
	}
	public String getTitle() {
		return title;
	}
	public void setTitle(String title) {
		this.title = title;
	}
	
	//学习
	public void study() {
		System.out.println("学生爱Java...");
	}
	
	//打游戏
	public void playGame() {
		System.out.println("学生玩战地一战风云...");
	}
	}

图解

static关键字

1)在类中，用static声明的成员变量称为静态成员变量，它是该类的公用变量，对于该类的所有对象来说，static成员变量只有一份。 

2)用static声明的方法称为静态方法，该方法独立存在于类中，所以也称为类方法。

静态方法中只能调用本类的静态成员变量和静态方法。（简记：静中只能有静，动中既可以有动，也可以有静）

 静态方法中不能使用this和super关键字。

3)静态成员可以通过类名.静态成员的方式去访问或类的实例(对象.静态成员)去访问。

4)static关键字的特点：

• static优先于对象存在，因为static所修饰的成员随着类的加载而加载，之后才会去创建类的实例(对象)。
  
• static所修饰的成员可以被所有对象所共享。static所修饰的是共享数据，而对象中存储的是特有数据。
• 如果数据是静态的,它可以被类名直接调用。被静态修饰的方法: 类名.方法名()；    被静态修饰的变量:类名.变量名;

5)注意事项

静态方法中不能直接调用非静态方法和非静态成员变量，如果静态方法中要调用静态成员，则必须实例化静态成员所在的类，即创建非静态成员所在类的对象，用对象去掉用非静态成员。

例：

class Demo{

public void function(){}

public static void function2(){

Demo a=new Demo();

a.function();                    //用对象去间接调用非静态方法

}
}

代码：

示例2

package org.westos.static关键字;
//自定义一个类
class Demo{
	//非静态的
	int num = 100 ;
	
	static int num2 = 200 ;
	
	public void show() {
		System.out.println(num);
		System.out.println(num2);
	}
	
	public static void method() {
		System.out.println("method demo...");
	}
}
public class StaticDemo2 {
	
	public static void main(String[] args) {
		
		//创建Demo类的对象
		Demo d = new Demo() ;
		d.num = 50 ;
		d.show(); 
		
		System.out.println(Demo.num2);//直接用类名调用static成员变量
		d.method();                   //用对象调用static方法
		Demo.method();                //直接用类名调用static方法
		
	}
}

package org.westos.static关键字;
/**
 * static用法:
 * 
 * 		一个类中可有静态变量,也可以有非静态变量
 * 		可以有静态成员方法,也可以有非静态成员方法
 * 	            静态的方法只能访问静态变量和静态的方法
 * 		非静态的方法,既可以访问静态变量，静态方法，也可以非静态的变量，非静态的方法
 * 
 * 简单记:静态只能访问静态
 * 
 * @author Administrator
 *
 */
class Student{
	
	int num = 100 ;
	public static int num2 = 200 ;
	
public void show() { //非静态的
		System.out.println(num);//隐式的去访问成员变量 ,隐藏了一个关键字:this
//		System.out.println(num2);隐式的去访问成员变量 ,隐藏了一个关键字:this
		System.out.println(this.num2);//显示的去访问静态成员变量
		function() ;//访问静态成员方法
	}	
public static void  function() {
//		show() ; show()为非静态的方法，静态只能访问静态方法,不能访问非静态的方法
		function2() ;//静态方法可以去访问静态的方法
	}
}
public static void function2() {
}
//测试类
public class StaticDemo3 {
	public static void main(String[] args) {
		//创建学生类对象
		Student s = new Student() ;
		s.show(); 
		s.function(); 
		s.function2(); 
	}
}

成员方法

类的组成中有一个成员:成员方法
成员方法的分类:
                        1)按照返回值划分
                           void的形式:没有具体的返回值
           非void形式:有具体返回值
  2)按照参数进行划分
      空参
      有参

package org.westos.成员方法;


/**
 * 类的组成中有一个成员:成员方法
 * 		成员方法的分类:
 * 				1)按照返回值划分
 * 					void的形式:没有具体的返回值
 * 					非void形式:有具体返回值
 * 				2)按照参数进行划分
 * 					空参
 * 					有参
 * @author Administrator
 *
 */
//创建一个学生类
class Student {
	
	
	private String name ;
	private String age ;
	public Student() { //alt+shift+s+c
	}
	//成员方法
	//有返回值没有参数的
	public String show() { 
		return "helloworld";
	}
	//没有返回值,有参数的情况
	public void method(String s) {
		System.out.println(s);
	}
	//没有返回值,没有参数的情况
	public void function() {
		System.out.println("function student...");
	}
	//有返回值,有参数的情况
	public String function2(String s1,String s2) {
		return s1+s2;//返回值类型为String
	}
}
//测试类
public class Test {

	public static void main(String[] args) {
		//创建学生类对象
		Student s = new Student() ;	
		String str = s.show() ;
		System.out.println(str);
		s.method("Java");
		s.function();
		String str2 = s.function2("hello", "world") ;
		System.out.println(str2);
		
	}
}

变量(variable)

 成员变量和局部变量的区别
   1)在类中位置不同
   成员变量:在类中,方法外
  局部变量:在方法声明上(方法头的括号中)或者在方法的定义中(方法体中)
   2)在内存中的位置不同:
   成员变量:堆内存
   局部变量:栈内存
  3)生命周期不同:
   成员变量:成员变量是随着类的加载而加载,随着类的消失而消失
   局部变量:随着方法的调用而存在,随着方法的调用完毕而消失
   4)初始化值不同
   成员变量:系统默认初始化,
   局部变量:定义一个局部变量,在使用之前必须先进行初始化,如果不初始化,则无法使用

代码示例:

package org.westos.variable;
class Variable{   
	//成员变量
	int num = 10;
	
	public void show() {
		System.out.println(num);
	}
}

//测试类
public class VariableDemo {
	
	public static void main(String[] args) {
		
		int num2 = 100 ;
		System.out.println(num2);
		//创建Vaiable类对象
		Variable v = new Variable() ;
		//使用对象名去访问这个类中的成员变量和成员方法
		System.out.println(v.num);
		
		v.show(); 
		
		
	}
}

standardclass

代码:

package org.westos.standclass;
/***
 * 一个标准类的写法:
 * 学生类
 * 		成员变量:姓名,年龄,性别
 * 		成员方法:set/getXXX()
 * 				学习,睡觉...	
 * 		构造方法:
 * 			无参构造:
 * 			有参构造
 * @author Administrator
 */
class Student{
	//成员变量
	private String name ;
	private int age ;
	private char gender ;
	
	
	//无参构造方法
	public Student() {}
	
	//有参构造
	public Student(String name,int age,char gender) {
		this.name = name ;
		this.age = age ;
		this.gender = gender ;
	}
	
	//setXXX/getXXX()方法
	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 setGender(char gender) {
		this.gender= gender ;
	}
	public char getGender() {
		return gender ;
	}
	
	//学习
	public void study() {
		System.out.println("学生在学习...");
	}
	public void sleep() {
		System.out.println("学生困了,就需要睡觉...");
	}
}


//测试类
public class StudentDemo {
	public static void main(String[] args) {
		
		//方式1:创建学生类对象
		//无参构造+set/getXXX()相结合的方式
		Student s = new Student() ;
		s.setName("高圆圆");
		s.setAge(28);
		s.setGender('女');
		System.out.println(s.getName()+"----"+s.getAge()+"---"+s.getGender());
		System.out.println("----------------------------");
		
		//方式2:直接通过有参构造形式
		Student s2 = new Student("高圆圆", 27, '女') ;
		System.out.println(s2.getName()+"----"+s2.getAge()+"---"+s2.getGender());
		
	}
}

形式参数的问题

形式参数的问题:
如果是基本数据类型,形式参数的改变对实际参数没有影响

如果是引用类型,形式参数的改变会直接影响实际参数

代码示例:

package org.westos.args;
/**
 * 形式参数的问题:
 * 			如果是基本数据类型,形式参数的改变对实际参数没有影响
 * 			如果是引用类型,形式参数的改变会直接影响实际参数
 * @author Administrator
 *
 */
class Demo{
	
	//求和的成员方法
	public int sum(int a,int b) { //形式参数为基本类型  :
		return a+b ;
	}
}

//一个学生类
class Student{
	public void show() {
		System.out.println("好好学习,天天向上....");
	}
}

class StudentDemo{
	//method方法中形式参数是一个引用类型:需要的是学生类对象  Student s = new Student () ;
	public void method(Student s) {//形式参数为引用类型  
		s.show(); 
	}
}

//测试类
public class ArgsTest {
		
	public static void main(String[] args) {
		//创建Demo类对象
		Demo d = new Demo() ;
		System.out.println(d.sum(10, 20)) ;
		System.out.println("-------------------------");
		
		//需求:调用StudentDemo中的method方法:如何调用
		//1)创建StudentDemo类对象
		StudentDemo sd = new StudentDemo() ;
		//2)形式参数是Student类型,所以创建Student类的对象
		Student s = new Student() ;
		sd.method(s);
		
	}
}