面向过程
Java是一个面向对象的语言。在一个面向对象的系统中,类(class)是数据和操作数据的方法的集合。数据和方法一起描述对象(object)的状态和行为。每一对象是其状态和行为的封装。类是按一定体系和层次安排的,使得子类可以从超类继承行为。在这个类层次体系中有一个根类,它是具有一般行为的类。Java程序是用类来组织的。
面向对象
OOP(Object Oriented Programming)面向对象编程。面向对象编程实质上就是对现实世界的对象进行建模操作。
类
我们把某些具有相同的属性和行为的事物抽象成一类。
类是模子,确定对象将会拥有的特征(属性)和行为(方法)
类的特点:
- 类是对象的类型
- 具有相同属性和方法的一组对象的集合
猫:
属性:颜色,年龄,体重
行为:睡觉,抓老鼠,吃食
小汽车类:
属性:颜色,马力,四个轮子
行为:行驶,停车
在java语言中万物皆对象(在java里面不是所有的东西都是对象,八种基本数据类型不是对象,jdk1.5以后对于八种基本数据类型都提供了包装类)。
对象
类是一个概念,对象是一个具体的实例。
“有什么”
属性:对象具有的各种静态特征
“能做什么”
方法:对象具有的各种动态行为
类和对象的关系
- 类是抽象的概念,仅仅是模板
- 对象是一个你能够看得到、摸得着的具体实体
- 类是对象的类型
- 对象是特定类型的数据
- 具体开发过程中,先定义类再实例化对象
类的定义
语法:
class 类名{
属性
方法
}
注意
:如果是一个类的情况,最好让类名
和文件名
一致。
类里面只能有属性
和行为
类名:要见名之意,要用英文的单词,每一个英文单词的首字符要大写。
属性
在类中定义的变量就是属性,属性可以没有初始值,但是jvm会给属性一个默认值,只有属性才有默认值
基本数据类型的默认值如下表:
基本数据类型 | 默认值 |
---|---|
byte | 0 |
short | 0 |
int | 0 |
long | 0 |
float | 0.0 |
double | 0.0 |
char | ‘ ’ |
boolean | false |
引用数据类型的默认值:null
方法
方法:对象具有的各种动态行为
语法:
public <static> 返回值 方法名字(数据类型 变量, 数据类型 变量……){
<return>
}
类的实例化
创建类的目的,就是创建对象(类的实例)
语法:
数据类型 变量 = new 数据类型();
实例:
上面实例创建了一个猫类
访问对象的属性:
对象.属性名
调用类的方法:
对象.方法(行为)名
实例:
创建对象的内存的结构
当我们运行类的时候会在内存中产生jvm
Jvm有栈,堆,数据共享区
栈:
程序运行的时候基本数据类型和引用数据类型的引用所存储的位置,内存小,存取的速度快堆:
是对象存储的位置,内存大,存取的速度慢数据共享区:
存储共享数据的内存区
数据共享区:
Dog.class
lookHome()
sleep()
//类中的对象方法是被当前类的所有对象共享的。
局部变量
凡是定义在方法内或者是语句块的变量都是局部变量。
如下:
局部变量的特点:
- 作用范围:只限于所定义的大括号。
- 存储的位置:存储在栈内存中。
- 默认值:无,局部变量必须赋值。
- 生命周期:所属的大括号结束就消失
class Demo1{
public static void main(String[] args){
//局部的变量只在它的所属的大括号和其子孙括号内有效
int x = 0;
if(x > 10){
System.out.println(x);
}
}
public static void add(){
//定义一个变量
int i = 0;
{
int x = 0;
}
//报错的
System.out.println(x);
}
//方法的参数这个变量的作用域就是这个方法的体内
public static void add(int a){
}
public static void multiply(){
//循环的变量的定义的也是在循环体的大括号内有效
for(int i=0;i<10;i++){
}
}
}
注意:
并不是只有基本数据类型才是局部变量
局部变量在使用之前必须要初始化,否则会报错
报错:
局部变量的生命周期
类的封装
面向对象的三大特征:封装
、继承
、多态
目的:提高数据安全性,通过封装,可以实现对属性的访问权限控制,同时增加了程序的可维护性。
封装性
封装的步骤
- 属性用private私有
- 使用set/get赋值,并用this引用
- 调用方法(方法公有)
实例:
// 对System.out.println();的封装。
public class Test
{
public static void test(String str)
{
System.out.println(str);
}
}
调用
public class Use
{
public static void main(String[] args)
{
Test.test("封装");
}
}
继承性
若一个类只允许继承一个父类,称为单继承;若允许继承多个父类,则称为多重继承。Java语言通过接口实现了多继承
实例:
Class A{
Public void A1(){
System.out.println(“我是特立独行的鱼儿”);
}
}
Class B extends A{
}
多态性
在这里插入代码片public Class Parents {
public void print() {
System.out.println(“parents”);
}
}
public Class Father extends Parents {
public void print() {
System.out.println(“father”);
}
}
public Class Mother extends Parents {
public void print() {
System.out.println(“mother”);
}
}
public Class Test {
public void find(Parents p) {
p.print();
}
public static void main(String[] args) {
Test t = new Test();
Father f = new Father();
Mother m = new Mother();
t.find(f);
t.find(m);
}
}
This关键字
对象方法中隐藏了一个this关键字, 如果那个对象调用了这个方法那么这个方法里面的this就是这个对象
class Person{
String name;
int age;
public void info(){
/*对象方法中隐藏了一个this关键字, 如果那个对象调用了这个方法那么这个方法里面的this就是这个对象
*/
System.out.println(this);
}
}
public class TestPerson{
public static void main(String[] args){
//创建一个Person对象
Person p = new Person();
System.out.println(p);
//调用info
p.info();
}
}
This在封装中用来区分同名的变量和属性,带有this的是属性
实例:
class Person{
private String name;
private int age;
public void setName(String name){
//this.name是属性
this.name = name;
}
public String getName(){
return name;
}
public void setAge(int age){
this.age = age;
}
public int getAge(){
return age;
}
}
构造器
构造器本身是一个方法:
- 没有返回值,也没有void。
- 构造器的方法名必须和类名一致
- 在方法中定义要初始化的参数列表
作用:创建对象,给对象赋初始值;
默认构造器
public Person(){
System.out.println("我是被鱼儿调用的构造器");
}
一个类的构造器没有任何参数这就是默认构造器,如果不写的话也是默认存在的,方法体什么都没有,我们也可以显示的定义出来。
有参数的构造器
实例:
public Person(String name, int age){
//给属性赋值
this.name = name;
this.age = age;
}
使用有参数的构造器创建对象:
Person p1 = new Person("特立独行的鱼儿", 20);
p1.info();
如果一个类里面存在着一个有参的构造器的话,那么无参数的默认构造器就会被覆盖,就不能使用,如果想要使用这个默认的构造器就必须把它显示的定义出来。
构造器直接的调用
public Person(String name, int age){
this.name = name;
this.age = age;
}
public Person(String name, int age, String gender){
//通过this的用法调用本类的构造器
/*
this.name = name;
this.age = age;
*/
this(name, age);
this.gender = gender;
}
通过this(变量,变量….)这种方式来调用本类的构造器,必须放在调用的第一行。
单例模式
我们以往创建对象的时候,通过一个类是可以创建很多个对象的,但是我们想要让一个类就只能创建一个对象。
懒汉模式
实例:
class Singleton{
private static Singleton s;
//给构造器私有化
private Singleton(){
}
//私有化构造器之后,肯定不能被外部使用
public static Singleton getInstance(){
if(s == null){
s = new Singleton();
}
return s;
}
}
class TestSingleton{
public static void main(String[] args){
Singleton s = Singleton.getInstance();
Singleton s1 = Singleton.getInstance();
Singleton s2 = Singleton.getInstance();
System.out.println(s);
System.out.println(s1);
System.out.println(s2);
}
}