面向对象 抽象--类--对象 垃圾回收机制 包

面向对象是一种思维方式 从现实存在的个体出发(学生)

抽象是一个分析的过程 分析系统里面都要哪些信息参与 需要找出数据 行为

数据和行为形成类

找出对象共有的数据,并且在类中定义为属性(成绩 年龄 电话 姓名)

找出对象共有的行为，并且定义为类的方法(选课 查课表 )

面向对象概念

抽象

从事物中舍弃个别的非本质特征，抽取共同的本质特征 只考虑与问题域相关的信息

类

类是一组具有相同属性和行为的对象的抽象，类的作用是用来创建对象，对象是类的一个实例

类的成员包括四个 成员属性 成员方法 代码块 内部类

类的定义

成员指的是类的成员

在类中定义的成员变量(变量)就是属性 属性就是定义变量

类的方法就是成员方法(方法)

属性和方法

属性有默认值 和数组类型默认值相同 方法中可以直接使用

方法中定义的变量和方法的形参是局部变量 类中定义的变量叫做属性(成员变量 全局变量)

属性和局部变量的对比

1. 属性定义在类中 局部变量定义在方法中

2.属性可以在本类里的任何方法中使用, 局部变量仅限于在当前方法中使用

3.属性有默认值 局部变量没有默认值 使用局部变量必须先赋值

属性在类里面可以先试用再声明 局部变量必须先声明再使用

允许定义同名的属性和局部变量 方法内部 同名的局部和属性   局部变量优先级高

如果在有同名局部变量的方法中想使用属性需要用this.

例:

public class Dog {
	
	String name;//属性 成员变量 全局变量 定义在类中
	int age;
	//属性可以在本类中所有的方法中直接使用
	//属性是有默认值的
	
	public void bark() {//方法
		int x = 0 ;//局部变量 方法体中定义的变量 方法的形参
		//局部变量仅限于当前方法
		//局部变量没有默认值 使用局部变量必须先赋值
		System.out.println(name+"正在狂叫"+x);
	}
	public void eat() {
		System.out.println(name+"正在吃狗粮");
		//允许定义和属性同名的局部变量
		int age = 8;
		//方法内部 同名的局部和属性   局部变量优先级高
		System.out.println(age);
		System.out.println(this.age);//如果在方法中想使用同名属性需要用this.
	}
	public static void main(String[] args) {
		Dog d = new Dog ();
		d.bark();
		d.eat();
	}
}

创建一个类

创建类需要有属性(数据)和方法(行为)

方法的具体代码 是对属性进行一些访问

类名和属性名一般使用名词 

方法名首个单词一般使用动词

例:

public class Employee {
	//属性-数据 
	String name;
	int age;
	double salary;
	
	//方法-行为
	//方法的具体代码 是对属性进行一些访问
	public void showName() {
		System.out.println("员工姓名:"+name);
	}
	public void showAge() {
		System.out.println("员工年龄:"+age);
	}
	public void updateName(String n) {
		name = n;
	}
	public double getSalary() {
		return salary;
	}
}

对象的创建

类是抽象的定义 定义好的属性和方法不能直接使用 必须创建这个类的对象才能使用

类(class)是对某一类事物的描述,创建对象的模板

对象(object)是实际存在的某类事物的个体,对象是类的实例 也称为实例(instance)

类是抽象 不具体的,对象是具体的

实例化 根据类创建对象的过程

匿名对象:没有对象名的对象 一般方法或属性在执行一次的时候利用匿名对象(new 类名())

创建对象语句

类名 对象名(变量名)  =  new  类名();

使用  .  运算符访问属性和方法  .  理解为里面的 是取值运算符

public class Employee {
	//属性-数据 
	String name;
	int age;
	double salary;
	
	//方法-行为
	//方法的具体代码 是对属性进行一些访问
	
