类和对象

类和对象

类是抽象的概念，如果要访问一个类中的属性或者方法则需要通过对象去访问。

一.基础知识

生活中的很多事物都可以看成一个类，例如：People（人）类，人有很多属性，如：姓名，年龄等等对应到类中就是成员变量/实例变量；人有很多行为，如：吃饭，睡觉等等对应到类中就是成员方法/实例方法。

1.修饰符

public

public可以同时修饰类和成员变量、成员方法。从字面理解：公有的，public修饰的类可以被所有的其他的类访问或引用，也就是说其它类中可以创建该类的实例，访问该类所有可见成员变量，调用所有可见方法。

private

private主要修饰类成员，表示该类成员只能被类自身访问，任何其他类都无法修改或者引用。

protected

protectedprotected受保护成员，主要修饰类成员，在同一个包中可以被该类的子类或者其他的类访问。特别注意：分为与父类在同一包内和不在同一包内的子类，不在同一个包中的子类，只能访问从父类继承而来的受保护成员，而不能访问父类实例本身的受保护成员，在相同包内则没有以上的限制。

final

final可用于修饰类，成员变量，成员方法。
修饰类，该类不能被继承；
修饰成员变量，该变量不能被修改；
修饰成员方法，该方法不能被重写。

default

default（默认，什么也不写）：修饰类，在同一个包内可见，即该类只能被同一个包中的类访问或引用。

static

static修饰变量和方法，修饰的变量和方法叫静态变量和静态方法。
静态变量和静态方法属于整个类，所有可以通过类名直接访问，不需要创建实例。

静态方法和非静态方法

实例方法和静态方法之间可以互相调用吗？

非静态方法和非静态属性都有一个this属性
静态方法和静态属性不具备this属性

实例方法中可以访问静态属性和静态方法
静态方法中不可以不可以访问实例属性和实例方法

2.重写和重载

重写（子与父）

重写是子类对父类的允许访问的方法的实现进行重写编写，返回值和形参都不能改变。简单的说子类中方法与父类中方法声明一模一样的方法就是进行了重写。“外壳不变，核心重写”。
例：

class people{
	String name;
	int age;
	public void eat(){
		System.out.print("eating");
		}
class Men extends People{
	public void eat(){
		System.out.print("eating");
		}
}

重载（同一类）

同一个类，方法名相同，参数不同，最常用的就是构造器重载。
被重载的方法必须改变参数列表；
被重载的方法可以改变返回类型和修饰符。
例：

class People{
		String name;
		int age;
		public void eat(){
			System.out.print("eating");
			}
		public void eat(String name){
			System.out.print(name+"eating");
			}
	}

3.定义类

(1)定义成员变量

在一个类中成员变量名是唯一的，下面以People（人）类为例，定义成员变量

class People{
		String name;
		int age;
 }

成员变量和局部变量

成员变量：a.在成员方法外
b.在栈内存
c.有默认初始值
局部变量：a.在成员方法定义中或者方法声明中
b.在堆内存
c.没有默认初始值，必须定义、赋值后才能使用

(2)定义成员方法

普通成员方法

[修饰符] 返回值类型 方法名([参数列表]){
方法体
}

public void eat(){ 
		System.out.print("eating");
}

特殊成员方法

a.构造方法

方法名和类名相同，不能有返回值，作用是对一些成员变量进行初始化，可以被重载
例：

class People{
		String name;
		int age;
		public People{//构造函数
			this,name = name;
			this.age = age;
			}
	}

this引用（对成员变量和局部变量进行区分）
类的当前实例 每一个类都会有自己的this引用 this引用指向当前对象本身作用就是在类中，让类中的方法可以调用本类中的另外一个方法或者属性
（1）.调用成员方法
（2）.调用重载的构造函数

b.main方法

main为方法名，args为形参，类型为字符串数组，void表示main方法无返回值

public static void main(String[] args){
}

4.对象

实例化对象

类名 对象名 = new 类名([参数列表])

People p = new People(String name,int age);

初始化对象

a.直接初始化

直接在定义成员变量时赋值

class People{
		int age = 10;
		}

b.定义构造函数

用this.对创建的成员变量赋初值

class People{
		String name;
		int age;
		public People{
			this,name = name;//初始化
			this.age = age;
			}
	}

构造函数

类中如果没有给定构造函数，系统会自动生成一个默认无参构造函数；如果人为给定一个构造函数，系统则不会生成。
new操作符创建一个对象，new后面的方法即是构造方法，构造方法是一种特殊的方法
有以下特殊之处：
（1) 没有返回值类型
（2) 必须和所在类名字相同
（3) new操作符调用生成一个对象
构造函数的作用
（1）类属性进行赋值
（2）给对象开辟内存空间

