Java面向对象基础1

     面向对象

      要设计一个计算机程序，一种方法就是根据问题的解决步骤，将程序组织为一系列的线性代码或函数，然后一次调用，即面向过程程序设计，如C语言程序设计。面向对象程序设计语言则是从另一个角度看待计算机程序，其核心是引入了对象的概念，从而可以模拟现实世界中的任何事物，与人类的思维习惯一致。当需求单一，或者简单时，我们一步一步去操作没问题，并且效率也挺高。可随着需求的更改，功能的增多，发现需要面对每一个步骤很麻烦了，这时就开始思索，能不能把这些步骤和功能在进行封装，封装时根据不同的功能，进行不同的封装，功能类似的封装在一起。这样结构就清晰了很多。用的时候，找到对应的类就可以了。这就是面向对象的思想。

       面向对象的思想特征:
            1)面向对象更符合我们的生活中的行为思想习惯
            2)面向对象将我们从执行者变成了指挥者,指挥对象做事情
            3)面向对象简单性体现在这里:让我们事情从复杂性--->简单化
       举个通俗的例子，就拿做饭来讲，
            面向过程：自己去买菜--->洗菜--->切菜--->炒菜--->吃菜
            面向对象：找个女朋友并教会自己的女朋做饭（买菜--->洗菜--->切菜--->炒菜），之后让女朋友为你做饭--->吃菜。
            如果这辈子只吃一两次饭的话，显然面向过程会比较简单，可是呢？女朋友将相当于Java里的类，需要的时候光调用该类中的成员变量和方法就行了。面向过程是基于面向过程的语言。
           面向对象的特征：封装、继承、多态；

一、类

     类是一种具有相关属性和行为的集合，Java中类是种复合数据类型，是组成Java程序的基本元素，它封装了一类对象的属性（成员变量）和改变这些属性的方法。与简单数据类型的使用不同，用户必须先定义类，并生成该类的对象，然户通过对象去访问成员变量和方法。

        定义类：

        类通过关键字class进行标识，格式如下：
           [类修饰符] class 类名 [extends 父类名] [implements 接口名]

           ｛
        ...//    类体，包括定义类的成员变量和方法
        ｝

    定义成员变量：

        成员变量的定义格式：
        [修饰符] 数据类型 成员变量名;
               *成员变量的类型可以是任意的数据类型，在一个类中，成员变量名是唯一的。类成员变量在所有方法体之外，因此它的作用域是整个类。类中的所有方法均可直接访问成员变量。
        成员变量和局部变量的区别
          1)在类中位置不同
              成员变量:类中,方法外
              局部变量:方法声明上,或者再方法定义中
          2)在内存中的位置不同:
              成员变量:堆内存
              局部变量:栈内存
          3)生命周期不同:
              成员变量:成员变量是随着类的加载而加载,随着类的消失而消失
              局部变量:随着方法的调用而存在,随着方法调用完毕而消失
          4)初始化值不同
              成员变量:初始化由系统默认初始化,对于成员变量,可以不给初始化值,由系统给,然后显示初始化;
              局部变量:定义一个局部变量,必须进行初始化,如果不初始化,无法使用(在使用之前进行初始化)

    定义成员方法：

         成员方法的定义格式：
        [修饰符] 返回值类型 方法名（[参数列表]）
            ｛
               方法体    
            ｝

        *返回值类型可以是任意的数据类型，如果方法不返回任何值，则声明为void（空）。方法体则用来描述对象的行为。（关于方法的详细介绍在Java基础总结中return语句下有详细讲解）

 	//定义一个学生类，其中含有的属性为：学号，姓名，班级；学生的行为（方法）：学习，玩游戏；
	public class Student {
       public int sid;//成员变量:学号
       public String name;//姓名
       public String grade;//班级
       public void study() {
    	   System.out.println("学生在学习");//成员方:法学习
       }
       public void play() {
    	   System.out.println("学生在玩游戏");//玩游戏
       }
	} 

二、对象

      我们可以吧很多有属性有特点的东西看作成对象，因为根据属性或特点可以将这些东西归为一类。
    比如 把汽车看成一个类，大众就是一个对象，宝马也是一个对象，还有奔驰，奥迪......。它们都具有共同的属性，如价格，颜色，发动机排量，轴距......

        创建对象：

            声明：声明一个对象，包括对象名称和对象类型。
            实例化：使用关键字new来创建一个对象。（类名 对象明=new 类名（参数））

            初始化：使用new创建对象时，会调用构造方法初始化对象。

