JavaSE 面向对象OOP(上)

一、面向对象概述

1 面向过程&面向对象区别

面向过程
- 第一步做什么，第二步做什么…
- 面向过程适合处理一些简单的问题。
面向对象
- 分类的思维模式，首先分类，随后逐个解决分类下的细节。
- 面向对象适合处理负责的问题，适合多人协作的问题。
- 以类的方式组织代码，以对象组织封装数据
面向对象三大特性：封装、继承、多态

2 方法回顾+补充

方法的定义
- 修饰符
- 返回类型
- break：跳出循环或switch， return：结束方法
- 方法名：注意命名规范见名知意
- 参数列表：（参数类型，参数名） …
- 异常抛出：随后填坑。
方法的调用
- 静态方法
- 非静态方法
- 实参、形参
- 值传递（Java）和引用传递可查看我之前的blog，点击查看详情
- this关键字

静态方法和非静态方法调用的补充案例：

package com.oop.demo01;
//该类内含静态方法与非静态方法
public class Student {//static 修饰的方法和类一起加载的//而非静态方法是在类实例化之后生成//静态方法public static void say(){System.out.println("Say!");}//非静态方法public void write(){System.out.println("Write!");}
}

package com.oop.demo01;
//该类为测试类
public class Demo02 {public static void main(String[] args) {//静态方法 static//调用方法：类名.方法名;Student.say(); //Say！//非静态方法 没有static//调用方法：对象类型 对象名 = new 对象类名; 使用实例对象操作方法;Student st = new Student();st.write();//Write！}
}

注意两种方法各自的调用方式！

3 类和对象

类是一种抽象的数据类型，它是对某一类事物的整体描述/定义，但是并不能代表某个具体的事物。
对象是类的实例。
也可理解为：类是一个模版：抽象；对象是一个具体的实例。

创建类和对象的案例：

package com.oop.demo02;//学生类 （属性+方法）
public class Student {//属性：字段/成员变量String name;//nullint age; //0//方法：public void study(){System.out.println(this.name+" is studying");}public void nostudy(){ System.out.println(this.name+" is not studing");}
}

package com.oop.demo02;//测试类：一个项目应该只有一个main方法
public class Application {public static void main(String[] args) {//类：抽象的，实例话//类实例化后会返回一个自己的对象//对象就是一个Student类的具体实例Student j = new Student();Student d = new Student();j.name = "Jever";j.age = 19;d.name = "Demut";d.age = 23;System.out.println(j.name);j.study();System.out.println(d.name);d.nostudy();}
}
//运行结果：
/*
运行结果：
Jever
Jever is studying
Demut
Demut is not studing*/

4 创建对象 <-构造器->

构造器：
- 和类名相同
- 没有返回值
作用：
- new 本质是在调用构造器
- 初始化对象的值
注意：
- 定义了有参构造之后，如果想使用无参构造，需要显示的定义一个无参的构造器。

构造器案例：

package com.oop.demo02;
//Person类（此类仅包含属性与构造器）
public class Person {String name;int age;//实例化初始值//无参构造器public Person(){}//有参构造器public Person(String name, int age){this.name = name;this.age = age;}
}

package com.oop.demo02;
//测试类
public class Application2 {public static void main(String[] args) {//使用有参量的构造器Person person = new Person("Jever",19);System.out.println(person.name);    //JeverSystem.out.println(person.age);     //19}
}

5 创建对象内存分析

代码如下：

package com.oop.demo03;
//Pet类  （属性+方法）
public class Pet {String name;int age;//无参构造会自动生成public void shout(){System.out.println("Shouting!");}public static void eat(){System.out.println("Eating");}
}

package com.oop.demo03;
//测试类 生成两实例对象，并进行操作
public class Application {public static void main(String[] args) {Pet dog = new Pet();dog.name =  "旺财";dog.age = 3;dog.shout();System.out.println(dog.name);System.out.println(dog.age);Pet cat = new Pet();Pet.eat();}
}

该过程示意图如下：

二、面向对象三大特性

1 封装

该露的露，该藏的藏
- 程序设计要追求“高内聚，低耦合”。高内聚就是类的内部数据操作细节自己完成，不允许外部干涉；低耦合指仅仅暴露少量的方法给外部使用。
封装值数据的隐藏
- 通常应禁止直接方位一个对象中数据的实际表示，而是应通过操作接口来访问，这称为封装。
属性私有，get/set（可在set中进行安全性的判断）
封装的作用：
- 提高程序安全性，保护数据
- 隐藏代码的实现细节
- 统一接口
- 增加系统可维护性

案例展示：

package com.oop.demo04;
//属性私有，get/set
public class Student {//以下属性私有，数据被封装private String name;  //姓名private int id;     //学号private char gender;  //性别private int age; //年龄 注意不可无限增长//提供一些可以操作私有属性的方法！//提供public 的get、set方法//get 获得这个数据public String getName(){return this.name;}public int getAge(){return this.age;}//set 给私有数据设置值public void setName(String name){this.name = name;}public void setAge(int age){//进行安全性判断if (age>110 || age<0){//不合法this.age = 0;}else {this.age = age;}}
}

package com.oop.demo04;
//测试类
public class Application {public static void main(String[] args) {Student s1 = new Student();s1.setName("Jever");System.out.println(s1.getName());s1.setAge(999);System.out.println(s1.getAge());}
}

2 继承

2.1 继承基础

继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模。
使用关键字extends(扩展)。子类是父类的扩展。
Java中类只有单继承，没有多继承。
所有类默认继承object类。

继承案例：

package com.oop.demo05;
//Person类：父类
public class Person {//public//protected//default//privateprivate String name; //子类无法继承public void say(){System.out.println("I am saying!");}public void setName(String name) {this.name = name;}public String getName() {return name;}
}

package com.oop.demo05;
//学生类
public class Student extends Person{}

package com.oop.demo05;
//测试类
public class Application {public static void main(String[] args) {Student st = new Student();st.say();}
}

注意访问时方法权限的问题！

2.2 super详解

注意：

super调用父类的构造方法，必须在构造方法的第一个
super必须只能出现在子类的方法或者构造方法中！
super和this不能同时调用构造方法！

VS this：

代表对象不同：
- this：调用本类对象；
- super：代表父类对象应用
前提：
- this：没有继承时也可以使用；
- super：只能在继承条件下才可以使用。
构造方法：
- this()：本类的构造；
- super()：父类的构造。

案例展示：

package com.oop.demo05;
//在Java中，所有的类都默认继承Object类。
//Person类：父类
public class Person {public Person(){System.out.println("Person无参构造器！");}protected String name = "Demut";public void print(){System.out.println("Person");}
}

package com.oop.demo05;
//学生类
public class Student extends Person{public Student(){//此处隐藏了super();//调用了父类的无参构造器,且调用父类的构造器语句必须在子类的第一行。super();System.out.println("Student无参构造器！");}private String name = "Jever";public void print(){System.out.println("Student");}public void test1(){System.out.println(this.name);//使用this访问本类中name  JeverSystem.out.println(super.name);//使用super访问父类中name  Demut}public void test2(){this.print(); //使用this访问本类中方法  Studentsuper.print(); //使用super访问父类中的方法  Person}
}

package com.oop.demo05;
//测试类
public class Application {public static void main(String[] args) {Student s = new Student();s.test1();s.test2();}
}
/*
测试结果：Person无参构造器！Student无参构造器！JeverDemutStudentPerson*/

2.3 方法重写

（父类的功能，子类不一定需要，或者不一定满足！故需要重写）

重点：需要有继承关系，子类重写父类的方法！

方法名必须相同
参数列表必须相同
修饰符：范围可以扩大但不能缩小： public -> protected -> default -> private
抛出异常：范围可以被缩小但不能扩大。（破洞只能越填越小）

重写中子类的方法和父类方法头一致；方法体不同！

案例展示：

package com.oop.demo05;
//父类：A
public class A {public static void test(){System.out.println("A=>test()");}public void test2(){System.out.println("A=>test2()");}
}

package com.oop.demo05;
//子类：B
public class B extends A{public static void test(){System.out.println("B=>test()");}@Override//重写public void test2() {System.out.println("B=>test2()");}
}

package com.oop.demo05;
//测试类
public class Application2 {//静态方法和非静态方法的区别很大！！！//重写与静态方法无关，只与非静态有关！public static void main(String[] args) {//方法的调用只和左边定义的数据类型有关。B b = new B();b.test();   //B=>test()//父类的引用指向了子类A a = new B();a.test();   //A=>test()b.test2();  //B=>test2()a.test2();  //B=>test2()}
}

写在最后

热爱可抵岁月漫长！

To Demut and Dottie!

Day06 JavaSE面向对象OOP(上) (Object-Oriented Programming)相关推荐

面向对象编程（Object Oriented Programming）概念总结及延伸（一）
1.介绍笔者的梦想是成为一个架构师,但是要成为一个合格的架构师是相当不易的,它既需要丰富的项目经验也需要不断地吸取新的知识,而且在这过程中我们也要不断巩固基础知识.我也注意到了,现在主流的文章大都集 ...
Java OOP（Object Oriented Programming）个人理解及总结
面向对象编程(Object Oriented Programming,OOP,面向对象程序设计) 其三大特征:封装,继承,多态: 封装:解决数据的安全问题. 继承:解决代码的重用问题. 多态:解决程序 ...
夯实基础，彻底掌握js的核心技术(二)：面向对象编程（Object Oriented Programming）
单例设计模式(Singleton Pattern) 1. 单例模式解决的问题: 表现形式: Var obj = {xxx; xxx, - } 2. 作用: 把描述同一件事物的属性和特征进行" ...
python三大特征六大原则_面向对象程序设计（Object Oriented Programming）的三大特性，六大原则...
三大特性封装.继承.多态性拿简单工厂模式举例: namespace DesignMode_01 { // 计算基类 public class Operation { private double ...
Object Oriented Programming面向对象编程
OOP 面向对象编程( Object Oriented Programming)是一种计算机编程架构.OOP 的一条基本原则是计算机程序是由单个能够起到子程序作用的单元或对象组合而成.OOP ...
面对对象编程(OOP, Object Oriented Programming)及其三个基本特性
一千个读者,一千个哈姆雷特.对于面对对象编程,书上都会告诉我们它有三个基本特性,封装,继承,多态,但谈起对这三点的见解,又是仁者见仁智者见智,感觉还是得多去编程中体验把 . 面向对象编程(OOP, O ...
Java SE 008 理解面向对象程序设计（Inside Object Oriented Programming）
Java SE 008 理解面向对象程序设计 (Inside Object Oriented Programming) 前言:此笔记为圣思园张龙老师讲述的java视频课程笔记,自己看视频学习时记录的, ...
OOP(Object,Oriented Programming)
1.面向对象概念在学习面向对象之前,我们可以先了解一下面向过程.面向过程是一种思想,意思是我们要做任何事,都需要亲力亲为,强调的是过程. 面向对象也是一种编程思想,相对于面向过程,我们可以由原来问题 ...
Python编程基础：第三十九节面向对象编程Object Oriented Programming
第三十九节面向对象编程Object Oriented Programming 前言实践前言到目前为止我们都是函数式编程,也即将每一个功能块写为一个函数.其实还有一种更常用的编程方式被称为面向对 ...

Day06 JavaSE面向对象OOP(上) (Object-Oriented Programming)

JavaSE 面向对象OOP(上)

一、面向对象概述

1 面向过程&面向对象区别

2 方法回顾+补充

3 类和对象

4 创建对象 <-构造器->

5 创建对象内存分析

二、面向对象三大特性

1 封装

2 继承

2.1 继承基础

2.2 super详解

2.3 方法重写

写在最后

Day06 JavaSE面向对象OOP(上) (Object-Oriented Programming)相关推荐

最新文章

热门文章