	public void showName() {
		System.out.println("员工姓名:"+name);
	}
	public void showAge() {
		System.out.println("员工年龄:"+age);
	}
	public void updateName(String n) {
		name = n;
	}
	public double getSalary() {
		return salary;		
	}
	public static void main(String[] args) {
		//创建对象
		Employee e1 = new Employee();
		//使用.运算符访问属性和方法  .理解为里面的
		e1.name = "王健林";
		e1.age = 60 ;
		e1.salary = 8888.88;
		
		e1.showName();//结果为 员工姓名:王健林
		e1.showAge();//结果为 员工年龄:60

		Employee e2 = e1;
		e2.updateName("王思聪");
		e1.showName();//结果为 员工姓名:王思聪
		Employee e3 = new Employee();

对象变量在堆区有多少数据取决于类的属性个数 元素下标为属性名 有默认值

垃圾回收机制 finalize()

垃圾回收机制 是将无法使用的对象或数组所占用的内存空间回收
某一个对象或数组的地址没有被任何一个引用变量所存储 那么它就是垃圾对象
java虚拟机中一个垃圾回收的机制负责回收垃圾对象
只有当堆区空间达到临界值时 才会启动垃圾回收 垃圾回收启动时 所有其他程序暂停运行

对象会被回收的情况:

1. 对象的引用被赋值为null  person p = new person(); p = null;

2.匿名对象

3.生命周期结束对象

构造方法 构造器

构造方法(构造器 constructor)只在创建对象时调用 在new的后面才能调用构造器

对象的创建 很多时候都是在别的类中

构造器语法特点

1.构造方法(构造器)的名字必须和类同名(其他方法也可以与类同名 但必须写返回值类型)

2.构造方法没有返回值类型 也没有void

3.构造方法中可以写return关键字 但是不能返回一个值

每一个类里面至少需要一个构造器

不一定要写构造器 java程序在编译时会自动提供一个默认的无参的空构造器

如果写了构造器 那么java程序将不会自动提供默认的无参的空构造器

实际应用中一个类最好定义两个构造器

1.默认的无参的构造器

2.有参的构造器 通过参数的传递给属性赋初值 参数的个数和类型由类的属性来决定

	public class Pet {
	
	String name;
	String breed;//品种

    public Pet() {
	}
	
	
	public Pet(String name, String breed) {
		this.name = name;
		this.breed = breed;
	}

创建两个对象时 堆区会创建两个分别的领域

构造器的重载

可以自动生成构造器 鼠标右键 选择source 倒数第二个和倒数第三个

调用重载的构造器 必须放在第一行 this(参数);

java包

命名规则

公司域名.公司项目名. 模块名         .  代表父子关系

包的声明要写在有效代码的第一行

同一包中的类可以直接访问并使用

不同包中的类相互使用需要加上导包语句  import 关键字

java.lang 包 默认包 使用时不需要导包,任何程序中,该包被自动导入

java.io 包  输入/输出操作有用的类的组成

java.util

package com.neusoft.javase.ch06.a;

import java.util.Random;
import java.util.Scanner;//导包 也可以写作import java.util.*; 星号代表该包下所有类 但是不推荐 因为过于浪费

public class Employee {
	public static void main(String[] args) {
		//同一个包中的类可以相互直接使用
		Dog d = new Dog();
		//不同包中的类相互使用需要加上导包语句
		Scanner sc = new Scanner(System.in);

		
	}

}

创建有对象时会有就近原则 

如果在一个主方法里面想建两个包下的类的对象 可以在另外一个包的类的前面写上包名.类名 

 

 

封装（Encapsulation）

有两方面 隐藏(不允许其他类直接访问)和公开(公开方法)

封装关键词

private(私有 只能在同一个类)   <  default(默认 同一个包里的类)   <   protected(保护 不同包的子类)  <   public(公开 所有都可以用)

一般属性用private 方法用public

公开方法一般建造两个 get(得到属性) 和set(修改属性)

右键source选择generate getter and setters

public class Employee {
	//封装性 
	//1.使用private修饰属性
	private int age;
	
	//2.对外提供公开的方法用于修改相关属性
	public void setAge(int age) {
		if (age>=18 && age<=60) {
			this.age = age;
		} else {
			System.out.println("修改年龄失败,数据不合法");
		}
	}

    //3.对外提供公开的方法用于得到相关属性
	public int getAge() {
		return age;
	}
}

定义类的步骤
1.定义私有属性(private)
2.提供两个构造器  右键source
3.提供get和set方法(public)右键source
4.定义其他方法
    

静态 static

static 可以修饰 属性方法 代码块

static修饰的内容会优先于创建对象

局部变量不能用static修饰

静态属性(类变量) :

当java程序运行时,第一次使用一个类时,虚拟机要加载类

如果这个类定义了静态属性 则虚拟机就会在加载类时 在方法区开辟空间存储静态属性

静态属性在内存中只有一个空间

静态属性的真实意义 全类 所有对象共享 整个类只需要一个数据时要定义成静态属性

静态属性可以通过类名 . 方式访问 例 : Chinese(类名).country(静态属性名) = "China"(赋值);

静态方法:

不需要创建对象(实例化),可以直接访问

静态方法不能访问非静态的属性

​​​​​​​不能修饰构造方法

工具类方法一般都是静态

静态代码块:

static可以修饰不包含在任何方法里的代码块 称为静态代码块

静态代码当类被加载时会被执行同时在方法区创建静态属性空间,只运行一次

	static {
		System.out.println("China类加载完毕,可以放心使用");
	}
    //主方法运行时"China类加载完毕,可以放心使用"会显示在结果的第一行