学习java的第7天--lrs

类和对象

学习编程语言,是为了描述现实世界的事物.在java中最基本的单元是类

什么是面向对象

面向过程:针对每一个步骤的具体表现

1)定义数组 2)获取最大值 3)在main方法调用完成 4)输出

                     2.1定义参照物

                     2.2遍历数组

                     2.3判断

                     2.4返回结果

面向对象是基于面向过程的

面向对象的思想特点有哪些:

1.更符合生活的思想行为习惯

2.让复杂的事情简单化

3.让我们从执行者变成指挥者

面向对象的三大特征:封装  继承   多态

举例 1

手机具有以下属性:品牌,价格,颜色

                      功能:打电话,发短信,打游戏

手机  --------------- class APhone{}

属性                     成员变量:品牌,价格,颜色(brand,price,colour)

功能                     成员方法:打电话,发短信,打游戏(call,message,playgame)

代码例子

 class Phone1{//定义一个手机类
	//成员变量私有化
        private String brand;
	private int price;
	private String colour;
	public void setBrand(String brand) {
		this.brand=brand;
	}
        //获取品牌名
	public String getBrand() {
		return brand;
	}
	public void setPrice(int price) {
		this.price=price;
	}
        //获取价格
	public int getPrice() {
		return price;
	}
	public void setColour(String colour) {
		this.colour=colour;
	}
        获取颜色
	public String getColour() {
		return colour;
	}
        //其他成员方法
	public void call() {
		System.out.println("iphone手机打电话信号有点不好嗷!");
	}
	public void message() {
		System.out.println("iphone手机发短信可以使用自制表情包");
	}
	public void playgame() {
		System.out.println("iphone手机玩游戏可以使用最高配置!");
	}
}
//测试类
public class DuiXiang{
	public static void main(String[] args) {
                //创建手机类对象
		Phone1 a=new Phone1();
                //使用公共的setXXX()/getXXX()方法
		a.setBrand("iphone11promax");
		a.setPrice(10999);
		a.setColour("green");
		System.out.println(a.getBrand()+" "+a.getPrice()+" "+a.getColour());
		//调用其他的方法
                a.call();
		a.message();
		a.playgame();
	}

}

private关键字的特点:

private:私有的,无法访问的

被private修饰的成员变量,成员方法,只能在本类中访问,外界不能直接访问

可以修饰成员变量,变量不能直接访问,但是可以间接的通过公共方法访问

 

构造方法

作用:给对象进行数据的初始化的

构造方法的格式:

1)构造方法的方法名和类名一致

2)没有具体的返回值类型

3)没有void

attention! 如果没有提供无参构造方法,系统会默认提供,建议在写标准类的时候,永远给出无参构造方法

无参构造方法

class WuCan{
	public WuCan(){
		System.out.println("劉柏汝...");
	}
}

public class DuiXiang{
	public static void main(String[] args) {
	WuCan w=new WuCan();
	//System.out.println(w);
	}
}

构造方法的注意事项:

1)无参构造方法:类名 对象名=new 类名();没有报错的原因是:如果开发者没有使用无参构造方法,系统会默认提供无参构造方法,对对象进行默认初始化,所以建议每次写代码都给出无参构造方法

2)开发中,如果给出了有参构造方法,系统将不会主动提供无参构造方法

3)构造方法是可以重载的

学习了构造方法后

标准类的写法为

1).成员变量私有化

2).提供setXXX()/getXXX()

3).提供无参构造方法/有参构造方法

3).创建对象,测试

1.通过setXXX/getXXX方法给成员变量赋值

2.通过有参构造方法赋值

下面的代码是无参构造方法和setXXX/getXXX方法和有参构造方法的集合

class wucan{
	private String name;
	private int age;
	
	public wucan(){
		String name=("凌瑞松");
		int age=(21);
		System.out.println("名字是:"+name+"  年齡是:"+age);
	}
}
 class huoqudedao{
	 private String school;
	 private String height;
	 public void setSchool(String school) {
		 this.school=school;
	 }
	 public String getSchool() {
		 return school;
	 } 
	 public void setHeight(String height) {
		 this.height=height;
	 }
	 public String getHeight() {
		 return height;
	 }
 }
class Youcan{
	private String mingzi;
    private int shuzi;
public Youcan(String mingzi,int shuzi) {
	this.mingzi=mingzi;
	this.shuzi=shuzi;
}
public void lbr() {
	System.out.println(mingzi+" "+shuzi);
}
}
public class DuiXiang{
	public static void main(String[] args) {
	wucan w=new wucan();	
	huoqudedao h=new huoqudedao();
	h.setSchool("凌瑞松就读于桂林电子科技大学");
	h.setHeight("他的身高是:173");
	System.out.println(h.getSchool()+" "+h.getHeight());
	Youcan y=new Youcan("凌瑞松",2527);
	y.lbr();
	}
}

匿名对象: 就是没有名字的对象

格式:new 类名();

匿名对象应用场景:

1)实际开发中,仅使用一次就可以了.

匿名对象直接在堆内存开辟空间,使用完毕后,立即从内存中释放调用

2)使用匿名对象的时候,可以链式编程

格式:new 类名1().方法名1(new 类名2());

this关键字

指的是访问类中的成员变量，用来区分成员变量和局部变量（重名问题）

private关键字

在内存中,成员变量随着对象的创建而存在,在堆内存中有自己的空间地址,每次都在开辟自己的空间,从内存角度考虑,很消耗内存空间,所以 java提供了关键字:static 静态修饰(静态,共享,共用):可以被多个对象共用

static关键字的特点(修饰成员变量,可以修饰成员方法)

1)随着类的加载而加载

2)优先于对象存在

3)可以被多个对象共用

4)被静态修饰的变量,方法

被静态修饰的成员 ,也成为"类成员"

class Student1{
	int num1 = 100 ;
	static int num2 = 200 ;
	
	
	//非静态的成员方法
	public void show(){
		System.out.println("show") ;
	}
	
	//静态的成员方法
	public static void function(){
		System.out.println("function") ;
	}
}

//测试类
public class JinTai{
	public static void main(String[] args){
		
		//创建一个学生类对象
		Student1 s  = new Student1() ;
		System.out.println(s.num1) ;//100
		System.out.println(s.num2) ;//200   
		s.show();
		s.function();
		System.out.println("-----------------") ;
		//类成员:属于被static修饰成员 
		//类名.成员变量
		//类名.成员方法();
		System.out.println(Student1.num2) ;
		Student1.function();
	}
}

关于static关键字的注意事项:

1)static修饰的成员,随着的类的加载而加载,优先于对象存在

在内存中,静态中不存在this关键字   this随着对象的创建而存在

2)访问问题

非静态的成员方法

可以访问静态的成员变量,也可以非静态的成员变量

可以访问静态的成员方法,也可以非静态的成员方法

静态的成员方法:
 只能访问静态的成员变量
 只能访问静态的成员方法

简单来说:静态只能访问静态

静态在使用时,不能随意使用:

如果一个变量能被多个对象使用,这个能使用static修饰

常量分类:

字面值

自定义常量(final关键字)