Java之旅基础篇__面向对象（一）

一、面向对象

基于面向过程的一种思想!

代表是Java语言， 强调对象的创建,使用对象调用功能! 

1.  面向对象的思想特点：
                1)更符合生活中的思想行为习惯
                2)让复杂的事情简单化
                3)让我们成从执行者变成了一个指挥者!

2.  面向对象设计原则:
        不断创建对象,使用对象,指挥该对象做事情。 
面向对象的三大特征:
                    封装,继承,多态!

3. 事物:描述现实世界的真实存在泛指的东西!  
                 学生----->学生事物
                属性:姓名,年龄,学号,性别
                行为:主要学习
    类:是描述一组事物的属性和行为的集合
    类: 是Java语言的最基本的单元  

/*
	需求:
		手机事物
		    属性:品牌(brand),价格(price),颜色(color),内存(memory)
			行为:打电话,玩游戏,聊天
			
	定义一个手机类(Phone),然后去测试手机类
	
手机类:class Phone
	成员变量:brand,price,color,memory
	成员变量:callPhone(String name),playGame(),chart() 
	
*/
//手机类
class Phone{
	//成员变量
	String brand ; //品牌
	double price ;//价格
	String color ;//颜色
	int memory ; //内存
	
	//成员方法
	public void callPhone(String name){
		System.out.println("给"+name+"打电话") ;
	}
	
	public void playGame(){
		System.out.println("手机可以王者农药") ;
	}
	
	public void chart(String name){
		System.out.println("可以跟"+name+"聊天了") ;
	}
	
	
	
}
//测试类
class PhoneTest{
	public static void main(String[] args){
		//创建一个手机类对象
		Phone p = new Phone() ;  //类名 对象名 = new 类名();
		//没有给该p对象的成员变量赋值
		System.out.println(p.brand+"---"+p.price+"---"+p.color+"---"+p.memory) ;
		
		//给成员变量赋值
		p.brand = "华为p40" ;
		p.price = 4999.99;
		p.color = "翡翠绿" ;
		p.memory = 16 ;
		System.out.println(p.brand+"---"+p.price+"---"+p.color+"---"+p.memory) ;
		//访问成员方法
		p.callPhone("库里");
		p.playGame() ;
		p.chart("库里") ;
		
	}
}

     

二、三大特征之一-----封装

1.  将类中成员变量私有化(private),对外提供公共的访问方法(权限足够大)

 私有化的成员变量:只能在本类中,外界不能访问的!

2.  private关键字的特点:
        1)private可以修饰一个类中的成员变量,也可以成员方法
        2)被private修饰的成员变量或者是成员方法只能在本类中方法,外界不能访问的!(保证数据的安全性)

//定义一个学生类
class Student{
	//成员变量私有化
	private String name ; //姓名
	private int age; //年龄
	//提供公共的访问方法赋值 setXXX/getXXX方法 XXX对应的属性名称
	//给姓名赋值
	public void setName(String n){ //传递一个具体的"字符串"
		 name = n ; 
	}
	//给年龄赋值
	public void setAge(int a){ //传递一个具体的 年龄值
		age = a ; //a = 20 ;
	}
	
	//获取姓名
	public String getName(){
		return name ;
	}
	//获取年龄
	public int getAge(){
		return age ;
	}
	//其他的成员方法:
	public void study(){
		System.out.println("学习Java中的面向对象...") ;
	}
}

//测试类
class StudentTest{
	public static void main(String[] args){
		//创建一个学生类
		Student s = new Student() ;
		//name,age已经私有化了,只能通过公共方法赋值和获取值
		s.setName("杜兰特") ;
		s.setAge(39) ;
		System.out.println(s.getName()+"---"+s.getAge()) ;
		s.study() ;
	}
}

三、匿名对象

匿名对象：
    new 类名();
    1.仅仅使用一次，使用完毕会被内存释放掉（节省内存空间）
    2.匿名对象也可以作为参数传递
    注意：建议在使用匿名对象时，不要多次使用！

