面向过程:
面向对象:
概述:对于描述复杂的事物,为了从宏观上把握、从整体上合理分析,我们需要使用面向对象的思路来分析整个系统。但是,具体到微观操作,仍然需要面向过程的思路去处理。
面向对象(Object-Oriented Programming, OOP)的本质是以类的方式组织代码,以对象的方式封装数据。
三大特性:
注意:
类是一种抽象的数据类型。它是对某一类事物的整体描述或定义,但并不能代表某一个具体的事物。
对象是抽象概念的具体实例。
创建的方式:使用new关键字创建对象
使用new关键字创建对象的时候,除了分配内存空间之外,还会给创建好的对象赋默认值进行初始化,以及调用类中的构造器。
示例:
Student类
package com.wmwx.oop.Demo01;
//学生类
public class Student {
//属性:字段
String name;
int age;
//方法
public void study(){
System.out.println("学生"+this.name+"在学习。");
}
}
Application类(启动类)
package com.wmwx.oop.Demo01;
//启动类
public class Application {
//一个项目应该只存在一个main方法
public static void main(String[] args) {
//类是抽象的,需要实例化
//类实例化后会返回一个自己的对象
//student对象是Student类的一个实例
Student student = new Student();
student.study(); //输出"学生null在学习。"
student.name = "小明";
student.study(); //输出"学生小明在学习。"
}
}
当一个对象被创建时候,构造方法用来初始化该对象。构造方法和它所在类的名字相同,但构造方法没有返回值。
一个类即使什么都不写,也会存在一个构造方法。因为 Java 自动提供了一个默认构造方法,其访问修饰符和类的访问修饰符相同。
一旦自己定义了构造方法,默认的构造方法就会失效。
示例:
Person类:
package com.wmwx.oop.Demo01;
public class Person {
String name;
//使用快捷键alt+insert可以自动生成构造方法
//无参构造
public Person(){
this.name = "一个无名氏";
}
//有参构造(一旦定义有参构造,就必须显式定义无参构造)
public Person(String name){
this.name = name;
}
}
Application类:
package com.wmwx.oop.Demo01;
public class Application {
public static void main(String[] args) {
//使用new关键字,本质是在调用构造方法
Person person1 = new Person(); //调用无参构造
System.out.println(person1.name); //输出"一个无名氏"
//利用构造方法,可以初始化对象
Person person2 = new Person("惟妙惟霄"); //调用有参构造
System.out.println(person2.name); //输出"惟妙惟霄"
}
}
过程如下:
所谓封装,即该露的露,该藏的藏。程序设计要追求**“高内聚,低耦合”**。
高内聚:类的内部数据操作细节自己完成,不允许外部干涉。
低耦合:仅暴露少量的方法给外部使用。
对于代码而言,总结起来就一句话:属性私有,get/set。
意义:
示例:
Student类:
package com.wmwx.oop.Demo03;
public class Student {
//属性私有
private String name;
private int id;
private String gender;
private int age;
//需要提供共有的get和set方法
//get方法:获取数据
public String getName() {
return name;
}
//set方法:设置数据
public void setName(String name) {
this.name = name;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getGender() {
return gender;
}
public void setGender(String gender) {
this.gender = gender;
}
public int getAge() {
return age;
}
public void setAge(int age) {
if (age<0||age>120){
this.age = 3;
}else{
this.age = age;
}
}
}
Application类:
package com.wmwx.oop;
import com.wmwx.oop.Demo03.Student;
//启动类
public class Application {
public static void main(String[] args) {
Student student = new Student();
student.setName("惟妙惟霄");
student.setId(123456);
student.setGender("男");
student.setAge(130);
System.out.println(student.getAge()); //输出3
}
}
继承的本质是对某一批类的抽象,从而实现对现实世界更好的建模。
在 Java 中通过 extends 关键字可以声明一个类是从另外一个类继承而来的,其语法如下:
class 子类 extends 父类 {
}
extends的意思是扩展,子类是对父类的扩展。
继承的注意事项:
在Java中,可以使用this指代当前类,并使用super指代父类。
super的注意事项:
重写是子类对父类的允许访问的方法的实现过程进行重新编写, 返回值和形参都不能改变。重写的好处在于子类可以根据需要,定义特定于自己的行为。 也就是说,子类能够根据需要实现父类的方法。重写需要遵守以下规则:
示例:
Person类:
package com.wmwx.oop.Demo04;
//父类:人类
public class Person {
private int money = 10_0000_0000;
protected String name = "惟妙惟霄";
public Person() {
System.out.println("Person的无参构造方法执行了!");
}
public void say(){
System.out.println("说了一句话。");
}
public int getMoney() {
return money;
}
public void setMoney(int money) {
this.money = money;
}
public void print(){
System.out.println("Person");
}
}
Student类:
package com.wmwx.oop.Demo04;
//子类:学生类
public class Student extends Person{
private String name = "妙霄";
public Student() {
//隐藏代码:super();
//父类的构造方法必须要在子类的构造方法的第一行
System.out.println("Student的无参构造方法执行了!");
}
public void test1(String name){
System.out.println(name); //输出参数
System.out.println(this.name); //输出当前类的name
System.out.println(super.name); //输出父类的name
}
//重写都是方法的重写,与属性无关
//只允许重写public方法
//可以使用快捷键alt+insert来插入重写方法
@Override
public void print() {
System.out.println("Student");
}
public void test2(){
print();
this.print();
super.print();
}
}
Application类:
package com.wmwx.oop;
import com.wmwx.oop.Demo04.Person;
import com.wmwx.oop.Demo04.Student;
//启动类
public class Application {
public static void main(String[] args) {
Student student = new Student();
//第一行输出"Person的无参构造方法执行了!"
//第二行输出"Student的无参构造方法执行了!"
student.say(); //子类继承父类,就会拥有父类的public方法
System.out.println(student.getMoney()); //可以用父类的get/set方法对属性进行操作
//可以使用快捷键ctrl+H来查看继承树
student.test1("MiaoXiao");
//第一行输出"MiaoXiao"
//第二行输出"妙霄"
//第三行输出"惟妙惟霄"
student.test2();
//第一行输出"Student"
//第二行输出"Student"
//第三行输出"Person"
Student stu1 = new Student();
stu1.print(); //输出"Student"
//父类的引用指向了子类
Person stu2 = new Student();
stu2.print(); //输出"Student"
}
}
多态是同一个行为具有多个不同表现形式或形态的能力。当使用多态方式调用方法时,首先检查父类中是否有该方法,如果没有,则编译错误;如果有,再去调用子类的同名方法。
多态存在的三个必要条件:
Parent p = new Child();
不能被重写的方法:
示例:
Person类:
package com.wmwx.oop.Demo05;
public class Person {
public void run(){
System.out.println("人在跑步。");
}
}
Student类:
package com.wmwx.oop.Demo05;
public class Student extends Person{
@Override
public void run() {
System.out.println("学生在跑步。");
}
public void eat(){
System.out.println("学生在吃东西。");
}
}
Application类:
package com.wmwx.oop;
import com.wmwx.oop.Demo05.Person;
import com.wmwx.oop.Demo05.Student;
//启动类
public class Application {
public static void main(String[] args) {
//一个对象的实际类型是确定的
//但可以指向的引用类型是不确定的
Student s1 = new Student();
Person s2 = new Student(); //父类的引用指向子类
Object s3 = new Student();
s1.run(); //输出"学生在跑步"
s2.run(); //子类重写父类方法,将执行子类方法,输出"学生在跑步。"
s1.eat(); //输出"学生在吃东西"
//s2.eat(); //不能调用。对象能使用哪些方法,要看左边的类型。
((Student)s2).eat(); //强制类型转换。输出"学生在吃东西。"
}
}
Java中的instanceof关键字可以用来判断某一个对象是不是某一个类是实例。如果是,返回true;如果不是,返回false;如果二者无关,则编译不通过。
示例:
package com.wmwx.oop;
import com.wmwx.oop.Demo06.Person;
import com.wmwx.oop.Demo06.Student;
import com.wmwx.oop.Demo06.Teacher;
//启动类
public class Application {
public static void main(String[] args) {
//继承关系如下:
//Object -> Person -> Student
//Object -> Person -> Teacher
//Object -> String
Object object = new Student();
System.out.println(object instanceof Student); //输出true
System.out.println(object instanceof Person); //输出true
System.out.println(object instanceof Object); //输出true
System.out.println(object instanceof Teacher); //输出false
System.out.println(object instanceof String); //输出false
System.out.println("=====");
Person person = new Student();
System.out.println(person instanceof Student); //输出true
System.out.println(person instanceof Person); //输出true
System.out.println(person instanceof Object); //输出true
System.out.println(person instanceof Teacher); //输出false
//System.out.println(person instanceof String); //编译时报错
System.out.println("=====");
Student student = new Student();
System.out.println(student instanceof Student); //输出true
System.out.println(student instanceof Person); //输出true
System.out.println(student instanceof Object); //输出true
//System.out.println(student instanceof Teacher);//编译时报错
//System.out.println(student instanceof String); //编译时报错
}
}
示例:
Person类:
package com.wmwx.oop.Demo06;
public class Person {
public void run(){
System.out.println("人在跑步。");
}
}
Student类:
package com.wmwx.oop.Demo06;
public class Student extends Person{
public void walk(){
System.out.println("学生在走路。");
}
}
Application类:
package com.wmwx.oop;
import com.wmwx.oop.Demo06.Person;
import com.wmwx.oop.Demo06.Student;
//启动类
public class Application {
public static void main(String[] args) {
//高 ----------------- 低
Person person = new Student();
((Student)person).walk(); //强制类型转换
Student student = new Student();
Person obj = student; //子类转换为父类,可能会丢失一些方法
//obj.walk(); //编译时报错
}
}
静态代码块会在类加载时执行,且只会执行一次。
示例:
Person类:
package com.wmwx.oop.Demo07;
public class Person {
//第二个执行,可在这里赋初始值
{
System.out.println("匿名代码块");
}
//第一个执行,只执行一次
static {
System.out.println("静态代码块");
}
//第三个执行
public Person() {
System.out.println("构造方法");
}
}
Application类:
package com.wmwx.oop;
import com.wmwx.oop.Demo07.Person;
//启动类
public class Application {
public static void main(String[] args) {
Person person = new Person();
//第一行输出"静态代码块"
//第二行输出"匿名代码块"
//第三行输出"构造方法"
}
}
在Java语言中使用abstract 来定义抽象类,其基本语法如下:
abstract class 类名{
//属性
//方法
}
抽象类除了不能实例化对象之外,类的其它功能依然存在,成员变量、成员方法和构造方法的访问方式和普通类一样。
由于抽象类不能实例化对象,所以抽象类必须被继承,才能被使用。在Java中一个类只能继承一个抽象类,但一个类可以实现多个接口。
在Java语言中使用abstract 来定义抽象方法,其基本语法如下:
abstract 访问修饰符 返回值类型 方法名(参数);
抽象类与抽象方法的规则:
示例:
Action类:
package com.wmwx.oop.Demo08;
//使用abstract声明抽象类
public abstract class Action {
//抽象方法,只有方法名,没有方法体
//仅作约束,期待他人实现
public abstract void doSomething();
}
A类:
package com.wmwx.oop.Demo08;
public class A extends Action{
//子类必须实现父类的抽象方法
//除非该子类是抽象类
@Override
public void doSomething() {
}
}
接口在JAVA编程语言中是一个抽象类型,是抽象方法的集合,通常以 interface 来声明。其基本语法如下:
[访问修饰符] interface 接口名称 [extends 其他的接口名称] {
// 抽象方法
}
接口的特性:
当类实现接口的时候,需要实现接口中所有的方法。否则,类必须声明为抽象的类。Java中使用 implements 关键字实现接口,其基本语法如下:
class 类名 implements 方法名{
//实现接口中的抽象方法
}
示例:
UserService接口:
package com.wmwx.oop.Demo09;
//定义接口使用关键字interface
public interface UserService {
//接口中的所有属性都是public static final
//一般不在接口中定义属性
int age = 60;
//接口中的所有方法都是public abstract
void add(String name);
void delete(String name);
void update(String name);
void query(String name);
}
TimeService接口:
package com.wmwx.oop.Demo09;
public interface TimeService {
void timer();
}
UserServiceImpl类:
package com.wmwx.oop.Demo09;
//类使用关键字implements来实现接口
//实现了接口的类,需要重写接口的所有方法
//一个类可以实现多个接口
public class UserServiceImpl implements UserService, TimeService{
@Override
public void add(String name) {
}
@Override
public void delete(String name) {
}
@Override
public void update(String name) {
}
@Override
public void query(String name) {
}
@Override
public void timer() {
}
}
所谓内部类,就是在一个类的内部再定义一个类。
示例:
Outer类:
package com.wmwx.oop.Demo10;
//外部类
public class Outer {
private int id=10;
public void out(){
System.out.println("这是外部类的方法!");
}
public class Inner{
public void in(){
System.out.println("这是内部类的方法!");
}
//获得外部类的私有属性
public int getId(){
return id;
}
}
public void method(){
//局部内部类,在外部类的方法之中
class Inner{
}
}
}
//一个java文件可以有多个class,但是只能有一个public class
class A{
}
Application类:
package com.wmwx.oop;
import com.wmwx.oop.Demo09.UserService;
import com.wmwx.oop.Demo10.Outer;
//启动类
public class Application {
public static void main(String[] args) {
//外部类使用new关键字
Outer outer = new Outer();
outer.out();
//内部类通过外部类来实例化
Outer.Inner inner = outer.new Inner();
inner.in();
System.out.println(inner.getId());
//匿名类,不用将实例保存到变量中
new Outer().out();
//使用匿名类实现接口
UserService userService = new UserService() {
@Override
public void add(String name) {
}
@Override
public void delete(String name) {
}
@Override
public void update(String name) {
}
@Override
public void query(String name) {
}
}
}
}
本文系转载,前往查看
如有侵权,请联系 cloudcommunity@tencent.com 删除。
本文系转载,前往查看
如有侵权,请联系 cloudcommunity@tencent.com 删除。