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;
}
}
构造方法***
构造方法的格式:
修饰符 类名(参数列表){
方法体;
}
构造方法的注意事项:
- 构造方法没有返回值,连void都没有
- 方法名和类名相同
- 构造方法是可以重载的(一个类中可以存在多个名字相同的方法,但是必须保证参数的个数或类型不同,与返回值无关)
构造方法何时被调用:
使用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
- 成员变量私有化
- 提供getters/setters
- 提供无参的构造方法
- 提供有参的构造方法
生成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);
}
}