//自定义一个学生类
class Student{
	public void study(){
		System.out.println("好好学习，天天向上");
	}
}
//自定义一个StudentDemo类
class StudentDemo{
	public void method(Student s){//引用类型（具体类）作为一个形式参数
		s.study();
	}
}
//测试类
class NoNameDemo{
	public static void main(String[] agrs){
		//访问StudentDemo中的method方法
		StudentDemo stu=new StudentDemo();
		Student s=new Student();
		stu.method(s);
		System.out.println("----------------------");
		//使用匿名对象
		stu.method(new Student());
		System.out.println("----------------------");
		//链式编程，开发中不常用
		new StudentDemo().method(new Student());
		
	}
}

四、构造方法

1.什么是构造方法:
        1)方法名和类名相同
        2)没有具体的返回值类型
        3)并且连void都没有
        
        权限修饰符 + 方法名（类名）(){  
        }
        构造方法主要作用:就是给该对象中的数据进行初始化!

2.注意事项:
       1)在一个类中,我们不写无参构造方法,系统会默认的提供一个无参构造方法,   
       2)如果我们提供一个有参构造方法,系统不会在提供无参了,如果使用无参构造方法创建对象,就会报错!
                    (建议手动给出无参构造方法)!

class Teacher{

	//定义两个成员变量
	private String name ;
	private int age ;
	
	
	//永远建议手动给出无参构造方法
	public Teacher(){}
	//提供一个有参构造方法,带一个参数的字符串类型的
	public Teacher(String name){
		this.name = name ;//通过有参构造赋值 "高圆圆"
		//System.out.println("这是带一个String类型参数的有参构造...") ;
	}
	//提供一个有参构造方法,带一个int类型参数的
	public Teacher(int age){
		System.out.println("这是带一个int类型的有参构造...") ;
	}
	
	public Teacher(String name,int age){
		System.out.println("这是一个带两个参数有参构造...") ;
	}
	
	//获取成员变量的值
	public String getName(){
		return name ;
	}
}
//测试类
class ConstructorDemo2{
	public static void main(String[] args){
		//提供无参构造方法:
		Teacher t = new Teacher() ;
		System.out.println(t);
		System.out.println("------------------------") ;
		//创建一个新的Teacher对象,通过带一个String类型的构造方法
		Teacher t2 = new Teacher("库里") ;
		System.out.println(t2.getName()) ;
		System.out.println(t2);
		System.out.println("------------------------") ;
		Teacher t3 = new Teacher(30) ;
		System.out.println(t3);
		System.out.println("------------------------") ;
		//给成员变量赋值:有参构造方法初始化
		Teacher t4 = new Teacher("库里",30) ;
		System.out.println(t4);
		
	}
}

五、成员变量和局部变量

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

    1)在类中的位置不同
    局部变量:在方法定义中或者是方法声明上的变量
    成员变量:在类中,方法外定义的变量
    2)在内存中的位置不同
    局部变量:在栈内存中存储  跟方法有关
    成员变量:在堆内存中存储     跟类的对象有关
    3)生命周期不同
    局部变量:随着方法的调用而存在,随着方法的调用完毕而消失!
    成员变量:随着对象的创建而存在,随着对象的创建完毕并且使用完毕,等待垃圾回收器回收掉掉(GC)之后才消失!(不会立即被回收)                                 
    4)初始时机不同:
    局部变量:在方法定义中或者方法声明上的变量,必须在使用之前进行数据初始化,否则"可能尚未初始化变量"
    成员变量:跟对象有关系,在堆内存中,即使这个成员变量没有赋值,系统会根据变量的类型给这个变量进行默认初始化

class Variable{
	//int num2 = 10 ;
	int num2 ; //系统默认初始化 0，成员变量
	public void show(){
		//方法中定义
		int num = 100 ;     //局部变量:必须使用之前赋值,否则报错!
		System.out.println(num) ;
    }
//测试类
class VariableDemo{
	public static void main(String[] args){
		//创建该类对:类名 对象名 = new  类名() ;
		//对象名.show();
		Variable v = new Variable() ;
		v.show() ;
		System.out.println(v.num2) ;//对象名.成员变量;
	}
}

六、一个标准类的写法

//定义一个手机类
class Phone{
	//属性私有化
	private String brand ;//品牌
	private int price ; //价格
	private String color ; //颜色
	
	//提供对外的公共访问方法
	public void setBrand(String brand){
		this.brand = brand ;
		//brand = brand ; //出现冲突:局部变量隐藏成员变量,默认成员变量
	}
	public void setPrice(int price){
		this.price = price ;
	}
	public void setColor(String color){
		this.color = color ;
	}
	//获取值
	public String getBrand(){
		return brand ;
	}
	public int getPrice(){
		return price ;
	}
	public String getColor(){
		return color ;
	}
	