class Student {
	   public int sid;//成员变量:学号
	   public String name;//姓名
	   public String grade;//班级
	   public char sex;//性别
	   public void study() {
		   System.out.println("学生在学习");//成员方:法学习
	   }
	   public void play() {
		   System.out.println("学生在玩游戏");//玩游戏
	   }
	}
	public class Studentdemo {
		public static void main(String[] args) {
			Student st1=new Student();//实例化对象
			st1.name="常新玉";//赋值
			st1.sid=050227;
			st1.grade="五年级二班";
			st1.sex='女';
	
	}
	}

使用对象：

             格式：
        对象名.成员变量名
        对象名.成员方法名

 class Student {
	   public int sid;//成员变量:学号
	   public String name;//姓名
	   public String grade;//班级
	   public char sex;//性别
	   public void study() {
		   System.out.println("学生在学习");//成员方:法学习
	   }
	   public void play() {
		   System.out.println("学生在玩游戏");//玩游戏
	   }
	}
	public class Studentdemo {
		public static void main(String[] args) {
			Student st1=new Student();//实例化对象
			st1.name="常新玉";//赋值
			st1.sid=050227;
			st1.grade="五年级二班";
			st1.sex='女';
			System.out.println(st1.name+"  "+st1.sid+"  "+st1.sex+"     "+st1.grade);
			st1.play();
			st1.study();
	}
	}
显示：
    常新玉  20631  女     五年级二班
    学生在玩游戏
    学生在学习

匿名对象：

        匿名对象就是创建对象时没有对象名

        格式：new 类名（）；

package org.classdemo.text2;
class Student1{
	String name;
	int id;
	int age;
	public  void show() {
		System.out.println("匿名对象;"+name);
	}
	public void meet(Student1 s1) {//参数为引用Student1类的对象
	System.out.println(s1.age+"岁");
}
}

public class Noname {
public static void main(String[] args) {
	Student1 s=new Student1();//创建一个名为s的对象
	s.name="李铭";//进行赋值
	s.show();//使用所创建的对象s调用类中的方法
	s.age=7;
	s.meet(s);
	System.out.println("----------------------------");
	new Student1();//创建匿名对象
	new Student1().name="李铭";//进行赋值
	new Student1().show();//当使用匿名对象调用方法时相当于从新创建了一个匿名对象，所以匿名对象不要多次使用
	new Student1().age=7;
	new Student1().meet(new Student1());//匿名对象可以作为参数值传递
	
}
}

匿名对象;李铭
7岁
----------------------------
匿名对象;null
0岁

     匿名对象的优势在于不需要创建一个有名对象，从而掉用类中成员方法，或成员变量。

 构造方法：

        当一个对象被创建时候，构造方法用来初始化该对象。构造方法和它所在类的名字相同，但构造方法没有返回值。 通常会使用构造方法给一个类的实例变量赋初值，或者执行其它必要的步骤来创建一个完整的对象。 不管你与否自定义构造方法，所有的类都有构造方法，因为Java自动提供了一个默认无参构造方法，它把所有成员初始化。 一旦你定义了自己的构造方法，默认构造方法就会失效。
      构造方法注意点：
          1)方法名和类名相同

          2)构造方法,连void都没有

 class Student {
	   public int sid;//成员变量:学号
	   public String name;//姓名
	   public String grade;//班级
	   public char sex;//性别
	   Student(int sid,String name,String grade,char sex){
		   this.grade=grade;//用构造方法对成员变量初始化
		   this.name=name;//this:代表是当前类对象,或者是(当前类对象的引用),解决局部隐藏了成员变量
		   this.sid=sid;
		   this.sex=sex;
	   }
	   public void study() {
		   System.out.println("学生在学习");//成员方:法学习
	   }
	   public void play() {
		   System.out.println("学生在玩游戏");//玩游戏
	   }
	}
	public   class Studentdemo {
		public static void main(String[] args) {
			Student st1=new Student(050227,"常新玉","五年级二班",'女');
			System.out.println(st1.name+"  "+st1.sid+"  "+st1.sex+"      "+st1.grade);
			st1.play();
			st1.study();
	}
	}
显示：
    常新玉  20631  女     五年级二班
    学生在玩游戏
    学生在学习

