······
目录
（OOP即object-oriented programming）
作为一个资深的小白翻身专家，今天就给大家倒倒我的面向对象学习史以及一些有趣的学习认知。
与面向对象相对的就是面向过程，接下来我们区分一下面向对象和面向过程。
面向过程特点：
面向对象特点：
总结：
对于描述复杂事物，为了从宏观上把握，我们要运用面向对象的思想从整体上合理分析整个系统；但具体到微观操作，仍需要用面向过程的思路去处理。
面向对象本质：以类的方式组织代码，以对象的方式封装数据。
从认识角度考虑先有对象后有类。对象是具体的，类时抽象的，类是对象的抽象
从代码运行角度考虑是仙有泪后有对象。类是对象的模板
土豆就是蔬菜类的一个具体实例，狗也是动物类的一个具体实例，苹果也是水果类的具体实例
温馨提示：
如果在观看代码的过程中不懂方法为何如此调用，可以详见：java中方法详解
/**
使用new关键字创建对象
使用new关键字创建是，除了分配内存空间之外，还会给创建好的对象进行默认的初始化以及类中构造器的调用
构造器又名构造方法，创建对象时必须调用。
构造器特点：
1、必须和类的名字相同；
2、必须没有返回类型，也不能写void
*/
public class Application{
public static void main(String[] args){
Person p = new Person();
System.out.println("姓名："+p.name+"证件号："+p.personID+"性别："+p.sex+"身高为"+heigt)；
p.name = "小李子";
p.personID=101214192830144143L;
p.sex = '男';
p.heigt = 172;
System.out.println("姓名："+p.name+"证件号："+p.personID+"性别："+p.sex+"身高为"+heigt)；
p.saySomething();
}
}
/*
类中含属性和功能两部分，可以单独存在。
属性： 字段Field 即成员变量
功能： 成员方法
但记住事物的存在肯定是有它的形态和存在价值的！！！
*/
class Person{
String name;
Long personID;
char sex;
int heigt;
public static void saySomething(){
System.out.print("啊~~~");
}
}构造器又名构造方法，创建对象时必须调用。
/*
格式：
修饰符 类名(参数列表){}
*/
public class Student{
//与类名相同，无返回值类型，不写时，系统会默认给出构造器
public Student(){
}
}
特点：
注意：
/*
以下程序报错原因：
使用new关键字，本质实在调用构造器
一旦定义了有参构造，系统就不会自动提供无参构造
如果想使用无参构造，需要重新显示定义无参构造
*/
public class Application{
public static void main(String[] args){
Student st = new Student();// 此时程序会报错
}
}
class Student{
String name;
/*
//如果想要不报错，自己在定义一个无参的构造方法
public Student(){
}
*/
//下面定义一个有参构造
public Student(String name){
this.name = name;
}
}Alt+insert-->自动生成构造方法
作用：
将非直接用的内容存放在盒子里，同时打开一个出口能够获取直接用的内容。即（该露的露，该藏的藏）
程序设计追求“高内聚，低耦合”，
高内聚，指类的内部数据操作细节自己完成，不允许外部干涉；
低耦合，指仅暴露少量的方法给外部使用。
通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏
将属性私有，使用get/set方法
public class Application{
public static void main(String[] args){
Person p = new Person();
System.out.println("姓名："+p.name+"证件号："+p.personID+"性别："+p.sex+"身高为"+heigt)；
/*new出的对象不能直接调用私有的Person属性，会报错如：‘name’has private access in 'Person'
如果想要调用Person属性，需要提供get、set方法
p.name = "小李子";
p.personID=101214192830144143L;
p.sex = '男';
p.heigt = 172;
*/
/*
p.setName("小李子");
p.setPersonID(101214192830144143L);
p.setSex('男');
p.setHeight(172);
*/
System.out.println("姓名："+p.getName()+"证件号："+p.getPersonID()+"性别："+p.getSex()+"身高为"+ p.getHeight())；
p.saySomething();
}
}
class Person{
//属性私有
private String name;
private Long personID;
private char sex;
private int heigt;
//提供一些可以操作私有属性的方法
//提供一些public的get、set方法
//get获得私有属性的数据
public String getName(){
return this.name;
}
//set给这个数据设置值
public void setName(String name){
this.name = name;
}
public String getPersonID(){
return this.personID;
}
public void setPersonID(Long personID){
this.personID = personID;
}
public String getSex(){
return this.Sex;
}
public void setSex(char sex){
this.sex = sex;
}
public String getHeight(){
return this.height;
}
public void setHeight(int height){
this.height = height;
}
public static void saySomething(){
System.out.print("啊~~~");
}
}继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模
extends：扩展。即自子类是父类的扩展，子类 is one of the 父类
class 子类 extends 父类{
}继承关系的两个类，一个为子类（派生类），一个为父类（基类）。子类继承父类，使用关键字extends表示
java中类只有单继承，没有多继承,可以多层继承
class Person{
String name;
int age;
char sex;
int height;
public static void say(){
}
}
class Student extends Person{
int learningID;
double score;
public static void learning(){
}
}
//父类可以由多个子类继承
class Teacher extends Person{
int teachID;
double salary;
public static void teaching(){
}
}
/*
多层继承演示:
Teenager既具备Student的属性和特征，
也具备Person的属性和特征，
同时还具备object的属性和特征
*/
class Teenager extends Student{
private int age;
public static void setAge(int age){
if(age>19||age<11){
System.out.println("非法青少年");
}else{
this.age = age;
}
}
}继承是类与类之间的一种关系。除此之外，类和类之间的关系还有依赖、组合、聚合
/*
this.name指成员变量
赋值的name是局部变量
*/
public class Student{
private String name;
public static void getName(String name){
this.name = name;
}
}this VS super：
this：代表本类对象的应用
super：代表父类对象的应用
this： 无继承关系（本类中）即可使用
super：只能在继承前提下方（即子类中）可使用
this() : 本类的构造
super()：父类的构造
注意必须要放在构造方法中的第一行
/*
子类中的构造方法会默认调用父类中无参的构造方法
虽然没有直接写super（），但默认有super()
如果父类中没有无参的构造方法，子类的构造方法必须要直接或者间接调用到父类中的构造方法
简而言之，子类中的构造方法必须要用到父类中的构造方法
*/
public class Application{
public static void main(String[] args){
// Person p = new Person();// 打印：我是父类人类的构造方法
// 先打印我是父类人类的构造方法，然后打印我是子类学生类构造方法
Student st = new Student();
}
}
class Person{
/* public Person(){
System.out.println("我是父类人类的构造方法");
}
*/
public Person(String p){
System.out.println("我是父类人类的构造方法");
}
}
class Student extends Person{
public Student(){
super("调用有参构造方法");
System.out.println("我是子类学生类的构造方法");
}
}
思考：为什么子类构造方法必须调用父类构造方法
子类构造方法调用父类构造方法目的是为了完成父类中数据的初始化。
需要有继承关系，子类重写父类的方法
/*
方法的重写一定是仅针对方法，跟属性无关
方法的调用仅和左侧定义的数据类型有关，会根据引用数据类型中的方法决定调用结果
静态方法和非静态方法区别很大
方法的重写只与非静态方法有关系
*/
public class application{
public static void main(String[] args){
Student st = new Student();
st.say();//打印：我是学生类中的静态方法
Person st1 = new Student();//父类的引用指向子类
st1.say();//打印：我是人类中的静态方法
st.cry();//打印：啊~~，我是学生类中的非静态方法
st1.cry(); //打印：啊~~，我是学生类中的非静态方法
st.smile();//哈哈哈，我是人类中的非静态方法
st1.smile();//哈哈哈，我是人类中的非静态方法 哈哈哈，我是学生类中的非静态方法
}
}
class Student extends Person{
public static void say(){
System.out.println("我是学生类中的静态方法");
}
public void cry(){
System.out.println("啊~~，我是学生类中的非静态方法");
}
@Override
public void smile() {
// TODO Auto-generated method stub
super.smile();
System.out.println("哈哈哈，我是学生类中非静态方法");
}
}
class Person{
public static void say(){
System.out.println("我是人类中的静态方法");
}
public void cry(){
System.out.println("我是人类中的非静态方法");
}
public void smile() {
System.out.println("哈哈哈，我是人类中的非静态方法");
}
}思考：为什么要重写？
父类的功能，子类不一定需要，活着不一定满足
继承中的成员变量的关系：
public Application{
public static void main(String[] args){
Student st = new Student();
System.out.println(st.country);//打印结果为 USA,如果Student类中没有，则为China
st.show("India");//打印结果依次为India、USA、China
}
}
class Person{
String name;
int age;
double weight;
String country = "China"；
public void say(){
}
}
class Student extends Person{
String name;
int grade;
int score;
String country = "USA";
public void test(){
}
public void show(String country){
System.out.println(country);//就近原则
System.out.println(this.country);//this关键字的应用指向成员变量
System.out.println(super.country);//super关键字的应用指向父类中的成员变量
}
}public class application{
public static void main(String[] args){
Student st = new Student();
Student.say();//打印：我是学生类中的静态方法
Person st1 = new Student();//父类的引用指向子类
Person.say();//打印：我是人类中的静态方法
st.cry();//打印：啊~~，我是学生类中的非静态方法
/*
父类不可以调子类中独有的方法，如果想要调用需要强制转换((Student)st1).cry()
st1.cry(); //报错：ClassCastException
*/
st.smile();//哈哈哈，我是人类中的非静态方法
st1.smile();//哈哈哈，我是人类中的非静态方法 哈哈哈，我是学生类中的非静态方法
}
}
class Student extends Person{
//含static的方法是静态的方法，类名直接调用，尽量不适用对象调用
public static void say(){
System.out.println("我是学生类中的静态方法");
}
public void cry(){
System.out.println("啊~~，我是学生类中的非静态方法");
}
@Override
public void smile() {
// TODO Auto-generated method stub
super.smile();
System.out.println("哈哈哈，我是学生类中非静态方法");
}
}
class Person{
//含static的方法是静态的方法，类名直接调用，尽量不适用对象调用
public static void say(){
System.out.println("我是人类中的静态方法");
}
public void smile() {
System.out.println("哈哈哈，我是人类中的非静态方法");
}
}多态是方法的多态，属性没有多态
父类和子类有继承关系，如果想让父类的对象调用子类的方法，需要进行强制转换
容易出现类型转换异常 ClassCastException
存在条件：继承关系，方法需要重写@Override，
父类引用指向子类对象 Person p= new Student();
instanceof （类型转换）引用类型 ，判断一个对象是什么类型
//如果A与B存在继承关系，那么结果为true，否则为false。
System.out.println(A instanceof B);子类继承父类，向上转型直接转，向下转型需要用强转，过程中可能会损失精度。
public class Student{
public static void main(String[] args){
Student st = new Student();
/* 执行结果依次为：
我是静态代码块
我是匿名代码块
我是构造代码块
通过打印结果我们能够得出执行速度：静态代码块>匿名代码块>构造代码块
*/
Student st1 = new Student();
/* 执行结果依次为：
我是匿名代码块
我是构造代码块
静态代码块只执行1次
*/
}
//代码块（匿名代码块）可以赋初始值
{
System.out.println("我是匿名代码块");
}
//静态代码块
static{
System.out.println("我是静态代码块");
}
//构造方法
public Student(){
System.out.prinln("我是构造方法");
}
}执行速度：静态代码块>匿名代码块>构造代码块
/*
抽象类也是单继承
格式：public abstract class 类名{}
抽象类不能new只能靠子类去实现它：约束
抽象方法必须在抽象类中
抽象类中可以写普通的方法
*/
public abstract class Description{
/*
抽象方法须有关键字abstract
抽象方法只有方法名没有方法实现,需要被实现，因此引入继承
*/
public abstract void sayStory();
}思考： 抽象类中有构造器吗？
无法创建对象，那是没有构造器的。
抽象类存在的意义是什么？
抽象出来，提高开发效率
约束和实现分离：面向接口编程
接口就是规范，定义的是一组规则，体现了现实世界中“如果你是~~则必须能做~~”
接口的本质是契约，就想法律一样，一旦制定，在大环境下都需要遵守
面向对象（OO）的精髓，是对对象的抽象，最能体现这一点的是接口。
/*
类可以实现接口，表现形式：A implements B
只要实现了接口的类就需要重写接口中的方法
接口是可以实现多继承的
*/
public class UserImpl implements UserService,TimeService{
public void add(String name) {
// TODO Auto-generated method stub
}
public void delete(String name) {
// TODO Auto-generated method stub
}
public void update(String name) {
// TODO Auto-generated method stub
}
public void quary(String name) {
// TODO Auto-generated method stub
}
public void timer() {
// TODO Auto-generated method stub
}
}
//接口都需要有实现类，定义的关键字是interface
public interface UserService{
//静态常量 public static final可以不写
public static final int AGE = 15;
//接口中所有定义其实都是抽象的 public abstract
void add(String name);
void delete(String name);
void update(String name);
void query(String name);
}
public interface TimeService{
void timer();
}在一个类的内部再定义一个类，如A类中定义一个B类，那么B类相对A类来说就成为内部类
class OutClass{
System.out.println("我是外部类");
class InnerClass{
System.out.println("我是内部类");
}
}/**
成员内部类的演示效果
可以获得外部类的私有属性和私有方法
调用前要先通过外部类实例化内部类
*/
class ApplicationTest{
public static void main(String[] args){
//测试是否可以new内部类和外部类,如何保障正常调用
OuterDemo od = new OuterDemo();
//通过这个外部类来实例化内部类~
OuterDemo.InnerDemo id = od.new InnerDemo();
id.getID();//得到的打印结果为1012；
}
}
public class OuterDemo{
private int id = 1012;
public void out(){
System.out.println("这是外部类的方法");
}
public class InnerDemo{
public void in(){
System.out.println("这是内部类的方法");
}
//获得外部类的私有属性
public void getID(){
System.out.println(id);
}
}
}/**
静态内部类的演示效果
不可以获得外部类的私有属性和私有方法，因为static为内存分配，在没有创建对象前已经存在
*/
class ApplicationTest{
public static void main(String[] args){
//测试是否可以new内部类和外部类,如何保障正常调用
OuterDemo od = new OuterDemo();
//通过这个外部类来实例化内部类~
OuterDemo.InnerDemo id = od.new InnerDemo();
// id.getID();//报错，static内存直接分配；
}
}
public class OuterDemo{
private int id = 1012;
public void out(){
System.out.println("这是外部类的方法");
}
public static class InnerDemo{
public void in(){
System.out.println("这是内部类的方法");
}
/*不能获得外部类的私有属性
public void getID(){
System.out.println(id);
}
*/
}
}/**
局部内部类的演示效果
*/
public class ApplicationTest{
public static void main(String[] args){
OuterDemo od = new OuterDemo();
}
}
public class OuterDemo{
//局部内部类
public void method(){
class InnerDemo{
public void in(){
}
}
}
}/**
匿名内部类的展示效果
*/
public class Test{
public static void main(String[] args){
//没有名字初始化类,不用将实例保存到变量中
new NameClass().myName();
}
}
class NameClass{
public void myName(){
System.out.println("我的名字叫测试匿名内部类");
}
}因工作比较忙，更新的不够及时，望小伙伴们海涵。
作品会及时更新，更多内容也可以观看www.51doit.cn