5.包

命名

com.公司名.项目名.模块名

导包

import 包名.类名

6.Java中的数据类型

基本数据类型

数值类型

整数型、浮点型

字符类型

引用数据类型

布尔类型、类、数组、接口

二.String类

本身是一个对象，对象的默认值是null
“hello” 遇到"“就会在内存上创建一个字符串对象
创建方式
String s = “hello”;
String s = new String(“hello”);
其首先会在堆上申请一块内存空间存储字符串常量"hello”, 然后通过new String会创建一个对象，需要注意这里有可能创建两个对象，第一个对象创建字符串常量hello添加到字符串常量池中，第二个对象则是创建 一个值为hello的字符串对象

StringBuilder/StringBuffer

StringBuilder/StringBuffer 相比于String类更加灵活，其提供的append函数可以实现字符串的拼接，由于String对象一旦创建，值就不可以被改变了
StringBuffer类是线程安全的，这就意味着多个任务使用同一个StringBuffer,某一时刻只能够有一个任务执行。如果多任务并发访问的情况则使用StringBuffer，反之就使用StringBuilder

三.类的三大特性

1.封装

定义

封装是指一种将抽象性函式接口的实现细节部份包装、隐藏起来的方法。封装可以被认为是一个保护屏障，防止该类的代码和数据被外部类定义的代码随机访问。又叫隐藏实现，只是说把一些对外接口暴露，而不需要用户去了解其内部实现。

封装的实现

a.修改属性可见性来限制对属性的访问（通常限制为private)
例：

class People{
		private String name;
		private int age;
	}

如果外部要使用这些属性，通常我们为外部提供公共的方法（get和set）来访问这些属性
get方法是提供获取的方法
set方法是提供设置属性的方法
例：

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

2.继承

继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。
子类中有很多和父类相同的属性和方法，利用继承，可以避免一些成员变量和成员方法的反复定义
子类可以通过继承自动获得父类中访问权限：public protected,default,但不能继承权限为private的成员变量和成员方法。

class People{
		String name;
		int age;
		public void eat(){ 
		System.out.print("eating");
	}
}
class Men extends People{
}	

实现

关键字：extends
在 Java 中，类的继承是单一继承，也就是说，一个子类只能拥有一个父类，所以 extends 只能继承一个类。

class People{
		
}
class Men extends People{
	super();
}

单继承

Java只支持单继承，不支持多继承，但是支持多重单继承

3.多态

定义

就是指在一个引用在不同的情况下的多种状态。也可以理解为，多态是指通过指向父类的指针，来调用不同子类中的实现方法
例：狗可以是狗的类型

Dog d = new Dog();

狗也是动物的一种，可以把狗称为动物

Animals d = new Dog();

存在条件

1.要有继承关系
2.要有方法重写

Animals d = new Dog();
d.show();
Dog d = new Dog();
d.show();

3.要有父类引用指向子类对象
父 f = new 子（）；

向上转型

多态本身就是向上转型的过程

使用格式

父类类型 变量名 = new 子类类型（）；