构造方法是可以重载的。

class Student{
	
	private String name ;
	private int age ;

	//无参构造
	public Student() {
		System.out.println("学生类的无参构造..");
	}
	//有参构造
	public Student(String name) {
		this.name = name;
		
		System.out.println("带一个String类型参数的有参构造");
	}

	public Student(int age) {
		this.age =age ;
		System.out.println("带一个int类型参数的有参构造");
	}
	//带两个参数
	public Student(String name,int age) {
		this.name =name ;
		this.age = age ;
		System.out.println("带两个参数的有参构造...");
	}
   }

 //测试类
 public class Studentdemo {

	public static void main(String[] args) {
		
		//创建学生类对象
		Student y = new Student() ; 
    	Student t = new Student("高成") ; 
		Student t1= new Student(20) ;
		Student t2 = new Student("高成", 20) ;

	}
 }
显示：
	学生类的无参构造..
	带一个String类型参数的有参构造
	带一个int类型参数的有参构造
	带两个参数的有参构造...

修饰符

   public
     public可以同时修饰类和成员变量，成员方法。如果public修饰一个类名，如public classA{...}，则表示该类可以被所有的其他类访问或引用，
即其他类中可以创建该类的实例，访问该类的所有可见成员变量，调用可见方法。
     如果类成员（变量和方法）用public修饰，表示该类的成员不仅可以被其内部成员访问，而且可以被其他类直接访问，外界可直接存取公有数据和公有方法。
  private
      private主要用于修饰类成员，表示该类成员只能被自身访问任何其他类（包括该类的子类）都无权访问和引用。将不希望他人随意引用或修改的数据和方法设置为private，这将使得私有成员对其他类不可见
，只有通过声明为public的方法才可以对数据进行访问，从而达到信息隐藏和封装的目的。

    我们可以通过【SetXXX()/GetXXX()方法:公共访问方法】来访问被private修饰的类成员。

class Student{
	
	//成员变量
	private String name ;
	private int age ;
	private int sId;
	private char sex ;
	
	////提供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 int getsId() {
		return sId;
	}
	public void setsId(int sId) {
		this.sId = sId;
	}
	public char getSex() {
		return sex;
	}
	public void setSex(char sex) {
		this.sex = sex;
	}

	//学习
	public void study() {
		System.out.println("学生爱Java...");
	}
	
	//打游戏
	public void playGame() {
		System.out.println("学生玩游戏..");
	}
	
	}
     class Studentdemo{
    	 public static void main(String[] args) {
			Student t=new Student();
			t.setName("王鑫");
			t.setAge(15);
			t.setSex('男');
			t.setsId(132014);
			System.out.println(t.getName()+"  "+t.getAge()+"  "+t.getSex()+"  "+t.getsId());
			
		}
     }
显示：
    王鑫  15  男  132014

static
      关于static关键字:
         1)静态随着类的加载而加载
          2)static优先于对象存在
              如:main  public static void main(..){...}
          
          3)static共享数据,可以被多个对象进行共享
              举例:    饮水机(staticd的:共享的)
                      水杯(不能共享的...)
          4)由于静态变量和静态方法都属于整个类，因此可以通过类名直接访问，而无须船舰该类的实例，格式如下：
                类名.静态变量名；
                类名.静态方法名（[实参列表]）
           static用法:
 
          一个类中可有静态变量,也可以有非静态
                  可以有静态成员方法,也可以有非静态的成员方法
                  静态的方法只能访问静态变量,或者是静态的方法
                  非静态的方法,既可以访问静态变量也可以非静态的变量...
 

                 简单记:静态只能访问静态

 class Phone{
	static String brand;
	static String color;
	static int price;
	public String size;
	public static void call() {
		System.out.println("用手机打电话");
	}
	public void testphone(String size,String color) {//非静态可以访问静态的成员变量和方法
		System.out.println(color+"的"+size+"手机");
		call();
	}
}
public class Phonedemo {
public static void main(String[] args) {
	Phone.brand="iphone";
	Phone.color="土豪金";
	Phone.price=6888;
	Phone.call();
	System.out.println(Phone.color+"  "+Phone.brand+"   "+Phone.price);
	Phone p=new Phone();
	p.testphone("plus", "红色");
}
}
显示：
		用手机打电话
		土豪金  iphone   6888
		红色的plus手机
		用手机打电话