Java（学习笔记四，kk自用）

• 类和对象的定义格式

类的定义：

class 类名称{
		属性名称；
		返回值类型 方法名称(){}
}

对象的定义：
类名称 对象名称 = new 类名称();
访问类中的属性：
对象.属性;
调用类中的方法：
对象.方法();

举例：

class Horse{
		String name;
		int age;
		public void run(){
			System.out.println("wdnmd");
}
}

public class Test1{
	public static void main(String[] args){
		Horse h=new Horse();
		h.name="qz";
		h.age=18;
		h.run();
}
}

匿名对象：

new Horse().eat();//只能使用一次，用完后该对象就会被释放

h=null;//把对象释放
	  //h.eat();  当对象不存在时，调用该对象的属性和方法将会报错

• new关键字表示创建一个对象
• new关键字表示实例化对象
• new关键字表示申请内存空间
• 注意：如果使用一个没有申请内存空间的对象，会报空指针异常：
  java.lang.NullPointerException

• 对象之间的赋值，相同类型才可以赋值

Horse h1=null;
Horse h2=null;
h1=new Horse();
h1.name="小白";
h1.age=4;
h2=h1;		//注意这里的赋值

这里一旦改变h2.name那么h1.name也会发生改变

堆中的对象没有被任何引用变量所指向时，该对象会被JVM的GC程序认为是垃圾对象，从而被回收。

private表示私有的属性或方法，只能在本类中访问
通常在一个类中，属性都私有化，并对外提供getter and setter方法

package kk;
import java.util.*;
public class hello_world{
    public static void main(String[] args){
        Person p1=new Person();
        p1.setName("菲菲");
        p1.setAge(10);

    }

};

class Person{
    //属性的封装
    private String name;
    private int age;

    //getter and setter

    //对外提供一个名为name属性设值的方法
    public void setName(String name)
    {
        this.name=name;
    }

    //对外提供一个获取name属性的方法
    public String getName(){
        return name;

    }
    public void setAge(int age)
    {
        this.age=age;

    }
    public int getAge(){
        return age;

    }
};

成员变量和局部变量

1. 在类中的位置不同

• 成员变量：在类中定义
• 局部变量：在方法中定义或者方法的参数

2. 在内存中的位置不同

• 成员变量：在堆内存（成员变量属于对象，对象进堆内存）
• 局部变量：在栈内存（局部变量属于方法，方法进栈内存）

3. 生命周期不同

• 成员变量：随着对象的创建而存在，随着对象的销毁而消失
• 局部变量：随着方法的调用而存在，随着方法的调用完毕而消失

4. 初始化值不同

• 成员变量：有默认初始化值，引用类型默认为null
• 局部变量：没有默认初始化值，必须定义，赋值，然后才能使用

注意：
局部变量名称可以和成员变量名称一样，在方法中使用的时候，采用的是就近原则。

• 构造方法是在类中定义的，构造方法的定义格式：方法名称与类名称相同，无返回值类型的声明。

package kk;
import java.util.*;
public class hello_world{
    public static void main(String[] args){
        Dog dog=new Dog();
        Dog dog1=new Dog("wangwang",5);

    }

};

class Dog{
        //构造方法的重载
        //构造方法也可以调用构造方法
    public Dog(){
        System.out.println("构造方法执行了！");

    }

    public Dog(String name,int age){
        this.name=name;
        this.age=age;
        System.out.println("带两个参数的构造方法！");
    }






    //属性的封装
    private String name;
    private int age;

    //getter and setter

    //对外提供一个名为name属性设值的方法
    public void setName(String name)
    {
        this.name=name;
    }

    //对外提供一个获取name属性的方法
    public String getName(){
        return name;

    }
    public void setAge(int age)
    {
        this.age=age;

    }
    public int getAge(){
        return age;

    }
};

• this关键字
  调用类中的属性、调用类中的方法或构造方法、表示当前对象。
  表示当前对象：在方法被调用的过程中，哪个对象调用了方法，在方法内的this就表示谁。

public class hello_world{
    public static void main(String[] args){
        Cat cat=new Cat();
        cat.setName("mimi");
        cat.setAge(3);
    }
}

class Cat{
    private String name;
    private int age;
    public void setName(String name)
    {
        this.name=name;
    }
    public String getName(){
        return name;
    }
    public void setAge(int age)
    {
        this.age=age;
    }
    public int getAge()
    {
        return age;
    }

    public void eat(){
        //在方法中使用this调用类中的其他方法或属性，this可以省略，this前面可以使用当前的类名
        //在后面的内部类知识点中会涉及到
        System.out.println("我是"+Cat.this.getName()+"我爱吃鱼！");
    }

        };

值传递与引用传递：
当变量存的是地址的时候，就是引用传递；当变量存的是值（基本数据类型）的时候，就是值传递。

但是注意String类型的传递，字符串本身就是一个对象，它的传递比较特殊。


对象的一对一关系：

package kk;
import java.util.*;
public class hello_world{
    public static void main(String[] args){
        Hero hero=new Hero("刘备",300);
        Weapon weapon=new Weapon("双股剑",3);

        //把两个对象关联起来
        hero.setWeapon(weapon);
        weapon.setHero(hero);

        //通过英雄来获取他的信息
        String name = hero.getName();
        int age = hero.getAge();
        Weapon w=hero.getWeapon();
        System.out.println("我是"+name+",我"+age+"岁,我的武器是"+w.getName()+",排行"+w.getGrade()+"级");
    }

};

class Hero{
    private String name;
    private int age;
    private Weapon weapon;  //一对一的关系


    public void setWeapon(Weapon weapon){
        this.weapon=weapon;
    }

    public Weapon getWeapon(){
        return weapon;
    }

    public Hero(String name,int age){
        this.age=age;
        this.name=name;
    }
    public void setName(String name){
        this.name=name;
    }
    public String getName(){
        return name;
    }
    public void setAge(int age){
        this.age=age;

    }
    public int getAge(){
        return age;
    }



}

class Weapon{
    private String name;
    private int grade;
    private Hero hero;

    public void setHero(Hero hero)
    {
        this.hero=hero;

    }
    public Hero getHero(){
        return hero;
    }

    public Weapon(String name,int grade){
        this.name=name;
        this.grade=grade;
    }
    public void setName(String name){
        this.name=name;
    }
    public String getName(){
        return name;
    }
    public void setGrade(int grade){
        this.grade=grade;
    }

    public int getGrade(){
        return grade;
    }

        }

static关键字：

1. 使用static关键字修饰一个属性：
   声明为static的变量实质上就是全局变量
2. 使用static关键字修饰一个方法：
   通常，在一个类中定义一个方法为static，那就是说，无需本类的对象即可调用此方法
3. 使用static关键字修饰一个类（内部类）

• 静态变量或方法不属于对象，依赖类
• 静态变量只存一份，在静态方法区中存储
• 静态方法不能访问非静态的属性和方法，只能访问静态

声明为static的方法有以下几条限制：
它们仅能调用其他的static方法
它们只能访问static数据
它们不能以任何方式引用this或supper

• 什么时候用static？
  所有对象共同的属性或方法，那么我们应该定义为静态的。

• 静态代码块
  static { } 在第一次使用的时候被调用（创建对象），只会执行一次，优于构造块执行，我们在项目开发中，通常会使用静态代码块来初始化只调用一次的数据

单例设计模式：

保证一个类仅有一个实例，并提供一个访问它的全局访问点。

1. 构造方法私有化
2. 声明一个本类对象
3. 给外部提供一个静态方法获取对象实例

两种实现方式：

• 饿汉式
• 懒汉式