	//其他成员方法
	public void sendMsg(String name){
		System.out.println("给"+name+"发短信...") ;
	}
	public void playGame(){
		System.out.println("手机可以玩游戏...") ;
	}
}
//测试类
class PhoneTest{
	public static void main(String[] args){
		//创建手机类对象
		Phone p = new Phone() ;
		//setXXX方法赋值
		p.setBrand("华为p40") ;
		p.setPrice(4999);
		p.setColor("橙色") ;
		System.out.println(p.getBrand()+"----"+p.getPrice()+"----"+p.getColor());
		p.sendMsg("库里");
		p.playGame() ;
        System.out.println("-----------------------------");
        Phone p1 = new Phone("oppo",3999,"黑色") ;
        System.out.println(p1.getBrand()+"----"+p1.getPrice()+"----"+p1.getColor());
		p1.sendMsg("库里");
		p1.playGame() ;
	}
}

七、static关键字

静态static关键字的特点:
        1)被static修饰的变量/方法 都随着类的加载而加载
        2)被static修饰的 优先于对象存在
        3)被static修饰的可以被多个对象共用 
            有共享,共用
            举例:
                班级的编号(同一个班级的都在共用编号)
                水杯(不能被共用)
            也在告诉我们,什么时候将变量定义静态变量
        4)被静态修饰的成员变量或者成员方法 ,
                可以被类名直接访问(推荐访问方式)
                    类名.成员方法;
                    类名.成员方法();
                但是,也可以用该类对象来访问该成员(不推荐的!)

class Demo{
	//成员变量
	int num = 100 ;
	//静态成员变量
	static int num2 = 50 ;
	//成员方法
	public void show(){
		System.out.println("show Demo") ;
	}
	//静态的成员方法
	public static void method(){
		System.out.println("method Demo") ;
	}
	
}
//测试类
class StaticDemo{
	public static void main(String[] args){
		Demo d = new Demo() ;
		//访问非静态的成员变量,成员方法
		System.out.println(d.num) ;
		d.show();
		System.out.println("-------------") ;
		
		//对象名来访问静态成员
		System.out.println(d.num2) ;
		d.method();
		
		System.out.println("-------------") ;
		//推荐方式:静态成员 直接使用类名访问(static静态的随着类的加载而加载)
		System.out.println(Demo.num2) ;
		Demo.method();
	}
}

static关键字的注意事项：
        1)在static中,是没有this关键字的! (this:代表当前类的对象的地址值,对象已经创建了而static修饰的和类有关系);
        2)关于成员方法的访问问题:
                非静态的成员方法
                    既可以访问静态的成员变量,也可以访问非静态的成员变量
                    既可以访问静态的成员方法,也可以访问非静态的成员方法;
                
                静态的成员方法
                    简单记:静态只能访问静态

故静态的成员方法要访问非静态的就要用到对象创建，然后通过提供的公共方法访问

class Demo2{
	
	//定义一个成员变量
    int num = 100 ;
	
	//静态成员变量
	static int num2 = 200 ;
	
	//成员方法
	public void show(){
		System.out.println(num2) ;
		System.out.println(num) ;
	}
	//成员方法
	public void method(){
		show() ;
		function() ;
	}
	
	//静态的成员方法
	public static void function(){
		System.out.println("这是静态的function方法...") ;
	}
	
	//静态的成员方法
	public static void function2(){
		System.out.println(num2) ;
		//System.out.println(num) ; // 无法从静态上下文中引用非静态 变量 num
		//show() ; 无法从静态上下文中引用非静态 方法 show()
		function() ;
	}
	
	
}
//测试
class StaticDemo2{
	public static void main(String[] args){
		//创建Demo2类的对象
		Demo2 d = new Demo2() ;
		d.show() ;
		System.out.println("-------------------------") ;
		d.method() ;
		System.out.println("-------------------------") ;
		d.function2() ;
		System.out.println("-------------------------") ;
		int result = sum(10,20) ; //静态只能访问静态!
		System.out.println(result);
	}
	
	//求两个数据之和
	public static  int sum(int a,int b){
		return a + b ;
	}
}