第二章-面向对象
万物皆对象
对象是对一个具体事务的描述,大到国家,小到空气都可以称它为一个对象,对象一共有2个部分所组成,属性和功能;
面向对象和面向过程的区别
面向过程:当事件比较简单的时候,利用面向过程,注重的是事件的具体的步骤/过程,注重的是过程中的具体行为,以函数为最小单元,考虑怎么去做;
面向过程:注重找"参与者",将功能封装到具体的对象中,做什么找谁去做,用什么功能去做,以类为最小的单元;
具体区别:面向对象->找具体可以实现功能的人去做;面向过程->自己去做
类和对象的关系
【类】：对象向上抽取相似的部分，定义成一个公共的模板；例如：人类、动物、国家
【对象】：具体的事务，看得见摸得着的；例如：张三、大黄、美国
类的定义
public class Persn{
private String name;//名称(属性)
private String age;//年龄(属性)
private String cellphone;//手机(属性)
/**
* 吃的功能(行为)
*/
public void eat(){
System.out.println();
}
/**
* 睡的功能(行为)
*/
public void sleep(int hours){
System.out.println("睡了"+hours+"个小时");
}
/**
* 自我介绍
*/
public String introduce(){
String str = "我的名字叫:"+this.name+",我今年:"+this.age+"岁了,我的手机号码是:"+cellphone;
return str;
}
}
对象的创建和使用
要点:
- 在使用同一个类,创建对象时,只在第一次使用的时候调用一次类的加载器对模板类进行加载完成初始化;
- 被创建出来的对象[ 属性 ]是私有的,[ 方法 ]是共享的;
public class Person{
String name;//名称(属性)
String age;//年龄(属性)
String cellphone;//手机(属性)
public String introduce(){
String str = "我的名字叫:"+this.name+",我今年:"+this.age+"岁了,我的手机号码是:"+cellphone;
return str;
}
}
public class Test{
public static void main(String[] arags){
Person p = new Person();//创建对象
p.name = "张三";
p.age = 18;
p.cellphone = "12345612345"
p.introduce();//调用方法
}
}
构造器
构造器就是在使用模板来创建出具体的事务时,为对象附加一些属性;比如:doc的文档模板进行打印,打印-彩色或黑白;
注意事项:
- 类中如果没有写构造器,它默认会创建一个空参数构造器;
- 如果创建了有参构造器,它不会自动创建一个空参构造器;
- 构造器可以重载,参数类型,顺序,个数不同为合法;
- 每个构造器中会默认调用一个super(),父类的构造器,只能写在构造器的第一行;
- 构造器不能有返回值;
- 构造器的名称必须和类名相同;
public class Person{
private String name;
private int age;
private String cellphone;
//空参构造器
public Person(){
super();
}
//全参构造器
public Person(String name,int age,String cellphone){
super();
this.name = name;
this.age = age;
this.cellphone = cellphone;
}
//有参构造器
public Person(String name){
super();
this.name = name;
}
}
对象创建内存图
this关键字
this关键字描述的就是当前对象,在哪个对象中使用this,this就代表哪个对象;
public class Person{
String name;
public Person(String name){
this.name = name;
}
}
Person p1 = new Person("小明"); //Person的构造器是公共的,但这个构造器的this 就代表p1对象
Person p2 = new Person("小丽"); //Person的构造器是公共的,但这个构造器的this 就代表p2对象
super关键字
super关键字代表的是父类,在子类对象中的属性名称或方法名称如果和父类一样,但是想在子类中去使用父类的方法或者属性我们可以通过super进行调用;
public class Person{
//父类的sleep方法
public void sleep(){
System.out.println("父类");
}
}
public class student extends Person{
//子类的sleep方法
public void sleep(){
System.out.println("子类");
super.sleep();//调用父类的
}
}
static关键字
被static修饰的属性和方法都属于类成员,会在类加载器对类进行加载的时候存在,因此类会优先于对象而存在,所以类成员也是共享的,静态的变量是不可能访问到还没有加载的对象成员;被加载的字节码文件是存放在方法区的,而方法区是共享的,;
public class Demo{
static String name;
static int age;
public static void introduce(){
System.out.println();
}
}
代码块
代码块就是规定一个作用域,比如我们定义的方法后面有{},if{},while{},for{},他们都有自己的代码块,代码块还包含普通代码块,静态代码块,构造代码块同步代码块等;
//构造代码块,对象创建一次执行一次
{
int a;
}
//静态代码块,在类被加载时执行,只执行一次
static{
int a;
}
//同步代码块,执行会被锁定,执行期间别的线程进不来(悲观锁)
synchronized{
int a;
}
package包管理
在我们项目开发时为了对代码进行管理,通常会以包的概率来对象相应的代码进行管理,集成开发环境中我们在包中创建一个类时,集成开发环境会帮我们自动在类的最上方使用package com.javacat7;对我们创建的类进行一个标识我们这个类是在哪个包下面的;
package com.javacat7;
public class Demo{
}
import导包
在一个类中,我们会用到其它的类的一些功能,如果要使用其它的类我们就需要把其它的类导入到当前类中进行使用,它分为静态导包和非静态导包,静态导入的包我们可以直接使用对应的方法,非静态导入的包我们需要通过对象进行使用;
package com.javacat7.utils;
public class MyUtils{
public int max(int a,int b){
return a > b ? a : b;
}
}
-------------------------------------------------------------------------------------
package com.javacat7.test;
//普通导包
import com.javacat7.utils.MyUtils;
public class TestDemo{
public static void main(String[] args){
MyUtils utils = new MyUtils();
utils.max(3,5);
}
}
-------------------------------------------------------------------------------------
package com.javacat7.test;
//静态导包
import static com.javacat7.utils.MyUtils;
public class TestDemo{
public static void main(String[] args){
utils.max(3,5);
}
}
权限修饰符
权限修饰符就是控制类或者对象中可以访问的级别权限,在我们开发项目架构中应用好修饰符很关键,如果只是开发只需要重点了解private和public即可;
public ; //当前类,相同包,子类,其它包 --都可以使用
protected ; //当前类,相同包,子类 --可以使用
default ; //当前包,相同包 --可以使用
private ; //当前包 --可以使用
final修饰符
- 修饰类: 类不允许被继承
- 修饰变量: 变量不可更改
- 修饰方法: 不允许被重写
三大特性-封装
封装就是把对象信息进行保护,对外提供可以访问到它的接口,根据对类封装的需求配合权限修饰符完成私密保护,提供可以访问的方法;
public class Person{
private String name;
private String gender;
public Person(String name,String gender){
if(gender.equals("男") || gender.equals("女")){
this.gender = gender;
}else{
this.gender = "男";
}
}
public void setGender(String gener){
if(gender.equals("男") || gender.equals("女")){
this.gender = gender;
}else{
this.gender = "男";
}
}
public String getGender(){
return this.gender;
}
}
三大特性-继承
Java中的继承只允许单继承,所有类的顶级父类是Object类,类是对对象的抽象,继承是对类的抽象;子类继承父类那么就拥有父类的一切,包括私有[但并不一定会拥有执行访问权]
父类:Person
public class Person{
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(){}//吃饭
public void sleep(){}//睡觉
}
子类:Student
//继承父类后拥有父类的一切,只要有相关访问的权限修饰符足够子类能使用,都可以在子类中使用
public class Student extends Person{
private String sno;//学号
public void study(){}//学习
}
三大特性-多态
多态是和方法相关,和属性无关,不需要记什么属性 编译看左边执行看左边,方法 编译看左边执行看右边。简单就是多态是对方法执行产生的多态现象；
动物抽象类
public abstract class Animal{
public abstract void shout();
}
小狗
public class Dog extends Animal{
@Override
public void shout(){
System.out.println("小狗:汪汪汪");
}
}
小猫
public class Cat extends Animal{
@Override
public void shout(){
System.out.println("小猫:喵喵喵");
}
}
小女孩
public class Girl{
public void play(Animal animal){
animal.shout();
}
}
main
public class Test{
public static void main(String[] args){
Dog dog = new Dog();//狗也是动物的一种,可以直接当Animal传入
Animal cat = new Cat();//多态的表现形式,猫也是动物的一种
Girl g = new Girl();
g.play(dog);
g.play(cat);
}
}
抽象类
在类中可能我们定义的一些方法每个人使用的需求都不相同,都需要对相关的方法进行重写,那么我们可以在类中去定义一个抽象方法,有抽象方法的类也叫抽象类,只有抽象类或接口中才可以定义抽象方法;抽象类可以被继承和创建,但创建时需要对抽象类中的方法进行重写;
抽象类
public abstract class MyUtils{
public abstract void min();
public void sort(int[] arr){
Arrays.sort(arr);
}
public static int getAbsValue(int number){
return Math.abs(number);
}
}
main方法
public class Test{
public static void main(String[] args){
MyUtils utils = new MyUtils(){
@Override
public void min(){
}
@Override
public void sort(int[] arr){
}
}
}
}
方法的重载和重写
- 方法的重载就是在一个类中有多个方法名称相同的方法,但参数类型不同
- 重写是指子类中对父类的方法进行重新编写
内部类
内部类就是定义在类中的类,有:成员内部类,静态内部类,局部内部类;
内部类的定义
public class Person {
//成员内部类
public class Student {
String name;
public void printName() {
System.out.println(name);
}
}
//静态内部类
public static class Emploee {
String name;
public void printName() {
System.out.println(name);
}
}
public void method() {
//局部内部类
class InnerClass {
String name;
public void printName() {
System.out.println(name);
}
}
InnerClass innerClass = new InnerClass();
innerClass.name = "局部内部类";
innerClass.printName();
}
}
使用
public class Test{
public static void main(String[] args){
Person person = new Person();
Person.Student ps = person.new Student();
ps.name = "我是成员内部类";
Person.Emploee pe = new Person.Emploee();
pe.name = "我是静态内部类";
ps.printName();
pe.printName();
person.method();
}
}
接口
Java的接口是可以多实现的,在开发中我们使用接口的频率非常高,它避免了Java只能单继承的局限性;接口默认是使用abstract修饰,就算不写,它也会自动加上,方法默认是使用public abstract 就算不写,也默认加上;
public interface OrderService{
//抽象方法
public abstract void addOrder(String orderNo);
//JDK1.8以后的,实现类不能对其重写
public static void deleteOrder(String orderNo){
System.out.println("我是删除订单");
}
//JDK1.8以后的,实现类可以对其重写
public default void updateOrder(String orderNo){
System.out.println("我是修改订单");
}
}
浙公网安备 33010602011771号