JAVA基础08

JAVA基础08

成员变量和局部变量

成员变量： 定义在类中方法外,没有static修饰, 存储在堆内存中,有初始值; 随着对象的创建而产生,随着对象的消失而消失

局部变量: 定义在方法中或者是方法的参数列表上,存储在栈内存中,没有初始值;局部变量随着方法的调用而产生,随着方法的结束而消失

封装

封装: 对类中的某个变量或方法进行私有化

• 私有化:private,凡是被他修饰的,统统不能被外界访问,只能本类自己访问,提供一套访问的修改的方法(get方法/set方法)
• this: 代表本类对象,谁调用了含有this的方法,this就代表谁

public class Demo1 {
	public static void main(String[] args) {
		Dog dog = new Dog();
		dog.setAge(11);
		int i = dog.getAge();
		dog.setColro("红色");
		String s = dog.getColor();
		dog.setName("小王");
		String ss = dog.getName();
		System.out.println(i+s+ss);
		dog.setSex("nv");
		String d =dog.getsex();
	}
}
class Dog{
	private String name;
	private int age;
	private String color;
	private String sex;
	public void setAge(int Age) {
		this.age=Age;
	}
	public int getAge() {
		return age;	
	}
	public void setColro(String Color) {
		this.color=Color;
	}
	public String getColor() {
		return color;
	}
	public void setName(String name) {
		this.name=name;
}
public String getName() {
	return name;
}
public void setSex(String sex) {
	this.sex=sex;
}
public String getsex() {
	return sex;	
}
}

构造方法***

构造方法的格式:

修饰符 类名(参数列表){

​ 方法体;

}

构造方法的注意事项:

1. 构造方法没有返回值,连void都没有
2. 方法名和类名相同
3. 构造方法是可以重载的(一个类中可以存在多个名字相同的方法,但是必须保证参数的个数或类型不同,与返回值无关)

构造方法何时被调用:

​ 使用new关键字创建对象的时候

如果我们没有在类中写构造方法,系统会默认为我们生成一个无参的构造方法

如果我们自己写了构造方法,那么系统则不再为我们提供

public class Student {
	private String name;
	private int age;
	//构造方法,并赋值
	public Student(String name,int age) {
		this.name = name;
		this.age = age;
	}
public Student() {
	System.out.println("aaa");
}
public Student(String aa) {
	System.out.println("bbb");
}
public Student(int a,int b) {
	System.out.println("ccc");
}
public static void main(String[] args) {
	Student s = new Student();
	Student s2 = new Student("dddd");
	Student s3 = new Student(12,3);
	Student s4 = new Student("小花",39);
}
}

javabean规范

javabean: 普通类, 只是用来描述一些对象. Teacher,Student,Mobile,Rect,Circle

1. 成员变量私有化
2. 提供getters/setters
3. 提供无参的构造方法
4. 提供有参的构造方法

生成get/set: alt + shift + s – > getters setters

生成构造方法: alt + shift + s – > constructor

生成show方法:alt + shift + s – > toString

class User{
​	private String name;
​	private String sex;
​	private int age;
​	public User() {
​		super();
​		

​```
}
public User(String name, String sex, int age) {
	super();
	this.name = name;
	this.sex = sex;
	this.age = age;
}
public String getName() {
	return name;
}
public void setName(String name) {
	this.name = name;
}
public String getSex() {
	return sex;
}
public void setSex(String sex) {
	this.sex = sex;
}
public int getAge() {
	return age;
}
public void setAge(int age) {
	this.age = age;
}
@Override
public String toString() {
	return "User [name=" + name + ", sex=" + sex + ", age=" + age + "]";
}
​```

}

同名局部变量和成员变量的区分

public class Person {
	String name = "张三";
	
	public void print(){//1
		System.out.println(name);
	}
	public void print(String name){//2
		System.out.println(name);//
	}
	
	public void print1(String name){//3
		System.out.println(this.name);
	}
	public static void main(String[] args) {
		Person p = new Person();
		System.out.println(p.name);//
		
		p.name = "李四";
		p.print();//
		
		p.print("王五");//
		
		p.print1("赵六");//
	}
}

结果:

张三
李四
王五
李四

static关键字

类中的非静态成员 使用对象调用

类中的静态方法和静态变量都是使用类名调用

类中的构造方法是使用new 关键字创建对象时调用

简述static 关键字:

​ static 用于修饰变量和方法,被static修饰的变量和方法就变成了静态变量和静态方法

​ 随着类的加载而加载,先于对象的存在,被所有的对象共享, 可以使用类名调用

​ (也可以使用对象调用,推荐使用类名调用)

​ 静态的方法中只能调用外部用static修饰的变量和方法,如果想要调用非静态的,必须要创建对象,非静态可以调用静态

public class StaticDemo {
public static void main(String[] args) {
	Static1.age=13;
	Static1.name="一";
	Static1.show();
}	
}
	class Static1 {
static String name;
static String sex;
static int age;

public static void show() {
	System.out.println(name+sex+age);	
}
}

final 关键字

final: 修饰符, 可以用来修饰 类, 方法, 变量

•  被final修饰的类不能被继承
  

•  被final修饰的方法不能被重写
  

•  被final修饰的变量值不能改变
  

•  final  修饰的变量一定要有初始值
  

•  final 修饰的引用数据数据: 地址值不能改变, 可以改变里面的属性值
  

•  一般我们在定义常量的时候,往往是final 和 static 一起使用
  

public class Final1 {
	public static void main(String[] args) {	

final int a=10;  //a的值不能再改变
final int[] arr = {1,2,3};
arr[0] = 6 ;  // arr的地址值不能再改变,但是它里面的参数可以改变	

}
}

单例设计模式

目的: 让类只能产生一个对象

饿汉式

/**
 *  design pattern
 *  单例设计模式: 让类只能产生一个实例(对象)
 */
//饿汉式
public class Singleton {
	private static Singleton s = new Singleton();//不具备懒加载
	private Singleton() {
	}
	public static Singleton getInstance() {
		return s;
	}
}

懒汉式

//懒汉式: 存在线程安全的问题;
public class Singleton2 {
	//唯一的一个对象
	private static Singleton2 s;
	/**
	 * 不让别人随便new
	 */
	private Singleton2() {
	}
	/**
	 * public:  让别人可以调用
	 * static:  使用类名调用(因为此时已经创建不了对象了)
	 */
	public static Singleton2 getInstance() {
		if(s == null) {
			s = new Singleton2();
		}
		return s;
	}
}

//测试: 
public class SingletonDemo {

	public static void main(String[] args) {
		Singleton s = Singleton.getInstance();
		System.out.println(s);
		Singleton s2 = Singleton.getInstance();
		System.out.println(s2);
	}
}